@ichaingo/web-worker 1.3.94

package/dist/assets/webWorker-CvepzMkT.js

@@ -0,0 +1,1419 @@
+var Ge = Object.defineProperty;
+var Be = (v, r, h) => r in v ? Ge(v, r, { enumerable: !0, configurable: !0, writable: !0, value: h }) : v[r] = h;
+var D = (v, r, h) => Be(v, typeof r != "symbol" ? r + "" : r, h);
+var Ie;
+(function(v) {
+  v.ALL_CHAIN_LATEST_BLOCK = "allChainLatestBlock", v.CHAIN_LATEST_BLOCK = "chainLatestBlock";
+})(Ie || (Ie = {}));
+var P;
+(function(v) {
+  v.CONNECTING = "connecting", v.CONNECTED = "connected", v.DISCONNECTED = "disconnected", v.RECONNECTING = "reconnecting", v.ERROR = "error";
+})(P || (P = {}));
+var Ee = { exports: {} }, f = {};
+/**
+ * @license React
+ * react.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Me;
+function Ke() {
+  if (Me) return f;
+  Me = 1;
+  var v = Symbol.for("react.transitional.element"), r = Symbol.for("react.portal"), h = Symbol.for("react.fragment"), b = Symbol.for("react.strict_mode"), M = Symbol.for("react.profiler"), k = Symbol.for("react.consumer"), z = Symbol.for("react.context"), O = Symbol.for("react.forward_ref"), A = Symbol.for("react.suspense"), $ = Symbol.for("react.memo"), G = Symbol.for("react.lazy"), F = Symbol.iterator;
+  function ue(t) {
+    return t === null || typeof t != "object" ? null : (t = F && t[F] || t["@@iterator"], typeof t == "function" ? t : null);
+  }
+  var x = {
+    isMounted: function() {
+      return !1;
+    },
+    enqueueForceUpdate: function() {
+    },
+    enqueueReplaceState: function() {
+    },
+    enqueueSetState: function() {
+    }
+  }, J = Object.assign, ie = {};
+  function H(t, o, c) {
+    this.props = t, this.context = o, this.refs = ie, this.updater = c || x;
+  }
+  H.prototype.isReactComponent = {}, H.prototype.setState = function(t, o) {
+    if (typeof t != "object" && typeof t != "function" && t != null)
+      throw Error(
+        "takes an object of state variables to update or a function which returns an object of state variables."
+      );
+    this.updater.enqueueSetState(this, t, o, "setState");
+  }, H.prototype.forceUpdate = function(t) {
+    this.updater.enqueueForceUpdate(this, t, "forceUpdate");
+  };
+  function Q() {
+  }
+  Q.prototype = H.prototype;
+  function ee(t, o, c) {
+    this.props = t, this.context = o, this.refs = ie, this.updater = c || x;
+  }
+  var L = ee.prototype = new Q();
+  L.constructor = ee, J(L, H.prototype), L.isPureReactComponent = !0;
+  var ae = Array.isArray, g = { H: null, A: null, T: null, S: null, V: null }, te = Object.prototype.hasOwnProperty;
+  function ne(t, o, c, a, _, R) {
+    return c = R.ref, {
+      $$typeof: v,
+      type: t,
+      key: o,
+      ref: c !== void 0 ? c : null,
+      props: R
+    };
+  }
+  function Y(t, o) {
+    return ne(
+      t.type,
+      o,
+      void 0,
+      void 0,
+      void 0,
+      t.props
+    );
+  }
+  function U(t) {
+    return typeof t == "object" && t !== null && t.$$typeof === v;
+  }
+  function me(t) {
+    var o = { "=": "=0", ":": "=2" };
+    return "$" + t.replace(/[=:]/g, function(c) {
+      return o[c];
+    });
+  }
+  var T = /\/+/g;
+  function re(t, o) {
+    return typeof t == "object" && t !== null && t.key != null ? me("" + t.key) : o.toString(36);
+  }
+  function B() {
+  }
+  function K(t) {
+    switch (t.status) {
+      case "fulfilled":
+        return t.value;
+      case "rejected":
+        throw t.reason;
+      default:
+        switch (typeof t.status == "string" ? t.then(B, B) : (t.status = "pending", t.then(
+          function(o) {
+            t.status === "pending" && (t.status = "fulfilled", t.value = o);
+          },
+          function(o) {
+            t.status === "pending" && (t.status = "rejected", t.reason = o);
+          }
+        )), t.status) {
+          case "fulfilled":
+            return t.value;
+          case "rejected":
+            throw t.reason;
+        }
+    }
+    throw t;
+  }
+  function j(t, o, c, a, _) {
+    var R = typeof t;
+    (R === "undefined" || R === "boolean") && (t = null);
+    var p = !1;
+    if (t === null) p = !0;
+    else
+      switch (R) {
+        case "bigint":
+        case "string":
+        case "number":
+          p = !0;
+          break;
+        case "object":
+          switch (t.$$typeof) {
+            case v:
+            case r:
+              p = !0;
+              break;
+            case G:
+              return p = t._init, j(
+                p(t._payload),
+                o,
+                c,
+                a,
+                _
+              );
+          }
+      }
+    if (p)
+      return _ = _(t), p = a === "" ? "." + re(t, 0) : a, ae(_) ? (c = "", p != null && (c = p.replace(T, "$&/") + "/"), j(_, o, c, "", function(V) {
+        return V;
+      })) : _ != null && (U(_) && (_ = Y(
+        _,
+        c + (_.key == null || t && t.key === _.key ? "" : ("" + _.key).replace(
+          T,
+          "$&/"
+        ) + "/") + p
+      )), o.push(_)), 1;
+    p = 0;
+    var I = a === "" ? "." : a + ":";
+    if (ae(t))
+      for (var w = 0; w < t.length; w++)
+        a = t[w], R = I + re(a, w), p += j(
+          a,
+          o,
+          c,
+          R,
+          _
+        );
+    else if (w = ue(t), typeof w == "function")
+      for (t = w.call(t), w = 0; !(a = t.next()).done; )
+        a = a.value, R = I + re(a, w++), p += j(
+          a,
+          o,
+          c,
+          R,
+          _
+        );
+    else if (R === "object") {
+      if (typeof t.then == "function")
+        return j(
+          K(t),
+          o,
+          c,
+          a,
+          _
+        );
+      throw o = String(t), Error(
+        "Objects are not valid as a React child (found: " + (o === "[object Object]" ? "object with keys {" + Object.keys(t).join(", ") + "}" : o) + "). If you meant to render a collection of children, use an array instead."
+      );
+    }
+    return p;
+  }
+  function W(t, o, c) {
+    if (t == null) return t;
+    var a = [], _ = 0;
+    return j(t, a, "", "", function(R) {
+      return o.call(c, R, _++);
+    }), a;
+  }
+  function oe(t) {
+    if (t._status === -1) {
+      var o = t._result;
+      o = o(), o.then(
+        function(c) {
+          (t._status === 0 || t._status === -1) && (t._status = 1, t._result = c);
+        },
+        function(c) {
+          (t._status === 0 || t._status === -1) && (t._status = 2, t._result = c);
+        }
+      ), t._status === -1 && (t._status = 0, t._result = o);
+    }
+    if (t._status === 1) return t._result.default;
+    throw t._result;
+  }
+  var X = typeof reportError == "function" ? reportError : function(t) {
+    if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+      var o = new window.ErrorEvent("error", {
+        bubbles: !0,
+        cancelable: !0,
+        message: typeof t == "object" && t !== null && typeof t.message == "string" ? String(t.message) : String(t),
+        error: t
+      });
+      if (!window.dispatchEvent(o)) return;
+    } else if (typeof process == "object" && typeof process.emit == "function") {
+      process.emit("uncaughtException", t);
+      return;
+    }
+    console.error(t);
+  };
+  function ce() {
+  }
+  return f.Children = {
+    map: W,
+    forEach: function(t, o, c) {
+      W(
+        t,
+        function() {
+          o.apply(this, arguments);
+        },
+        c
+      );
+    },
+    count: function(t) {
+      var o = 0;
+      return W(t, function() {
+        o++;
+      }), o;
+    },
+    toArray: function(t) {
+      return W(t, function(o) {
+        return o;
+      }) || [];
+    },
+    only: function(t) {
+      if (!U(t))
+        throw Error(
+          "React.Children.only expected to receive a single React element child."
+        );
+      return t;
+    }
+  }, f.Component = H, f.Fragment = h, f.Profiler = M, f.PureComponent = ee, f.StrictMode = b, f.Suspense = A, f.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = g, f.__COMPILER_RUNTIME = {
+    __proto__: null,
+    c: function(t) {
+      return g.H.useMemoCache(t);
+    }
+  }, f.cache = function(t) {
+    return function() {
+      return t.apply(null, arguments);
+    };
+  }, f.cloneElement = function(t, o, c) {
+    if (t == null)
+      throw Error(
+        "The argument must be a React element, but you passed " + t + "."
+      );
+    var a = J({}, t.props), _ = t.key, R = void 0;
+    if (o != null)
+      for (p in o.ref !== void 0 && (R = void 0), o.key !== void 0 && (_ = "" + o.key), o)
+        !te.call(o, p) || p === "key" || p === "__self" || p === "__source" || p === "ref" && o.ref === void 0 || (a[p] = o[p]);
+    var p = arguments.length - 2;
+    if (p === 1) a.children = c;
+    else if (1 < p) {
+      for (var I = Array(p), w = 0; w < p; w++)
+        I[w] = arguments[w + 2];
+      a.children = I;
+    }
+    return ne(t.type, _, void 0, void 0, R, a);
+  }, f.createContext = function(t) {
+    return t = {
+      $$typeof: z,
+      _currentValue: t,
+      _currentValue2: t,
+      _threadCount: 0,
+      Provider: null,
+      Consumer: null
+    }, t.Provider = t, t.Consumer = {
+      $$typeof: k,
+      _context: t
+    }, t;
+  }, f.createElement = function(t, o, c) {
+    var a, _ = {}, R = null;
+    if (o != null)
+      for (a in o.key !== void 0 && (R = "" + o.key), o)
+        te.call(o, a) && a !== "key" && a !== "__self" && a !== "__source" && (_[a] = o[a]);
+    var p = arguments.length - 2;
+    if (p === 1) _.children = c;
+    else if (1 < p) {
+      for (var I = Array(p), w = 0; w < p; w++)
+        I[w] = arguments[w + 2];
+      _.children = I;
+    }
+    if (t && t.defaultProps)
+      for (a in p = t.defaultProps, p)
+        _[a] === void 0 && (_[a] = p[a]);
+    return ne(t, R, void 0, void 0, null, _);
+  }, f.createRef = function() {
+    return { current: null };
+  }, f.forwardRef = function(t) {
+    return { $$typeof: O, render: t };
+  }, f.isValidElement = U, f.lazy = function(t) {
+    return {
+      $$typeof: G,
+      _payload: { _status: -1, _result: t },
+      _init: oe
+    };
+  }, f.memo = function(t, o) {
+    return {
+      $$typeof: $,
+      type: t,
+      compare: o === void 0 ? null : o
+    };
+  }, f.startTransition = function(t) {
+    var o = g.T, c = {};
+    g.T = c;
+    try {
+      var a = t(), _ = g.S;
+      _ !== null && _(c, a), typeof a == "object" && a !== null && typeof a.then == "function" && a.then(ce, X);
+    } catch (R) {
+      X(R);
+    } finally {
+      g.T = o;
+    }
+  }, f.unstable_useCacheRefresh = function() {
+    return g.H.useCacheRefresh();
+  }, f.use = function(t) {
+    return g.H.use(t);
+  }, f.useActionState = function(t, o, c) {
+    return g.H.useActionState(t, o, c);
+  }, f.useCallback = function(t, o) {
+    return g.H.useCallback(t, o);
+  }, f.useContext = function(t) {
+    return g.H.useContext(t);
+  }, f.useDebugValue = function() {
+  }, f.useDeferredValue = function(t, o) {
+    return g.H.useDeferredValue(t, o);
+  }, f.useEffect = function(t, o, c) {
+    var a = g.H;
+    if (typeof c == "function")
+      throw Error(
+        "useEffect CRUD overload is not enabled in this build of React."
+      );
+    return a.useEffect(t, o);
+  }, f.useId = function() {
+    return g.H.useId();
+  }, f.useImperativeHandle = function(t, o, c) {
+    return g.H.useImperativeHandle(t, o, c);
+  }, f.useInsertionEffect = function(t, o) {
+    return g.H.useInsertionEffect(t, o);
+  }, f.useLayoutEffect = function(t, o) {
+    return g.H.useLayoutEffect(t, o);
+  }, f.useMemo = function(t, o) {
+    return g.H.useMemo(t, o);
+  }, f.useOptimistic = function(t, o) {
+    return g.H.useOptimistic(t, o);
+  }, f.useReducer = function(t, o, c) {
+    return g.H.useReducer(t, o, c);
+  }, f.useRef = function(t) {
+    return g.H.useRef(t);
+  }, f.useState = function(t) {
+    return g.H.useState(t);
+  }, f.useSyncExternalStore = function(t, o, c) {
+    return g.H.useSyncExternalStore(
+      t,
+      o,
+      c
+    );
+  }, f.useTransition = function() {
+    return g.H.useTransition();
+  }, f.version = "19.1.1", f;
+}
+var se = { exports: {} };
+/**
+ * @license React
+ * react.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+se.exports;
+var $e;
+function Qe() {
+  return $e || ($e = 1, (function(v, r) {
+    process.env.NODE_ENV !== "production" && (function() {
+      function h(e, n) {
+        Object.defineProperty(k.prototype, e, {
+          get: function() {
+            console.warn(
+              "%s(...) is deprecated in plain JavaScript React classes. %s",
+              n[0],
+              n[1]
+            );
+          }
+        });
+      }
+      function b(e) {
+        return e === null || typeof e != "object" ? null : (e = ve && e[ve] || e["@@iterator"], typeof e == "function" ? e : null);
+      }
+      function M(e, n) {
+        e = (e = e.constructor) && (e.displayName || e.name) || "ReactClass";
+        var s = e + "." + n;
+        Re[s] || (console.error(
+          "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
+          n,
+          e
+        ), Re[s] = !0);
+      }
+      function k(e, n, s) {
+        this.props = e, this.context = n, this.refs = _e, this.updater = s || Te;
+      }
+      function z() {
+      }
+      function O(e, n, s) {
+        this.props = e, this.context = n, this.refs = _e, this.updater = s || Te;
+      }
+      function A(e) {
+        return "" + e;
+      }
+      function $(e) {
+        try {
+          A(e);
+          var n = !1;
+        } catch {
+          n = !0;
+        }
+        if (n) {
+          n = console;
+          var s = n.error, u = typeof Symbol == "function" && Symbol.toStringTag && e[Symbol.toStringTag] || e.constructor.name || "Object";
+          return s.call(
+            n,
+            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+            u
+          ), A(e);
+        }
+      }
+      function G(e) {
+        if (e == null) return null;
+        if (typeof e == "function")
+          return e.$$typeof === Ye ? null : e.displayName || e.name || null;
+        if (typeof e == "string") return e;
+        switch (e) {
+          case t:
+            return "Fragment";
+          case c:
+            return "Profiler";
+          case o:
+            return "StrictMode";
+          case p:
+            return "Suspense";
+          case I:
+            return "SuspenseList";
+          case He:
+            return "Activity";
+        }
+        if (typeof e == "object")
+          switch (typeof e.tag == "number" && console.error(
+            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+          ), e.$$typeof) {
+            case ce:
+              return "Portal";
+            case _:
+              return (e.displayName || "Context") + ".Provider";
+            case a:
+              return (e._context.displayName || "Context") + ".Consumer";
+            case R:
+              var n = e.render;
+              return e = e.displayName, e || (e = n.displayName || n.name || "", e = e !== "" ? "ForwardRef(" + e + ")" : "ForwardRef"), e;
+            case w:
+              return n = e.displayName || null, n !== null ? n : G(e.type) || "Memo";
+            case V:
+              n = e._payload, e = e._init;
+              try {
+                return G(e(n));
+              } catch {
+              }
+          }
+        return null;
+      }
+      function F(e) {
+        if (e === t) return "<>";
+        if (typeof e == "object" && e !== null && e.$$typeof === V)
+          return "<...>";
+        try {
+          var n = G(e);
+          return n ? "<" + n + ">" : "<...>";
+        } catch {
+          return "<...>";
+        }
+      }
+      function ue() {
+        var e = E.A;
+        return e === null ? null : e.getOwner();
+      }
+      function x() {
+        return Error("react-stack-top-frame");
+      }
+      function J(e) {
+        if (le.call(e, "key")) {
+          var n = Object.getOwnPropertyDescriptor(e, "key").get;
+          if (n && n.isReactWarning) return !1;
+        }
+        return e.key !== void 0;
+      }
+      function ie(e, n) {
+        function s() {
+          Ce || (Ce = !0, console.error(
+            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+            n
+          ));
+        }
+        s.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: s,
+          configurable: !0
+        });
+      }
+      function H() {
+        var e = G(this.type);
+        return ke[e] || (ke[e] = !0, console.error(
+          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+        )), e = this.props.ref, e !== void 0 ? e : null;
+      }
+      function Q(e, n, s, u, i, m, l, y) {
+        return s = m.ref, e = {
+          $$typeof: X,
+          type: e,
+          key: n,
+          props: m,
+          _owner: i
+        }, (s !== void 0 ? s : null) !== null ? Object.defineProperty(e, "ref", {
+          enumerable: !1,
+          get: H
+        }) : Object.defineProperty(e, "ref", { enumerable: !1, value: null }), e._store = {}, Object.defineProperty(e._store, "validated", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: 0
+        }), Object.defineProperty(e, "_debugInfo", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: null
+        }), Object.defineProperty(e, "_debugStack", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: l
+        }), Object.defineProperty(e, "_debugTask", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: y
+        }), Object.freeze && (Object.freeze(e.props), Object.freeze(e)), e;
+      }
+      function ee(e, n) {
+        return n = Q(
+          e.type,
+          n,
+          void 0,
+          void 0,
+          e._owner,
+          e.props,
+          e._debugStack,
+          e._debugTask
+        ), e._store && (n._store.validated = e._store.validated), n;
+      }
+      function L(e) {
+        return typeof e == "object" && e !== null && e.$$typeof === X;
+      }
+      function ae(e) {
+        var n = { "=": "=0", ":": "=2" };
+        return "$" + e.replace(/[=:]/g, function(s) {
+          return n[s];
+        });
+      }
+      function g(e, n) {
+        return typeof e == "object" && e !== null && e.key != null ? ($(e.key), ae("" + e.key)) : n.toString(36);
+      }
+      function te() {
+      }
+      function ne(e) {
+        switch (e.status) {
+          case "fulfilled":
+            return e.value;
+          case "rejected":
+            throw e.reason;
+          default:
+            switch (typeof e.status == "string" ? e.then(te, te) : (e.status = "pending", e.then(
+              function(n) {
+                e.status === "pending" && (e.status = "fulfilled", e.value = n);
+              },
+              function(n) {
+                e.status === "pending" && (e.status = "rejected", e.reason = n);
+              }
+            )), e.status) {
+              case "fulfilled":
+                return e.value;
+              case "rejected":
+                throw e.reason;
+            }
+        }
+        throw e;
+      }
+      function Y(e, n, s, u, i) {
+        var m = typeof e;
+        (m === "undefined" || m === "boolean") && (e = null);
+        var l = !1;
+        if (e === null) l = !0;
+        else
+          switch (m) {
+            case "bigint":
+            case "string":
+            case "number":
+              l = !0;
+              break;
+            case "object":
+              switch (e.$$typeof) {
+                case X:
+                case ce:
+                  l = !0;
+                  break;
+                case V:
+                  return l = e._init, Y(
+                    l(e._payload),
+                    n,
+                    s,
+                    u,
+                    i
+                  );
+              }
+          }
+        if (l) {
+          l = e, i = i(l);
+          var y = u === "" ? "." + g(l, 0) : u;
+          return be(i) ? (s = "", y != null && (s = y.replace(Ne, "$&/") + "/"), Y(i, n, s, "", function(q) {
+            return q;
+          })) : i != null && (L(i) && (i.key != null && (l && l.key === i.key || $(i.key)), s = ee(
+            i,
+            s + (i.key == null || l && l.key === i.key ? "" : ("" + i.key).replace(
+              Ne,
+              "$&/"
+            ) + "/") + y
+          ), u !== "" && l != null && L(l) && l.key == null && l._store && !l._store.validated && (s._store.validated = 2), i = s), n.push(i)), 1;
+        }
+        if (l = 0, y = u === "" ? "." : u + ":", be(e))
+          for (var d = 0; d < e.length; d++)
+            u = e[d], m = y + g(u, d), l += Y(
+              u,
+              n,
+              s,
+              m,
+              i
+            );
+        else if (d = b(e), typeof d == "function")
+          for (d === e.entries && (Ae || console.warn(
+            "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
+          ), Ae = !0), e = d.call(e), d = 0; !(u = e.next()).done; )
+            u = u.value, m = y + g(u, d++), l += Y(
+              u,
+              n,
+              s,
+              m,
+              i
+            );
+        else if (m === "object") {
+          if (typeof e.then == "function")
+            return Y(
+              ne(e),
+              n,
+              s,
+              u,
+              i
+            );
+          throw n = String(e), Error(
+            "Objects are not valid as a React child (found: " + (n === "[object Object]" ? "object with keys {" + Object.keys(e).join(", ") + "}" : n) + "). If you meant to render a collection of children, use an array instead."
+          );
+        }
+        return l;
+      }
+      function U(e, n, s) {
+        if (e == null) return e;
+        var u = [], i = 0;
+        return Y(e, u, "", "", function(m) {
+          return n.call(s, m, i++);
+        }), u;
+      }
+      function me(e) {
+        if (e._status === -1) {
+          var n = e._result;
+          n = n(), n.then(
+            function(s) {
+              (e._status === 0 || e._status === -1) && (e._status = 1, e._result = s);
+            },
+            function(s) {
+              (e._status === 0 || e._status === -1) && (e._status = 2, e._result = s);
+            }
+          ), e._status === -1 && (e._status = 0, e._result = n);
+        }
+        if (e._status === 1)
+          return n = e._result, n === void 0 && console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`,
+            n
+          ), "default" in n || console.error(
+            `lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`,
+            n
+          ), n.default;
+        throw e._result;
+      }
+      function T() {
+        var e = E.H;
+        return e === null && console.error(
+          `Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem.`
+        ), e;
+      }
+      function re() {
+      }
+      function B(e) {
+        if (pe === null)
+          try {
+            var n = ("require" + Math.random()).slice(0, 7);
+            pe = (v && v[n]).call(
+              v,
+              "timers"
+            ).setImmediate;
+          } catch {
+            pe = function(u) {
+              je === !1 && (je = !0, typeof MessageChannel > "u" && console.error(
+                "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
+              ));
+              var i = new MessageChannel();
+              i.port1.onmessage = u, i.port2.postMessage(void 0);
+            };
+          }
+        return pe(e);
+      }
+      function K(e) {
+        return 1 < e.length && typeof AggregateError == "function" ? new AggregateError(e) : e[0];
+      }
+      function j(e, n) {
+        n !== de - 1 && console.error(
+          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
+        ), de = n;
+      }
+      function W(e, n, s) {
+        var u = E.actQueue;
+        if (u !== null)
+          if (u.length !== 0)
+            try {
+              oe(u), B(function() {
+                return W(e, n, s);
+              });
+              return;
+            } catch (i) {
+              E.thrownErrors.push(i);
+            }
+          else E.actQueue = null;
+        0 < E.thrownErrors.length ? (u = K(E.thrownErrors), E.thrownErrors.length = 0, s(u)) : n(e);
+      }
+      function oe(e) {
+        if (!ye) {
+          ye = !0;
+          var n = 0;
+          try {
+            for (; n < e.length; n++) {
+              var s = e[n];
+              do {
+                E.didUsePromise = !1;
+                var u = s(!1);
+                if (u !== null) {
+                  if (E.didUsePromise) {
+                    e[n] = s, e.splice(0, n);
+                    return;
+                  }
+                  s = u;
+                } else break;
+              } while (!0);
+            }
+            e.length = 0;
+          } catch (i) {
+            e.splice(0, n + 1), E.thrownErrors.push(i);
+          } finally {
+            ye = !1;
+          }
+        }
+      }
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var X = Symbol.for("react.transitional.element"), ce = Symbol.for("react.portal"), t = Symbol.for("react.fragment"), o = Symbol.for("react.strict_mode"), c = Symbol.for("react.profiler"), a = Symbol.for("react.consumer"), _ = Symbol.for("react.context"), R = Symbol.for("react.forward_ref"), p = Symbol.for("react.suspense"), I = Symbol.for("react.suspense_list"), w = Symbol.for("react.memo"), V = Symbol.for("react.lazy"), He = Symbol.for("react.activity"), ve = Symbol.iterator, Re = {}, Te = {
+        isMounted: function() {
+          return !1;
+        },
+        enqueueForceUpdate: function(e) {
+          M(e, "forceUpdate");
+        },
+        enqueueReplaceState: function(e) {
+          M(e, "replaceState");
+        },
+        enqueueSetState: function(e) {
+          M(e, "setState");
+        }
+      }, we = Object.assign, _e = {};
+      Object.freeze(_e), k.prototype.isReactComponent = {}, k.prototype.setState = function(e, n) {
+        if (typeof e != "object" && typeof e != "function" && e != null)
+          throw Error(
+            "takes an object of state variables to update or a function which returns an object of state variables."
+          );
+        this.updater.enqueueSetState(this, e, n, "setState");
+      }, k.prototype.forceUpdate = function(e) {
+        this.updater.enqueueForceUpdate(this, e, "forceUpdate");
+      };
+      var N = {
+        isMounted: [
+          "isMounted",
+          "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
+        ],
+        replaceState: [
+          "replaceState",
+          "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
+        ]
+      }, fe;
+      for (fe in N)
+        N.hasOwnProperty(fe) && h(fe, N[fe]);
+      z.prototype = k.prototype, N = O.prototype = new z(), N.constructor = O, we(N, k.prototype), N.isPureReactComponent = !0;
+      var be = Array.isArray, Ye = Symbol.for("react.client.reference"), E = {
+        H: null,
+        A: null,
+        T: null,
+        S: null,
+        V: null,
+        actQueue: null,
+        isBatchingLegacy: !1,
+        didScheduleLegacyUpdate: !1,
+        didUsePromise: !1,
+        thrownErrors: [],
+        getCurrentStack: null,
+        recentlyCreatedOwnerStacks: 0
+      }, le = Object.prototype.hasOwnProperty, Oe = console.createTask ? console.createTask : function() {
+        return null;
+      };
+      N = {
+        react_stack_bottom_frame: function(e) {
+          return e();
+        }
+      };
+      var Ce, Se, ke = {}, Ue = N.react_stack_bottom_frame.bind(
+        N,
+        x
+      )(), We = Oe(F(x)), Ae = !1, Ne = /\/+/g, Pe = typeof reportError == "function" ? reportError : function(e) {
+        if (typeof window == "object" && typeof window.ErrorEvent == "function") {
+          var n = new window.ErrorEvent("error", {
+            bubbles: !0,
+            cancelable: !0,
+            message: typeof e == "object" && e !== null && typeof e.message == "string" ? String(e.message) : String(e),
+            error: e
+          });
+          if (!window.dispatchEvent(n)) return;
+        } else if (typeof process == "object" && typeof process.emit == "function") {
+          process.emit("uncaughtException", e);
+          return;
+        }
+        console.error(e);
+      }, je = !1, pe = null, de = 0, he = !1, ye = !1, Le = typeof queueMicrotask == "function" ? function(e) {
+        queueMicrotask(function() {
+          return queueMicrotask(e);
+        });
+      } : B;
+      N = Object.freeze({
+        __proto__: null,
+        c: function(e) {
+          return T().useMemoCache(e);
+        }
+      }), r.Children = {
+        map: U,
+        forEach: function(e, n, s) {
+          U(
+            e,
+            function() {
+              n.apply(this, arguments);
+            },
+            s
+          );
+        },
+        count: function(e) {
+          var n = 0;
+          return U(e, function() {
+            n++;
+          }), n;
+        },
+        toArray: function(e) {
+          return U(e, function(n) {
+            return n;
+          }) || [];
+        },
+        only: function(e) {
+          if (!L(e))
+            throw Error(
+              "React.Children.only expected to receive a single React element child."
+            );
+          return e;
+        }
+      }, r.Component = k, r.Fragment = t, r.Profiler = c, r.PureComponent = O, r.StrictMode = o, r.Suspense = p, r.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = E, r.__COMPILER_RUNTIME = N, r.act = function(e) {
+        var n = E.actQueue, s = de;
+        de++;
+        var u = E.actQueue = n !== null ? n : [], i = !1;
+        try {
+          var m = e();
+        } catch (d) {
+          E.thrownErrors.push(d);
+        }
+        if (0 < E.thrownErrors.length)
+          throw j(n, s), e = K(E.thrownErrors), E.thrownErrors.length = 0, e;
+        if (m !== null && typeof m == "object" && typeof m.then == "function") {
+          var l = m;
+          return Le(function() {
+            i || he || (he = !0, console.error(
+              "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
+            ));
+          }), {
+            then: function(d, q) {
+              i = !0, l.then(
+                function(Z) {
+                  if (j(n, s), s === 0) {
+                    try {
+                      oe(u), B(function() {
+                        return W(
+                          Z,
+                          d,
+                          q
+                        );
+                      });
+                    } catch (ze) {
+                      E.thrownErrors.push(ze);
+                    }
+                    if (0 < E.thrownErrors.length) {
+                      var qe = K(
+                        E.thrownErrors
+                      );
+                      E.thrownErrors.length = 0, q(qe);
+                    }
+                  } else d(Z);
+                },
+                function(Z) {
+                  j(n, s), 0 < E.thrownErrors.length && (Z = K(
+                    E.thrownErrors
+                  ), E.thrownErrors.length = 0), q(Z);
+                }
+              );
+            }
+          };
+        }
+        var y = m;
+        if (j(n, s), s === 0 && (oe(u), u.length !== 0 && Le(function() {
+          i || he || (he = !0, console.error(
+            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
+          ));
+        }), E.actQueue = null), 0 < E.thrownErrors.length)
+          throw e = K(E.thrownErrors), E.thrownErrors.length = 0, e;
+        return {
+          then: function(d, q) {
+            i = !0, s === 0 ? (E.actQueue = u, B(function() {
+              return W(
+                y,
+                d,
+                q
+              );
+            })) : d(y);
+          }
+        };
+      }, r.cache = function(e) {
+        return function() {
+          return e.apply(null, arguments);
+        };
+      }, r.captureOwnerStack = function() {
+        var e = E.getCurrentStack;
+        return e === null ? null : e();
+      }, r.cloneElement = function(e, n, s) {
+        if (e == null)
+          throw Error(
+            "The argument must be a React element, but you passed " + e + "."
+          );
+        var u = we({}, e.props), i = e.key, m = e._owner;
+        if (n != null) {
+          var l;
+          e: {
+            if (le.call(n, "ref") && (l = Object.getOwnPropertyDescriptor(
+              n,
+              "ref"
+            ).get) && l.isReactWarning) {
+              l = !1;
+              break e;
+            }
+            l = n.ref !== void 0;
+          }
+          l && (m = ue()), J(n) && ($(n.key), i = "" + n.key);
+          for (y in n)
+            !le.call(n, y) || y === "key" || y === "__self" || y === "__source" || y === "ref" && n.ref === void 0 || (u[y] = n[y]);
+        }
+        var y = arguments.length - 2;
+        if (y === 1) u.children = s;
+        else if (1 < y) {
+          l = Array(y);
+          for (var d = 0; d < y; d++)
+            l[d] = arguments[d + 2];
+          u.children = l;
+        }
+        for (u = Q(
+          e.type,
+          i,
+          void 0,
+          void 0,
+          m,
+          u,
+          e._debugStack,
+          e._debugTask
+        ), i = 2; i < arguments.length; i++)
+          m = arguments[i], L(m) && m._store && (m._store.validated = 1);
+        return u;
+      }, r.createContext = function(e) {
+        return e = {
+          $$typeof: _,
+          _currentValue: e,
+          _currentValue2: e,
+          _threadCount: 0,
+          Provider: null,
+          Consumer: null
+        }, e.Provider = e, e.Consumer = {
+          $$typeof: a,
+          _context: e
+        }, e._currentRenderer = null, e._currentRenderer2 = null, e;
+      }, r.createElement = function(e, n, s) {
+        for (var u = 2; u < arguments.length; u++) {
+          var i = arguments[u];
+          L(i) && i._store && (i._store.validated = 1);
+        }
+        if (u = {}, i = null, n != null)
+          for (d in Se || !("__self" in n) || "key" in n || (Se = !0, console.warn(
+            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
+          )), J(n) && ($(n.key), i = "" + n.key), n)
+            le.call(n, d) && d !== "key" && d !== "__self" && d !== "__source" && (u[d] = n[d]);
+        var m = arguments.length - 2;
+        if (m === 1) u.children = s;
+        else if (1 < m) {
+          for (var l = Array(m), y = 0; y < m; y++)
+            l[y] = arguments[y + 2];
+          Object.freeze && Object.freeze(l), u.children = l;
+        }
+        if (e && e.defaultProps)
+          for (d in m = e.defaultProps, m)
+            u[d] === void 0 && (u[d] = m[d]);
+        i && ie(
+          u,
+          typeof e == "function" ? e.displayName || e.name || "Unknown" : e
+        );
+        var d = 1e4 > E.recentlyCreatedOwnerStacks++;
+        return Q(
+          e,
+          i,
+          void 0,
+          void 0,
+          ue(),
+          u,
+          d ? Error("react-stack-top-frame") : Ue,
+          d ? Oe(F(e)) : We
+        );
+      }, r.createRef = function() {
+        var e = { current: null };
+        return Object.seal(e), e;
+      }, r.forwardRef = function(e) {
+        e != null && e.$$typeof === w ? console.error(
+          "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
+        ) : typeof e != "function" ? console.error(
+          "forwardRef requires a render function but was given %s.",
+          e === null ? "null" : typeof e
+        ) : e.length !== 0 && e.length !== 2 && console.error(
+          "forwardRef render functions accept exactly two parameters: props and ref. %s",
+          e.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
+        ), e != null && e.defaultProps != null && console.error(
+          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
+        );
+        var n = { $$typeof: R, render: e }, s;
+        return Object.defineProperty(n, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return s;
+          },
+          set: function(u) {
+            s = u, e.name || e.displayName || (Object.defineProperty(e, "name", { value: u }), e.displayName = u);
+          }
+        }), n;
+      }, r.isValidElement = L, r.lazy = function(e) {
+        return {
+          $$typeof: V,
+          _payload: { _status: -1, _result: e },
+          _init: me
+        };
+      }, r.memo = function(e, n) {
+        e == null && console.error(
+          "memo: The first argument must be a component. Instead received: %s",
+          e === null ? "null" : typeof e
+        ), n = {
+          $$typeof: w,
+          type: e,
+          compare: n === void 0 ? null : n
+        };
+        var s;
+        return Object.defineProperty(n, "displayName", {
+          enumerable: !1,
+          configurable: !0,
+          get: function() {
+            return s;
+          },
+          set: function(u) {
+            s = u, e.name || e.displayName || (Object.defineProperty(e, "name", { value: u }), e.displayName = u);
+          }
+        }), n;
+      }, r.startTransition = function(e) {
+        var n = E.T, s = {};
+        E.T = s, s._updatedFibers = /* @__PURE__ */ new Set();
+        try {
+          var u = e(), i = E.S;
+          i !== null && i(s, u), typeof u == "object" && u !== null && typeof u.then == "function" && u.then(re, Pe);
+        } catch (m) {
+          Pe(m);
+        } finally {
+          n === null && s._updatedFibers && (e = s._updatedFibers.size, s._updatedFibers.clear(), 10 < e && console.warn(
+            "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
+          )), E.T = n;
+        }
+      }, r.unstable_useCacheRefresh = function() {
+        return T().useCacheRefresh();
+      }, r.use = function(e) {
+        return T().use(e);
+      }, r.useActionState = function(e, n, s) {
+        return T().useActionState(
+          e,
+          n,
+          s
+        );
+      }, r.useCallback = function(e, n) {
+        return T().useCallback(e, n);
+      }, r.useContext = function(e) {
+        var n = T();
+        return e.$$typeof === a && console.error(
+          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
+        ), n.useContext(e);
+      }, r.useDebugValue = function(e, n) {
+        return T().useDebugValue(e, n);
+      }, r.useDeferredValue = function(e, n) {
+        return T().useDeferredValue(e, n);
+      }, r.useEffect = function(e, n, s) {
+        e == null && console.warn(
+          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        );
+        var u = T();
+        if (typeof s == "function")
+          throw Error(
+            "useEffect CRUD overload is not enabled in this build of React."
+          );
+        return u.useEffect(e, n);
+      }, r.useId = function() {
+        return T().useId();
+      }, r.useImperativeHandle = function(e, n, s) {
+        return T().useImperativeHandle(e, n, s);
+      }, r.useInsertionEffect = function(e, n) {
+        return e == null && console.warn(
+          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), T().useInsertionEffect(e, n);
+      }, r.useLayoutEffect = function(e, n) {
+        return e == null && console.warn(
+          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
+        ), T().useLayoutEffect(e, n);
+      }, r.useMemo = function(e, n) {
+        return T().useMemo(e, n);
+      }, r.useOptimistic = function(e, n) {
+        return T().useOptimistic(e, n);
+      }, r.useReducer = function(e, n, s) {
+        return T().useReducer(e, n, s);
+      }, r.useRef = function(e) {
+        return T().useRef(e);
+      }, r.useState = function(e) {
+        return T().useState(e);
+      }, r.useSyncExternalStore = function(e, n, s) {
+        return T().useSyncExternalStore(
+          e,
+          n,
+          s
+        );
+      }, r.useTransition = function() {
+        return T().useTransition();
+      }, r.version = "19.1.1", typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+  })(se, se.exports)), se.exports;
+}
+var De;
+function Xe() {
+  return De || (De = 1, process.env.NODE_ENV === "production" ? Ee.exports = Ke() : Ee.exports = Qe()), Ee.exports;
+}
+Xe();
+const S = class S {
+  constructor(r) {
+    D(this, "socket", null);
+    D(this, "config");
+    D(this, "status", P.DISCONNECTED);
+    D(this, "reconnectAttempts", 0);
+    D(this, "reconnectTimer", null);
+    D(this, "heartbeatTimer", null);
+    D(this, "eventListeners", {});
+    this.config = {
+      reconnectInterval: 3e3,
+      maxReconnectAttempts: 5,
+      heartbeatInterval: 3e4,
+      debug: !1,
+      ...r
+    };
+  }
+  /**
+   * 获取单例实例
+   */
+  static getInstance(r) {
+    if (S.instance)
+      r && (JSON.stringify(S.instance.config) !== JSON.stringify(r) && (S.instance = new S(r)), r && (S.instance.config = {
+        ...S.instance.config,
+        ...r
+      }));
+    else {
+      if (!r)
+        throw new Error("首次创建SocketConnection实例时必须提供配置");
+      S.instance = new S(r);
+    }
+    return S.instance;
+  }
+  /**
+   * 连接WebSocket
+   */
+  connect(r) {
+    return this.config = {
+      ...this.config,
+      ...r
+    }, new Promise((h, b) => {
+      var k, z;
+      if (((k = this.socket) == null ? void 0 : k.readyState) === WebSocket.OPEN) {
+        h();
+        return;
+      }
+      const M = this.config.url + ((z = this.config) != null && z.params ? `?${Object.entries(this.config.params).map(([O, A]) => `${O}=${A}`).join("&")}` : "");
+      if (M) {
+        this.setStatus(P.CONNECTING), this.log("正在连接WebSocket...", M);
+        try {
+          this.socket = new WebSocket(M, this.config.protocols), this.setupEventListeners(), this.socket.onopen = () => {
+            var O, A;
+            this.log("WebSocket连接成功"), this.setStatus(P.CONNECTED), this.reconnectAttempts = 0, this.startHeartbeat(), (A = (O = this.eventListeners).open) == null || A.call(O), h();
+          }, this.socket.onerror = (O) => {
+            var A, $;
+            this.log("WebSocket连接错误:", O), this.setStatus(P.ERROR), ($ = (A = this.eventListeners).error) == null || $.call(A, O), b(O);
+          };
+        } catch (O) {
+          this.log("创建WebSocket连接失败:", O), this.setStatus(P.ERROR), b(O);
+        }
+      }
+    });
+  }
+  /**
+   * 断开连接
+   */
+  disconnect() {
+    this.log("正在断开WebSocket连接..."), this.stopHeartbeat(), this.clearReconnectTimer(), this.socket && (this.socket.close(1e3, "主动断开连接"), this.socket = null), this.setStatus(P.DISCONNECTED);
+  }
+  /**
+   * 发送消息
+   */
+  send(r) {
+    var h;
+    return ((h = this.socket) == null ? void 0 : h.readyState) === WebSocket.OPEN ? (this.socket.send(r), this.log("发送消息:", r), !0) : (this.log("WebSocket未连接，无法发送消息"), !1);
+  }
+  /**
+   * 发送JSON消息
+   */
+  sendJSON(r) {
+    return this.send(JSON.stringify(r));
+  }
+  /**
+   * 添加事件监听器
+   */
+  on(r, h) {
+    this.eventListeners[r] = h;
+  }
+  /**
+   * 移除事件监听器
+   */
+  off(r) {
+    delete this.eventListeners[r];
+  }
+  /**
+   * 获取连接状态
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * 检查是否已连接
+   */
+  isConnected() {
+    var r;
+    return this.status === P.CONNECTED && ((r = this.socket) == null ? void 0 : r.readyState) === WebSocket.OPEN;
+  }
+  /**
+   * 设置事件监听器
+   */
+  setupEventListeners() {
+    this.socket && (this.socket.onmessage = (r) => {
+      var h, b;
+      this.log("收到消息:", r.data), r.data !== "pong" && ((b = (h = this.eventListeners).message) == null || b.call(h, r.data));
+    }, this.socket.onclose = (r) => {
+      var h, b;
+      this.log("WebSocket连接关闭:", r.code, r.reason), this.setStatus(P.DISCONNECTED), this.stopHeartbeat(), (b = (h = this.eventListeners).close) == null || b.call(h, r), r.code !== 1e3 && this.reconnectAttempts < (this.config.maxReconnectAttempts || 5) && this.scheduleReconnect();
+    }, this.socket.onerror = (r) => {
+      var h, b;
+      this.log("WebSocket错误:", r), this.setStatus(P.ERROR), (b = (h = this.eventListeners).error) == null || b.call(h, r);
+    });
+  }
+  /**
+   * 设置连接状态
+   */
+  setStatus(r) {
+    var h, b;
+    this.status !== r && (this.status = r, this.log("连接状态变更:", r), (b = (h = this.eventListeners).statusChange) == null || b.call(h, r));
+  }
+  /**
+   * 安排重连
+   */
+  scheduleReconnect() {
+    this.reconnectTimer || (this.reconnectAttempts++, this.setStatus(P.RECONNECTING), this.log(`准备重连 (第${this.reconnectAttempts}次)...`), this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null, this.connect().catch(() => {
+      });
+    }, this.config.reconnectInterval || 3e3));
+  }
+  /**
+   * 清除重连定时器
+   */
+  clearReconnectTimer() {
+    this.reconnectTimer && (clearTimeout(this.reconnectTimer), this.reconnectTimer = null);
+  }
+  /**
+   * 开始心跳检测
+   */
+  startHeartbeat() {
+    this.stopHeartbeat(), this.config.heartbeatInterval && this.config.heartbeatInterval > 0 && (this.heartbeatTimer = setInterval(() => {
+      this.isConnected() && this.send("ping");
+    }, this.config.heartbeatInterval));
+  }
+  /**
+   * 停止心跳检测
+   */
+  stopHeartbeat() {
+    this.heartbeatTimer && (clearInterval(this.heartbeatTimer), this.heartbeatTimer = null);
+  }
+  /**
+   * 日志输出
+   */
+  log(...r) {
+    this.config.debug && console.log("[SocketConnection]", ...r);
+  }
+  /**
+   * 销毁实例
+   */
+  destroy() {
+    this.disconnect(), this.eventListeners = {}, S.instance = null;
+  }
+};
+D(S, "instance", null);
+let ge = S, C = null;
+self.onmessage = (v) => {
+  const { type: r, data: h } = (v == null ? void 0 : v.data) || {};
+  switch (r) {
+    case "INIT":
+      C = ge.getInstance({ url: h == null ? void 0 : h.url, debug: (h == null ? void 0 : h.debug) ?? !0 }), C == null || C.connect(), C == null || C.on("open", () => {
+        self.postMessage({ type: "INIT_OK" });
+      }), C == null || C.on("message", (b) => {
+        self.postMessage({ type: "RECEIVE_MESSAGE", data: b });
+      });
+      break;
+    case "SEND_MESSAGE":
+      C == null || C.send(JSON.stringify(h));
+      break;
+    case "CLOSE":
+      C == null || C.disconnect(), C = null;
+      break;
+  }
+};