zen-code 4.7.4 → 4.8.0

package/dist/devtools-CzaVuYnh.mjs

@@ -1,2667 +0,0 @@
-import Qe from "node:events";
-import dt from "node:https";
-import Je from "node:http";
-import _t from "node:net";
-import pt from "node:tls";
-import Oe from "node:crypto";
-import se from "node:stream";
-import mt from "node:url";
-import gt from "node:zlib";
-import { g as et, a as yt } from "./_commonjsHelpers-DQNKXVTB.mjs";
-import Et from "node:buffer";
-import tt from "react-devtools-core";
-var te = { exports: {} }, _e, $e;
-function q() {
-  if ($e) return _e;
-  $e = 1;
-  const P = ["nodebuffer", "arraybuffer", "fragments"], T = typeof Blob < "u";
-  return T && P.push("blob"), _e = {
-    BINARY_TYPES: P,
-    CLOSE_TIMEOUT: 3e4,
-    EMPTY_BUFFER: Buffer.alloc(0),
-    GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
-    hasBlob: T,
-    kForOnEventAttribute: /* @__PURE__ */ Symbol("kIsForOnEventAttribute"),
-    kListener: /* @__PURE__ */ Symbol("kListener"),
-    kStatusCode: /* @__PURE__ */ Symbol("status-code"),
-    kWebSocket: /* @__PURE__ */ Symbol("websocket"),
-    NOOP: () => {
-    }
-  }, _e;
-}
-const St = {}, xt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  default: St
-}, Symbol.toStringTag, { value: "Module" })), vt = /* @__PURE__ */ et(xt);
-var Fe;
-function ae() {
-  if (Fe) return te.exports;
-  Fe = 1;
-  const { EMPTY_BUFFER: P } = q(), T = Buffer[Symbol.species];
-  function M(l, a) {
-    if (l.length === 0) return P;
-    if (l.length === 1) return l[0];
-    const _ = Buffer.allocUnsafe(a);
-    let h = 0;
-    for (let L = 0; L < l.length; L++) {
-      const c = l[L];
-      _.set(c, h), h += c.length;
-    }
-    return h < a ? new T(_.buffer, _.byteOffset, h) : _;
-  }
-  function D(l, a, _, h, L) {
-    for (let c = 0; c < L; c++)
-      _[h + c] = l[c] ^ a[c & 3];
-  }
-  function x(l, a) {
-    for (let _ = 0; _ < l.length; _++)
-      l[_] ^= a[_ & 3];
-  }
-  function d(l) {
-    return l.length === l.buffer.byteLength ? l.buffer : l.buffer.slice(l.byteOffset, l.byteOffset + l.length);
-  }
-  function n(l) {
-    if (n.readOnly = !0, Buffer.isBuffer(l)) return l;
-    let a;
-    return l instanceof ArrayBuffer ? a = new T(l) : ArrayBuffer.isView(l) ? a = new T(l.buffer, l.byteOffset, l.byteLength) : (a = Buffer.from(l), n.readOnly = !1), a;
-  }
-  if (te.exports = {
-    concat: M,
-    mask: D,
-    toArrayBuffer: d,
-    toBuffer: n,
-    unmask: x
-  }, !process.env.WS_NO_BUFFER_UTIL)
-    try {
-      const l = vt;
-      te.exports.mask = function(a, _, h, L, c) {
-        c < 48 ? D(a, _, h, L, c) : l.mask(a, _, h, L, c);
-      }, te.exports.unmask = function(a, _) {
-        a.length < 32 ? x(a, _) : l.unmask(a, _);
-      };
-    } catch {
-    }
-  return te.exports;
-}
-var pe, We;
-function bt() {
-  if (We) return pe;
-  We = 1;
-  const P = /* @__PURE__ */ Symbol("kDone"), T = /* @__PURE__ */ Symbol("kRun");
-  class M {
-    /**
-     * Creates a new `Limiter`.
-     *
-     * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
-     *     to run concurrently
-     */
-    constructor(x) {
-      this[P] = () => {
-        this.pending--, this[T]();
-      }, this.concurrency = x || 1 / 0, this.jobs = [], this.pending = 0;
-    }
-    /**
-     * Adds a job to the queue.
-     *
-     * @param {Function} job The job to run
-     * @public
-     */
-    add(x) {
-      this.jobs.push(x), this[T]();
-    }
-    /**
-     * Removes a job from the queue and runs it if possible.
-     *
-     * @private
-     */
-    [T]() {
-      if (this.pending !== this.concurrency && this.jobs.length) {
-        const x = this.jobs.shift();
-        this.pending++, x(this[P]);
-      }
-    }
-  }
-  return pe = M, pe;
-}
-var me, Ve;
-function le() {
-  if (Ve) return me;
-  Ve = 1;
-  const P = gt, T = ae(), M = bt(), { kStatusCode: D } = q(), x = Buffer[Symbol.species], d = Buffer.from([0, 0, 255, 255]), n = /* @__PURE__ */ Symbol("permessage-deflate"), l = /* @__PURE__ */ Symbol("total-length"), a = /* @__PURE__ */ Symbol("callback"), _ = /* @__PURE__ */ Symbol("buffers"), h = /* @__PURE__ */ Symbol("error");
-  let L;
-  class c {
-    /**
-     * Creates a PerMessageDeflate instance.
-     *
-     * @param {Object} [options] Configuration options
-     * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
-     *     for, or request, a custom client window size
-     * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
-     *     acknowledge disabling of client context takeover
-     * @param {Number} [options.concurrencyLimit=10] The number of concurrent
-     *     calls to zlib
-     * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
-     *     use of a custom server window size
-     * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
-     *     disabling of server context takeover
-     * @param {Number} [options.threshold=1024] Size (in bytes) below which
-     *     messages should not be compressed if context takeover is disabled
-     * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
-     *     deflate
-     * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
-     *     inflate
-     * @param {Boolean} [isServer=false] Create the instance in either server or
-     *     client mode
-     * @param {Number} [maxPayload=0] The maximum allowed message length
-     */
-    constructor(p, f, E) {
-      if (this._maxPayload = E | 0, this._options = p || {}, this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024, this._isServer = !!f, this._deflate = null, this._inflate = null, this.params = null, !L) {
-        const w = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
-        L = new M(w);
-      }
-    }
-    /**
-     * @type {String}
-     */
-    static get extensionName() {
-      return "permessage-deflate";
-    }
-    /**
-     * Create an extension negotiation offer.
-     *
-     * @return {Object} Extension parameters
-     * @public
-     */
-    offer() {
-      const p = {};
-      return this._options.serverNoContextTakeover && (p.server_no_context_takeover = !0), this._options.clientNoContextTakeover && (p.client_no_context_takeover = !0), this._options.serverMaxWindowBits && (p.server_max_window_bits = this._options.serverMaxWindowBits), this._options.clientMaxWindowBits ? p.client_max_window_bits = this._options.clientMaxWindowBits : this._options.clientMaxWindowBits == null && (p.client_max_window_bits = !0), p;
-    }
-    /**
-     * Accept an extension negotiation offer/response.
-     *
-     * @param {Array} configurations The extension negotiation offers/reponse
-     * @return {Object} Accepted configuration
-     * @public
-     */
-    accept(p) {
-      return p = this.normalizeParams(p), this.params = this._isServer ? this.acceptAsServer(p) : this.acceptAsClient(p), this.params;
-    }
-    /**
-     * Releases all resources used by the extension.
-     *
-     * @public
-     */
-    cleanup() {
-      if (this._inflate && (this._inflate.close(), this._inflate = null), this._deflate) {
-        const p = this._deflate[a];
-        this._deflate.close(), this._deflate = null, p && p(
-          new Error(
-            "The deflate stream was closed while data was being processed"
-          )
-        );
-      }
-    }
-    /**
-     *  Accept an extension negotiation offer.
-     *
-     * @param {Array} offers The extension negotiation offers
-     * @return {Object} Accepted configuration
-     * @private
-     */
-    acceptAsServer(p) {
-      const f = this._options, E = p.find((w) => !(f.serverNoContextTakeover === !1 && w.server_no_context_takeover || w.server_max_window_bits && (f.serverMaxWindowBits === !1 || typeof f.serverMaxWindowBits == "number" && f.serverMaxWindowBits > w.server_max_window_bits) || typeof f.clientMaxWindowBits == "number" && !w.client_max_window_bits));
-      if (!E)
-        throw new Error("None of the extension offers can be accepted");
-      return f.serverNoContextTakeover && (E.server_no_context_takeover = !0), f.clientNoContextTakeover && (E.client_no_context_takeover = !0), typeof f.serverMaxWindowBits == "number" && (E.server_max_window_bits = f.serverMaxWindowBits), typeof f.clientMaxWindowBits == "number" ? E.client_max_window_bits = f.clientMaxWindowBits : (E.client_max_window_bits === !0 || f.clientMaxWindowBits === !1) && delete E.client_max_window_bits, E;
-    }
-    /**
-     * Accept the extension negotiation response.
-     *
-     * @param {Array} response The extension negotiation response
-     * @return {Object} Accepted configuration
-     * @private
-     */
-    acceptAsClient(p) {
-      const f = p[0];
-      if (this._options.clientNoContextTakeover === !1 && f.client_no_context_takeover)
-        throw new Error('Unexpected parameter "client_no_context_takeover"');
-      if (!f.client_max_window_bits)
-        typeof this._options.clientMaxWindowBits == "number" && (f.client_max_window_bits = this._options.clientMaxWindowBits);
-      else if (this._options.clientMaxWindowBits === !1 || typeof this._options.clientMaxWindowBits == "number" && f.client_max_window_bits > this._options.clientMaxWindowBits)
-        throw new Error(
-          'Unexpected or invalid parameter "client_max_window_bits"'
-        );
-      return f;
-    }
-    /**
-     * Normalize parameters.
-     *
-     * @param {Array} configurations The extension negotiation offers/reponse
-     * @return {Array} The offers/response with normalized parameters
-     * @private
-     */
-    normalizeParams(p) {
-      return p.forEach((f) => {
-        Object.keys(f).forEach((E) => {
-          let w = f[E];
-          if (w.length > 1)
-            throw new Error(`Parameter "${E}" must have only a single value`);
-          if (w = w[0], E === "client_max_window_bits") {
-            if (w !== !0) {
-              const t = +w;
-              if (!Number.isInteger(t) || t < 8 || t > 15)
-                throw new TypeError(
-                  `Invalid value for parameter "${E}": ${w}`
-                );
-              w = t;
-            } else if (!this._isServer)
-              throw new TypeError(
-                `Invalid value for parameter "${E}": ${w}`
-              );
-          } else if (E === "server_max_window_bits") {
-            const t = +w;
-            if (!Number.isInteger(t) || t < 8 || t > 15)
-              throw new TypeError(
-                `Invalid value for parameter "${E}": ${w}`
-              );
-            w = t;
-          } else if (E === "client_no_context_takeover" || E === "server_no_context_takeover") {
-            if (w !== !0)
-              throw new TypeError(
-                `Invalid value for parameter "${E}": ${w}`
-              );
-          } else
-            throw new Error(`Unknown parameter "${E}"`);
-          f[E] = w;
-        });
-      }), p;
-    }
-    /**
-     * Decompress data. Concurrency limited.
-     *
-     * @param {Buffer} data Compressed data
-     * @param {Boolean} fin Specifies whether or not this is the last fragment
-     * @param {Function} callback Callback
-     * @public
-     */
-    decompress(p, f, E) {
-      L.add((w) => {
-        this._decompress(p, f, (t, e) => {
-          w(), E(t, e);
-        });
-      });
-    }
-    /**
-     * Compress data. Concurrency limited.
-     *
-     * @param {(Buffer|String)} data Data to compress
-     * @param {Boolean} fin Specifies whether or not this is the last fragment
-     * @param {Function} callback Callback
-     * @public
-     */
-    compress(p, f, E) {
-      L.add((w) => {
-        this._compress(p, f, (t, e) => {
-          w(), E(t, e);
-        });
-      });
-    }
-    /**
-     * Decompress data.
-     *
-     * @param {Buffer} data Compressed data
-     * @param {Boolean} fin Specifies whether or not this is the last fragment
-     * @param {Function} callback Callback
-     * @private
-     */
-    _decompress(p, f, E) {
-      const w = this._isServer ? "client" : "server";
-      if (!this._inflate) {
-        const t = `${w}_max_window_bits`, e = typeof this.params[t] != "number" ? P.Z_DEFAULT_WINDOWBITS : this.params[t];
-        this._inflate = P.createInflateRaw({
-          ...this._options.zlibInflateOptions,
-          windowBits: e
-        }), this._inflate[n] = this, this._inflate[l] = 0, this._inflate[_] = [], this._inflate.on("error", v), this._inflate.on("data", C);
-      }
-      this._inflate[a] = E, this._inflate.write(p), f && this._inflate.write(d), this._inflate.flush(() => {
-        const t = this._inflate[h];
-        if (t) {
-          this._inflate.close(), this._inflate = null, E(t);
-          return;
-        }
-        const e = T.concat(
-          this._inflate[_],
-          this._inflate[l]
-        );
-        this._inflate._readableState.endEmitted ? (this._inflate.close(), this._inflate = null) : (this._inflate[l] = 0, this._inflate[_] = [], f && this.params[`${w}_no_context_takeover`] && this._inflate.reset()), E(null, e);
-      });
-    }
-    /**
-     * Compress data.
-     *
-     * @param {(Buffer|String)} data Data to compress
-     * @param {Boolean} fin Specifies whether or not this is the last fragment
-     * @param {Function} callback Callback
-     * @private
-     */
-    _compress(p, f, E) {
-      const w = this._isServer ? "server" : "client";
-      if (!this._deflate) {
-        const t = `${w}_max_window_bits`, e = typeof this.params[t] != "number" ? P.Z_DEFAULT_WINDOWBITS : this.params[t];
-        this._deflate = P.createDeflateRaw({
-          ...this._options.zlibDeflateOptions,
-          windowBits: e
-        }), this._deflate[l] = 0, this._deflate[_] = [], this._deflate.on("data", b);
-      }
-      this._deflate[a] = E, this._deflate.write(p), this._deflate.flush(P.Z_SYNC_FLUSH, () => {
-        if (!this._deflate)
-          return;
-        let t = T.concat(
-          this._deflate[_],
-          this._deflate[l]
-        );
-        f && (t = new x(t.buffer, t.byteOffset, t.length - 4)), this._deflate[a] = null, this._deflate[l] = 0, this._deflate[_] = [], f && this.params[`${w}_no_context_takeover`] && this._deflate.reset(), E(null, t);
-      });
-    }
-  }
-  me = c;
-  function b(O) {
-    this[_].push(O), this[l] += O.length;
-  }
-  function C(O) {
-    if (this[l] += O.length, this[n]._maxPayload < 1 || this[l] <= this[n]._maxPayload) {
-      this[_].push(O);
-      return;
-    }
-    this[h] = new RangeError("Max payload size exceeded"), this[h].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH", this[h][D] = 1009, this.removeListener("data", C), this.reset();
-  }
-  function v(O) {
-    if (this[n]._inflate = null, this[h]) {
-      this[a](this[h]);
-      return;
-    }
-    O[D] = 1007, this[a](O);
-  }
-  return me;
-}
-var re = { exports: {} };
-const wt = {}, Ot = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  default: wt
-}, Symbol.toStringTag, { value: "Module" })), Tt = /* @__PURE__ */ et(Ot);
-var Ge;
-function ie() {
-  if (Ge) return re.exports;
-  Ge = 1;
-  const { isUtf8: P } = Et, { hasBlob: T } = q(), M = [
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    // 0 - 15
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    // 16 - 31
-    0,
-    1,
-    0,
-    1,
-    1,
-    1,
-    1,
-    1,
-    0,
-    0,
-    1,
-    1,
-    0,
-    1,
-    1,
-    0,
-    // 32 - 47
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    0,
-    0,
-    0,
-    0,
-    0,
-    0,
-    // 48 - 63
-    0,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    // 64 - 79
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    0,
-    0,
-    0,
-    1,
-    1,
-    // 80 - 95
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    // 96 - 111
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    1,
-    0,
-    1,
-    0,
-    1,
-    0
-    // 112 - 127
-  ];
-  function D(n) {
-    return n >= 1e3 && n <= 1014 && n !== 1004 && n !== 1005 && n !== 1006 || n >= 3e3 && n <= 4999;
-  }
-  function x(n) {
-    const l = n.length;
-    let a = 0;
-    for (; a < l; )
-      if ((n[a] & 128) === 0)
-        a++;
-      else if ((n[a] & 224) === 192) {
-        if (a + 1 === l || (n[a + 1] & 192) !== 128 || (n[a] & 254) === 192)
-          return !1;
-        a += 2;
-      } else if ((n[a] & 240) === 224) {
-        if (a + 2 >= l || (n[a + 1] & 192) !== 128 || (n[a + 2] & 192) !== 128 || n[a] === 224 && (n[a + 1] & 224) === 128 || // Overlong
-        n[a] === 237 && (n[a + 1] & 224) === 160)
-          return !1;
-        a += 3;
-      } else if ((n[a] & 248) === 240) {
-        if (a + 3 >= l || (n[a + 1] & 192) !== 128 || (n[a + 2] & 192) !== 128 || (n[a + 3] & 192) !== 128 || n[a] === 240 && (n[a + 1] & 240) === 128 || // Overlong
-        n[a] === 244 && n[a + 1] > 143 || n[a] > 244)
-          return !1;
-        a += 4;
-      } else
-        return !1;
-    return !0;
-  }
-  function d(n) {
-    return T && typeof n == "object" && typeof n.arrayBuffer == "function" && typeof n.type == "string" && typeof n.stream == "function" && (n[Symbol.toStringTag] === "Blob" || n[Symbol.toStringTag] === "File");
-  }
-  if (re.exports = {
-    isBlob: d,
-    isValidStatusCode: D,
-    isValidUTF8: x,
-    tokenChars: M
-  }, P)
-    re.exports.isValidUTF8 = function(n) {
-      return n.length < 24 ? x(n) : P(n);
-    };
-  else if (!process.env.WS_NO_UTF_8_VALIDATE)
-    try {
-      const n = Tt;
-      re.exports.isValidUTF8 = function(l) {
-        return l.length < 32 ? x(l) : n(l);
-      };
-    } catch {
-    }
-  return re.exports;
-}
-var ge, je;
-function rt() {
-  if (je) return ge;
-  je = 1;
-  const { Writable: P } = se, T = le(), {
-    BINARY_TYPES: M,
-    EMPTY_BUFFER: D,
-    kStatusCode: x,
-    kWebSocket: d
-  } = q(), { concat: n, toArrayBuffer: l, unmask: a } = ae(), { isValidStatusCode: _, isValidUTF8: h } = ie(), L = Buffer[Symbol.species], c = 0, b = 1, C = 2, v = 3, O = 4, p = 5, f = 6;
-  class E extends P {
-    /**
-     * Creates a Receiver instance.
-     *
-     * @param {Object} [options] Options object
-     * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
-     *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
-     *     multiple times in the same tick
-     * @param {String} [options.binaryType=nodebuffer] The type for binary data
-     * @param {Object} [options.extensions] An object containing the negotiated
-     *     extensions
-     * @param {Boolean} [options.isServer=false] Specifies whether to operate in
-     *     client or server mode
-     * @param {Number} [options.maxPayload=0] The maximum allowed message length
-     * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
-     *     not to skip UTF-8 validation for text and close messages
-     */
-    constructor(t = {}) {
-      super(), this._allowSynchronousEvents = t.allowSynchronousEvents !== void 0 ? t.allowSynchronousEvents : !0, this._binaryType = t.binaryType || M[0], this._extensions = t.extensions || {}, this._isServer = !!t.isServer, this._maxPayload = t.maxPayload | 0, this._skipUTF8Validation = !!t.skipUTF8Validation, this[d] = void 0, this._bufferedBytes = 0, this._buffers = [], this._compressed = !1, this._payloadLength = 0, this._mask = void 0, this._fragmented = 0, this._masked = !1, this._fin = !1, this._opcode = 0, this._totalPayloadLength = 0, this._messageLength = 0, this._fragments = [], this._errored = !1, this._loop = !1, this._state = c;
-    }
-    /**
-     * Implements `Writable.prototype._write()`.
-     *
-     * @param {Buffer} chunk The chunk of data to write
-     * @param {String} encoding The character encoding of `chunk`
-     * @param {Function} cb Callback
-     * @private
-     */
-    _write(t, e, s) {
-      if (this._opcode === 8 && this._state == c) return s();
-      this._bufferedBytes += t.length, this._buffers.push(t), this.startLoop(s);
-    }
-    /**
-     * Consumes `n` bytes from the buffered data.
-     *
-     * @param {Number} n The number of bytes to consume
-     * @return {Buffer} The consumed bytes
-     * @private
-     */
-    consume(t) {
-      if (this._bufferedBytes -= t, t === this._buffers[0].length) return this._buffers.shift();
-      if (t < this._buffers[0].length) {
-        const s = this._buffers[0];
-        return this._buffers[0] = new L(
-          s.buffer,
-          s.byteOffset + t,
-          s.length - t
-        ), new L(s.buffer, s.byteOffset, t);
-      }
-      const e = Buffer.allocUnsafe(t);
-      do {
-        const s = this._buffers[0], i = e.length - t;
-        t >= s.length ? e.set(this._buffers.shift(), i) : (e.set(new Uint8Array(s.buffer, s.byteOffset, t), i), this._buffers[0] = new L(
-          s.buffer,
-          s.byteOffset + t,
-          s.length - t
-        )), t -= s.length;
-      } while (t > 0);
-      return e;
-    }
-    /**
-     * Starts the parsing loop.
-     *
-     * @param {Function} cb Callback
-     * @private
-     */
-    startLoop(t) {
-      this._loop = !0;
-      do
-        switch (this._state) {
-          case c:
-            this.getInfo(t);
-            break;
-          case b:
-            this.getPayloadLength16(t);
-            break;
-          case C:
-            this.getPayloadLength64(t);
-            break;
-          case v:
-            this.getMask();
-            break;
-          case O:
-            this.getData(t);
-            break;
-          case p:
-          case f:
-            this._loop = !1;
-            return;
-        }
-      while (this._loop);
-      this._errored || t();
-    }
-    /**
-     * Reads the first two bytes of a frame.
-     *
-     * @param {Function} cb Callback
-     * @private
-     */
-    getInfo(t) {
-      if (this._bufferedBytes < 2) {
-        this._loop = !1;
-        return;
-      }
-      const e = this.consume(2);
-      if ((e[0] & 48) !== 0) {
-        const i = this.createError(
-          RangeError,
-          "RSV2 and RSV3 must be clear",
-          !0,
-          1002,
-          "WS_ERR_UNEXPECTED_RSV_2_3"
-        );
-        t(i);
-        return;
-      }
-      const s = (e[0] & 64) === 64;
-      if (s && !this._extensions[T.extensionName]) {
-        const i = this.createError(
-          RangeError,
-          "RSV1 must be clear",
-          !0,
-          1002,
-          "WS_ERR_UNEXPECTED_RSV_1"
-        );
-        t(i);
-        return;
-      }
-      if (this._fin = (e[0] & 128) === 128, this._opcode = e[0] & 15, this._payloadLength = e[1] & 127, this._opcode === 0) {
-        if (s) {
-          const i = this.createError(
-            RangeError,
-            "RSV1 must be clear",
-            !0,
-            1002,
-            "WS_ERR_UNEXPECTED_RSV_1"
-          );
-          t(i);
-          return;
-        }
-        if (!this._fragmented) {
-          const i = this.createError(
-            RangeError,
-            "invalid opcode 0",
-            !0,
-            1002,
-            "WS_ERR_INVALID_OPCODE"
-          );
-          t(i);
-          return;
-        }
-        this._opcode = this._fragmented;
-      } else if (this._opcode === 1 || this._opcode === 2) {
-        if (this._fragmented) {
-          const i = this.createError(
-            RangeError,
-            `invalid opcode ${this._opcode}`,
-            !0,
-            1002,
-            "WS_ERR_INVALID_OPCODE"
-          );
-          t(i);
-          return;
-        }
-        this._compressed = s;
-      } else if (this._opcode > 7 && this._opcode < 11) {
-        if (!this._fin) {
-          const i = this.createError(
-            RangeError,
-            "FIN must be set",
-            !0,
-            1002,
-            "WS_ERR_EXPECTED_FIN"
-          );
-          t(i);
-          return;
-        }
-        if (s) {
-          const i = this.createError(
-            RangeError,
-            "RSV1 must be clear",
-            !0,
-            1002,
-            "WS_ERR_UNEXPECTED_RSV_1"
-          );
-          t(i);
-          return;
-        }
-        if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
-          const i = this.createError(
-            RangeError,
-            `invalid payload length ${this._payloadLength}`,
-            !0,
-            1002,
-            "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
-          );
-          t(i);
-          return;
-        }
-      } else {
-        const i = this.createError(
-          RangeError,
-          `invalid opcode ${this._opcode}`,
-          !0,
-          1002,
-          "WS_ERR_INVALID_OPCODE"
-        );
-        t(i);
-        return;
-      }
-      if (!this._fin && !this._fragmented && (this._fragmented = this._opcode), this._masked = (e[1] & 128) === 128, this._isServer) {
-        if (!this._masked) {
-          const i = this.createError(
-            RangeError,
-            "MASK must be set",
-            !0,
-            1002,
-            "WS_ERR_EXPECTED_MASK"
-          );
-          t(i);
-          return;
-        }
-      } else if (this._masked) {
-        const i = this.createError(
-          RangeError,
-          "MASK must be clear",
-          !0,
-          1002,
-          "WS_ERR_UNEXPECTED_MASK"
-        );
-        t(i);
-        return;
-      }
-      this._payloadLength === 126 ? this._state = b : this._payloadLength === 127 ? this._state = C : this.haveLength(t);
-    }
-    /**
-     * Gets extended payload length (7+16).
-     *
-     * @param {Function} cb Callback
-     * @private
-     */
-    getPayloadLength16(t) {
-      if (this._bufferedBytes < 2) {
-        this._loop = !1;
-        return;
-      }
-      this._payloadLength = this.consume(2).readUInt16BE(0), this.haveLength(t);
-    }
-    /**
-     * Gets extended payload length (7+64).
-     *
-     * @param {Function} cb Callback
-     * @private
-     */
-    getPayloadLength64(t) {
-      if (this._bufferedBytes < 8) {
-        this._loop = !1;
-        return;
-      }
-      const e = this.consume(8), s = e.readUInt32BE(0);
-      if (s > Math.pow(2, 21) - 1) {
-        const i = this.createError(
-          RangeError,
-          "Unsupported WebSocket frame: payload length > 2^53 - 1",
-          !1,
-          1009,
-          "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
-        );
-        t(i);
-        return;
-      }
-      this._payloadLength = s * Math.pow(2, 32) + e.readUInt32BE(4), this.haveLength(t);
-    }
-    /**
-     * Payload length has been read.
-     *
-     * @param {Function} cb Callback
-     * @private
-     */
-    haveLength(t) {
-      if (this._payloadLength && this._opcode < 8 && (this._totalPayloadLength += this._payloadLength, this._totalPayloadLength > this._maxPayload && this._maxPayload > 0)) {
-        const e = this.createError(
-          RangeError,
-          "Max payload size exceeded",
-          !1,
-          1009,
-          "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
-        );
-        t(e);
-        return;
-      }
-      this._masked ? this._state = v : this._state = O;
-    }
-    /**
-     * Reads mask bytes.
-     *
-     * @private
-     */
-    getMask() {
-      if (this._bufferedBytes < 4) {
-        this._loop = !1;
-        return;
-      }
-      this._mask = this.consume(4), this._state = O;
-    }
-    /**
-     * Reads data bytes.
-     *
-     * @param {Function} cb Callback
-     * @private
-     */
-    getData(t) {
-      let e = D;
-      if (this._payloadLength) {
-        if (this._bufferedBytes < this._payloadLength) {
-          this._loop = !1;
-          return;
-        }
-        e = this.consume(this._payloadLength), this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0 && a(e, this._mask);
-      }
-      if (this._opcode > 7) {
-        this.controlMessage(e, t);
-        return;
-      }
-      if (this._compressed) {
-        this._state = p, this.decompress(e, t);
-        return;
-      }
-      e.length && (this._messageLength = this._totalPayloadLength, this._fragments.push(e)), this.dataMessage(t);
-    }
-    /**
-     * Decompresses data.
-     *
-     * @param {Buffer} data Compressed data
-     * @param {Function} cb Callback
-     * @private
-     */
-    decompress(t, e) {
-      this._extensions[T.extensionName].decompress(t, this._fin, (i, m) => {
-        if (i) return e(i);
-        if (m.length) {
-          if (this._messageLength += m.length, this._messageLength > this._maxPayload && this._maxPayload > 0) {
-            const u = this.createError(
-              RangeError,
-              "Max payload size exceeded",
-              !1,
-              1009,
-              "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
-            );
-            e(u);
-            return;
-          }
-          this._fragments.push(m);
-        }
-        this.dataMessage(e), this._state === c && this.startLoop(e);
-      });
-    }
-    /**
-     * Handles a data message.
-     *
-     * @param {Function} cb Callback
-     * @private
-     */
-    dataMessage(t) {
-      if (!this._fin) {
-        this._state = c;
-        return;
-      }
-      const e = this._messageLength, s = this._fragments;
-      if (this._totalPayloadLength = 0, this._messageLength = 0, this._fragmented = 0, this._fragments = [], this._opcode === 2) {
-        let i;
-        this._binaryType === "nodebuffer" ? i = n(s, e) : this._binaryType === "arraybuffer" ? i = l(n(s, e)) : this._binaryType === "blob" ? i = new Blob(s) : i = s, this._allowSynchronousEvents ? (this.emit("message", i, !0), this._state = c) : (this._state = f, setImmediate(() => {
-          this.emit("message", i, !0), this._state = c, this.startLoop(t);
-        }));
-      } else {
-        const i = n(s, e);
-        if (!this._skipUTF8Validation && !h(i)) {
-          const m = this.createError(
-            Error,
-            "invalid UTF-8 sequence",
-            !0,
-            1007,
-            "WS_ERR_INVALID_UTF8"
-          );
-          t(m);
-          return;
-        }
-        this._state === p || this._allowSynchronousEvents ? (this.emit("message", i, !1), this._state = c) : (this._state = f, setImmediate(() => {
-          this.emit("message", i, !1), this._state = c, this.startLoop(t);
-        }));
-      }
-    }
-    /**
-     * Handles a control message.
-     *
-     * @param {Buffer} data Data to handle
-     * @return {(Error|RangeError|undefined)} A possible error
-     * @private
-     */
-    controlMessage(t, e) {
-      if (this._opcode === 8) {
-        if (t.length === 0)
-          this._loop = !1, this.emit("conclude", 1005, D), this.end();
-        else {
-          const s = t.readUInt16BE(0);
-          if (!_(s)) {
-            const m = this.createError(
-              RangeError,
-              `invalid status code ${s}`,
-              !0,
-              1002,
-              "WS_ERR_INVALID_CLOSE_CODE"
-            );
-            e(m);
-            return;
-          }
-          const i = new L(
-            t.buffer,
-            t.byteOffset + 2,
-            t.length - 2
-          );
-          if (!this._skipUTF8Validation && !h(i)) {
-            const m = this.createError(
-              Error,
-              "invalid UTF-8 sequence",
-              !0,
-              1007,
-              "WS_ERR_INVALID_UTF8"
-            );
-            e(m);
-            return;
-          }
-          this._loop = !1, this.emit("conclude", s, i), this.end();
-        }
-        this._state = c;
-        return;
-      }
-      this._allowSynchronousEvents ? (this.emit(this._opcode === 9 ? "ping" : "pong", t), this._state = c) : (this._state = f, setImmediate(() => {
-        this.emit(this._opcode === 9 ? "ping" : "pong", t), this._state = c, this.startLoop(e);
-      }));
-    }
-    /**
-     * Builds an error object.
-     *
-     * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
-     * @param {String} message The error message
-     * @param {Boolean} prefix Specifies whether or not to add a default prefix to
-     *     `message`
-     * @param {Number} statusCode The status code
-     * @param {String} errorCode The exposed error code
-     * @return {(Error|RangeError)} The error
-     * @private
-     */
-    createError(t, e, s, i, m) {
-      this._loop = !1, this._errored = !0;
-      const u = new t(
-        s ? `Invalid WebSocket frame: ${e}` : e
-      );
-      return Error.captureStackTrace(u, this.createError), u.code = m, u[x] = i, u;
-    }
-  }
-  return ge = E, ge;
-}
-var ye, qe;
-function st() {
-  if (qe) return ye;
-  qe = 1;
-  const { Duplex: P } = se, { randomFillSync: T } = Oe, M = le(), { EMPTY_BUFFER: D, kWebSocket: x, NOOP: d } = q(), { isBlob: n, isValidStatusCode: l } = ie(), { mask: a, toBuffer: _ } = ae(), h = /* @__PURE__ */ Symbol("kByteLength"), L = Buffer.alloc(4), c = 8 * 1024;
-  let b, C = c;
-  const v = 0, O = 1, p = 2;
-  class f {
-    /**
-     * Creates a Sender instance.
-     *
-     * @param {Duplex} socket The connection socket
-     * @param {Object} [extensions] An object containing the negotiated extensions
-     * @param {Function} [generateMask] The function used to generate the masking
-     *     key
-     */
-    constructor(e, s, i) {
-      this._extensions = s || {}, i && (this._generateMask = i, this._maskBuffer = Buffer.alloc(4)), this._socket = e, this._firstFragment = !0, this._compress = !1, this._bufferedBytes = 0, this._queue = [], this._state = v, this.onerror = d, this[x] = void 0;
-    }
-    /**
-     * Frames a piece of data according to the HyBi WebSocket protocol.
-     *
-     * @param {(Buffer|String)} data The data to frame
-     * @param {Object} options Options object
-     * @param {Boolean} [options.fin=false] Specifies whether or not to set the
-     *     FIN bit
-     * @param {Function} [options.generateMask] The function used to generate the
-     *     masking key
-     * @param {Boolean} [options.mask=false] Specifies whether or not to mask
-     *     `data`
-     * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
-     *     key
-     * @param {Number} options.opcode The opcode
-     * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
-     *     modified
-     * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
-     *     RSV1 bit
-     * @return {(Buffer|String)[]} The framed data
-     * @public
-     */
-    static frame(e, s) {
-      let i, m = !1, u = 2, R = !1;
-      s.mask && (i = s.maskBuffer || L, s.generateMask ? s.generateMask(i) : (C === c && (b === void 0 && (b = Buffer.alloc(c)), T(b, 0, c), C = 0), i[0] = b[C++], i[1] = b[C++], i[2] = b[C++], i[3] = b[C++]), R = (i[0] | i[1] | i[2] | i[3]) === 0, u = 6);
-      let B;
-      typeof e == "string" ? (!s.mask || R) && s[h] !== void 0 ? B = s[h] : (e = Buffer.from(e), B = e.length) : (B = e.length, m = s.mask && s.readOnly && !R);
-      let A = B;
-      B >= 65536 ? (u += 8, A = 127) : B > 125 && (u += 2, A = 126);
-      const N = Buffer.allocUnsafe(m ? B + u : u);
-      return N[0] = s.fin ? s.opcode | 128 : s.opcode, s.rsv1 && (N[0] |= 64), N[1] = A, A === 126 ? N.writeUInt16BE(B, 2) : A === 127 && (N[2] = N[3] = 0, N.writeUIntBE(B, 4, 6)), s.mask ? (N[1] |= 128, N[u - 4] = i[0], N[u - 3] = i[1], N[u - 2] = i[2], N[u - 1] = i[3], R ? [N, e] : m ? (a(e, i, N, u, B), [N]) : (a(e, i, e, 0, B), [N, e])) : [N, e];
-    }
-    /**
-     * Sends a close message to the other peer.
-     *
-     * @param {Number} [code] The status code component of the body
-     * @param {(String|Buffer)} [data] The message component of the body
-     * @param {Boolean} [mask=false] Specifies whether or not to mask the message
-     * @param {Function} [cb] Callback
-     * @public
-     */
-    close(e, s, i, m) {
-      let u;
-      if (e === void 0)
-        u = D;
-      else {
-        if (typeof e != "number" || !l(e))
-          throw new TypeError("First argument must be a valid error code number");
-        if (s === void 0 || !s.length)
-          u = Buffer.allocUnsafe(2), u.writeUInt16BE(e, 0);
-        else {
-          const B = Buffer.byteLength(s);
-          if (B > 123)
-            throw new RangeError("The message must not be greater than 123 bytes");
-          u = Buffer.allocUnsafe(2 + B), u.writeUInt16BE(e, 0), typeof s == "string" ? u.write(s, 2) : u.set(s, 2);
-        }
-      }
-      const R = {
-        [h]: u.length,
-        fin: !0,
-        generateMask: this._generateMask,
-        mask: i,
-        maskBuffer: this._maskBuffer,
-        opcode: 8,
-        readOnly: !1,
-        rsv1: !1
-      };
-      this._state !== v ? this.enqueue([this.dispatch, u, !1, R, m]) : this.sendFrame(f.frame(u, R), m);
-    }
-    /**
-     * Sends a ping message to the other peer.
-     *
-     * @param {*} data The message to send
-     * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-     * @param {Function} [cb] Callback
-     * @public
-     */
-    ping(e, s, i) {
-      let m, u;
-      if (typeof e == "string" ? (m = Buffer.byteLength(e), u = !1) : n(e) ? (m = e.size, u = !1) : (e = _(e), m = e.length, u = _.readOnly), m > 125)
-        throw new RangeError("The data size must not be greater than 125 bytes");
-      const R = {
-        [h]: m,
-        fin: !0,
-        generateMask: this._generateMask,
-        mask: s,
-        maskBuffer: this._maskBuffer,
-        opcode: 9,
-        readOnly: u,
-        rsv1: !1
-      };
-      n(e) ? this._state !== v ? this.enqueue([this.getBlobData, e, !1, R, i]) : this.getBlobData(e, !1, R, i) : this._state !== v ? this.enqueue([this.dispatch, e, !1, R, i]) : this.sendFrame(f.frame(e, R), i);
-    }
-    /**
-     * Sends a pong message to the other peer.
-     *
-     * @param {*} data The message to send
-     * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
-     * @param {Function} [cb] Callback
-     * @public
-     */
-    pong(e, s, i) {
-      let m, u;
-      if (typeof e == "string" ? (m = Buffer.byteLength(e), u = !1) : n(e) ? (m = e.size, u = !1) : (e = _(e), m = e.length, u = _.readOnly), m > 125)
-        throw new RangeError("The data size must not be greater than 125 bytes");
-      const R = {
-        [h]: m,
-        fin: !0,
-        generateMask: this._generateMask,
-        mask: s,
-        maskBuffer: this._maskBuffer,
-        opcode: 10,
-        readOnly: u,
-        rsv1: !1
-      };
-      n(e) ? this._state !== v ? this.enqueue([this.getBlobData, e, !1, R, i]) : this.getBlobData(e, !1, R, i) : this._state !== v ? this.enqueue([this.dispatch, e, !1, R, i]) : this.sendFrame(f.frame(e, R), i);
-    }
-    /**
-     * Sends a data message to the other peer.
-     *
-     * @param {*} data The message to send
-     * @param {Object} options Options object
-     * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
-     *     or text
-     * @param {Boolean} [options.compress=false] Specifies whether or not to
-     *     compress `data`
-     * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
-     *     last one
-     * @param {Boolean} [options.mask=false] Specifies whether or not to mask
-     *     `data`
-     * @param {Function} [cb] Callback
-     * @public
-     */
-    send(e, s, i) {
-      const m = this._extensions[M.extensionName];
-      let u = s.binary ? 2 : 1, R = s.compress, B, A;
-      typeof e == "string" ? (B = Buffer.byteLength(e), A = !1) : n(e) ? (B = e.size, A = !1) : (e = _(e), B = e.length, A = _.readOnly), this._firstFragment ? (this._firstFragment = !1, R && m && m.params[m._isServer ? "server_no_context_takeover" : "client_no_context_takeover"] && (R = B >= m._threshold), this._compress = R) : (R = !1, u = 0), s.fin && (this._firstFragment = !0);
-      const N = {
-        [h]: B,
-        fin: s.fin,
-        generateMask: this._generateMask,
-        mask: s.mask,
-        maskBuffer: this._maskBuffer,
-        opcode: u,
-        readOnly: A,
-        rsv1: R
-      };
-      n(e) ? this._state !== v ? this.enqueue([this.getBlobData, e, this._compress, N, i]) : this.getBlobData(e, this._compress, N, i) : this._state !== v ? this.enqueue([this.dispatch, e, this._compress, N, i]) : this.dispatch(e, this._compress, N, i);
-    }
-    /**
-     * Gets the contents of a blob as binary data.
-     *
-     * @param {Blob} blob The blob
-     * @param {Boolean} [compress=false] Specifies whether or not to compress
-     *     the data
-     * @param {Object} options Options object
-     * @param {Boolean} [options.fin=false] Specifies whether or not to set the
-     *     FIN bit
-     * @param {Function} [options.generateMask] The function used to generate the
-     *     masking key
-     * @param {Boolean} [options.mask=false] Specifies whether or not to mask
-     *     `data`
-     * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
-     *     key
-     * @param {Number} options.opcode The opcode
-     * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
-     *     modified
-     * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
-     *     RSV1 bit
-     * @param {Function} [cb] Callback
-     * @private
-     */
-    getBlobData(e, s, i, m) {
-      this._bufferedBytes += i[h], this._state = p, e.arrayBuffer().then((u) => {
-        if (this._socket.destroyed) {
-          const B = new Error(
-            "The socket was closed while the blob was being read"
-          );
-          process.nextTick(E, this, B, m);
-          return;
-        }
-        this._bufferedBytes -= i[h];
-        const R = _(u);
-        s ? this.dispatch(R, s, i, m) : (this._state = v, this.sendFrame(f.frame(R, i), m), this.dequeue());
-      }).catch((u) => {
-        process.nextTick(w, this, u, m);
-      });
-    }
-    /**
-     * Dispatches a message.
-     *
-     * @param {(Buffer|String)} data The message to send
-     * @param {Boolean} [compress=false] Specifies whether or not to compress
-     *     `data`
-     * @param {Object} options Options object
-     * @param {Boolean} [options.fin=false] Specifies whether or not to set the
-     *     FIN bit
-     * @param {Function} [options.generateMask] The function used to generate the
-     *     masking key
-     * @param {Boolean} [options.mask=false] Specifies whether or not to mask
-     *     `data`
-     * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
-     *     key
-     * @param {Number} options.opcode The opcode
-     * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
-     *     modified
-     * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
-     *     RSV1 bit
-     * @param {Function} [cb] Callback
-     * @private
-     */
-    dispatch(e, s, i, m) {
-      if (!s) {
-        this.sendFrame(f.frame(e, i), m);
-        return;
-      }
-      const u = this._extensions[M.extensionName];
-      this._bufferedBytes += i[h], this._state = O, u.compress(e, i.fin, (R, B) => {
-        if (this._socket.destroyed) {
-          const A = new Error(
-            "The socket was closed while data was being compressed"
-          );
-          E(this, A, m);
-          return;
-        }
-        this._bufferedBytes -= i[h], this._state = v, i.readOnly = !1, this.sendFrame(f.frame(B, i), m), this.dequeue();
-      });
-    }
-    /**
-     * Executes queued send operations.
-     *
-     * @private
-     */
-    dequeue() {
-      for (; this._state === v && this._queue.length; ) {
-        const e = this._queue.shift();
-        this._bufferedBytes -= e[3][h], Reflect.apply(e[0], this, e.slice(1));
-      }
-    }
-    /**
-     * Enqueues a send operation.
-     *
-     * @param {Array} params Send operation parameters.
-     * @private
-     */
-    enqueue(e) {
-      this._bufferedBytes += e[3][h], this._queue.push(e);
-    }
-    /**
-     * Sends a frame.
-     *
-     * @param {(Buffer | String)[]} list The frame to send
-     * @param {Function} [cb] Callback
-     * @private
-     */
-    sendFrame(e, s) {
-      e.length === 2 ? (this._socket.cork(), this._socket.write(e[0]), this._socket.write(e[1], s), this._socket.uncork()) : this._socket.write(e[0], s);
-    }
-  }
-  ye = f;
-  function E(t, e, s) {
-    typeof s == "function" && s(e);
-    for (let i = 0; i < t._queue.length; i++) {
-      const m = t._queue[i], u = m[m.length - 1];
-      typeof u == "function" && u(e);
-    }
-  }
-  function w(t, e, s) {
-    E(t, e, s), t.onerror(e);
-  }
-  return ye;
-}
-var Ee, ze;
-function Ct() {
-  if (ze) return Ee;
-  ze = 1;
-  const { kForOnEventAttribute: P, kListener: T } = q(), M = /* @__PURE__ */ Symbol("kCode"), D = /* @__PURE__ */ Symbol("kData"), x = /* @__PURE__ */ Symbol("kError"), d = /* @__PURE__ */ Symbol("kMessage"), n = /* @__PURE__ */ Symbol("kReason"), l = /* @__PURE__ */ Symbol("kTarget"), a = /* @__PURE__ */ Symbol("kType"), _ = /* @__PURE__ */ Symbol("kWasClean");
-  class h {
-    /**
-     * Create a new `Event`.
-     *
-     * @param {String} type The name of the event
-     * @throws {TypeError} If the `type` argument is not specified
-     */
-    constructor(p) {
-      this[l] = null, this[a] = p;
-    }
-    /**
-     * @type {*}
-     */
-    get target() {
-      return this[l];
-    }
-    /**
-     * @type {String}
-     */
-    get type() {
-      return this[a];
-    }
-  }
-  Object.defineProperty(h.prototype, "target", { enumerable: !0 }), Object.defineProperty(h.prototype, "type", { enumerable: !0 });
-  class L extends h {
-    /**
-     * Create a new `CloseEvent`.
-     *
-     * @param {String} type The name of the event
-     * @param {Object} [options] A dictionary object that allows for setting
-     *     attributes via object members of the same name
-     * @param {Number} [options.code=0] The status code explaining why the
-     *     connection was closed
-     * @param {String} [options.reason=''] A human-readable string explaining why
-     *     the connection was closed
-     * @param {Boolean} [options.wasClean=false] Indicates whether or not the
-     *     connection was cleanly closed
-     */
-    constructor(p, f = {}) {
-      super(p), this[M] = f.code === void 0 ? 0 : f.code, this[n] = f.reason === void 0 ? "" : f.reason, this[_] = f.wasClean === void 0 ? !1 : f.wasClean;
-    }
-    /**
-     * @type {Number}
-     */
-    get code() {
-      return this[M];
-    }
-    /**
-     * @type {String}
-     */
-    get reason() {
-      return this[n];
-    }
-    /**
-     * @type {Boolean}
-     */
-    get wasClean() {
-      return this[_];
-    }
-  }
-  Object.defineProperty(L.prototype, "code", { enumerable: !0 }), Object.defineProperty(L.prototype, "reason", { enumerable: !0 }), Object.defineProperty(L.prototype, "wasClean", { enumerable: !0 });
-  class c extends h {
-    /**
-     * Create a new `ErrorEvent`.
-     *
-     * @param {String} type The name of the event
-     * @param {Object} [options] A dictionary object that allows for setting
-     *     attributes via object members of the same name
-     * @param {*} [options.error=null] The error that generated this event
-     * @param {String} [options.message=''] The error message
-     */
-    constructor(p, f = {}) {
-      super(p), this[x] = f.error === void 0 ? null : f.error, this[d] = f.message === void 0 ? "" : f.message;
-    }
-    /**
-     * @type {*}
-     */
-    get error() {
-      return this[x];
-    }
-    /**
-     * @type {String}
-     */
-    get message() {
-      return this[d];
-    }
-  }
-  Object.defineProperty(c.prototype, "error", { enumerable: !0 }), Object.defineProperty(c.prototype, "message", { enumerable: !0 });
-  class b extends h {
-    /**
-     * Create a new `MessageEvent`.
-     *
-     * @param {String} type The name of the event
-     * @param {Object} [options] A dictionary object that allows for setting
-     *     attributes via object members of the same name
-     * @param {*} [options.data=null] The message content
-     */
-    constructor(p, f = {}) {
-      super(p), this[D] = f.data === void 0 ? null : f.data;
-    }
-    /**
-     * @type {*}
-     */
-    get data() {
-      return this[D];
-    }
-  }
-  Object.defineProperty(b.prototype, "data", { enumerable: !0 }), Ee = {
-    CloseEvent: L,
-    ErrorEvent: c,
-    Event: h,
-    EventTarget: {
-      /**
-       * Register an event listener.
-       *
-       * @param {String} type A string representing the event type to listen for
-       * @param {(Function|Object)} handler The listener to add
-       * @param {Object} [options] An options object specifies characteristics about
-       *     the event listener
-       * @param {Boolean} [options.once=false] A `Boolean` indicating that the
-       *     listener should be invoked at most once after being added. If `true`,
-       *     the listener would be automatically removed when invoked.
-       * @public
-       */
-      addEventListener(O, p, f = {}) {
-        for (const w of this.listeners(O))
-          if (!f[P] && w[T] === p && !w[P])
-            return;
-        let E;
-        if (O === "message")
-          E = function(t, e) {
-            const s = new b("message", {
-              data: e ? t : t.toString()
-            });
-            s[l] = this, v(p, this, s);
-          };
-        else if (O === "close")
-          E = function(t, e) {
-            const s = new L("close", {
-              code: t,
-              reason: e.toString(),
-              wasClean: this._closeFrameReceived && this._closeFrameSent
-            });
-            s[l] = this, v(p, this, s);
-          };
-        else if (O === "error")
-          E = function(t) {
-            const e = new c("error", {
-              error: t,
-              message: t.message
-            });
-            e[l] = this, v(p, this, e);
-          };
-        else if (O === "open")
-          E = function() {
-            const t = new h("open");
-            t[l] = this, v(p, this, t);
-          };
-        else
-          return;
-        E[P] = !!f[P], E[T] = p, f.once ? this.once(O, E) : this.on(O, E);
-      },
-      /**
-       * Remove an event listener.
-       *
-       * @param {String} type A string representing the event type to remove
-       * @param {(Function|Object)} handler The listener to remove
-       * @public
-       */
-      removeEventListener(O, p) {
-        for (const f of this.listeners(O))
-          if (f[T] === p && !f[P]) {
-            this.removeListener(O, f);
-            break;
-          }
-      }
-    },
-    MessageEvent: b
-  };
-  function v(O, p, f) {
-    typeof O == "object" && O.handleEvent ? O.handleEvent.call(O, f) : O.call(p, f);
-  }
-  return Ee;
-}
-var Se, He;
-function it() {
-  if (He) return Se;
-  He = 1;
-  const { tokenChars: P } = ie();
-  function T(x, d, n) {
-    x[d] === void 0 ? x[d] = [n] : x[d].push(n);
-  }
-  function M(x) {
-    const d = /* @__PURE__ */ Object.create(null);
-    let n = /* @__PURE__ */ Object.create(null), l = !1, a = !1, _ = !1, h, L, c = -1, b = -1, C = -1, v = 0;
-    for (; v < x.length; v++)
-      if (b = x.charCodeAt(v), h === void 0)
-        if (C === -1 && P[b] === 1)
-          c === -1 && (c = v);
-        else if (v !== 0 && (b === 32 || b === 9))
-          C === -1 && c !== -1 && (C = v);
-        else if (b === 59 || b === 44) {
-          if (c === -1)
-            throw new SyntaxError(`Unexpected character at index ${v}`);
-          C === -1 && (C = v);
-          const p = x.slice(c, C);
-          b === 44 ? (T(d, p, n), n = /* @__PURE__ */ Object.create(null)) : h = p, c = C = -1;
-        } else
-          throw new SyntaxError(`Unexpected character at index ${v}`);
-      else if (L === void 0)
-        if (C === -1 && P[b] === 1)
-          c === -1 && (c = v);
-        else if (b === 32 || b === 9)
-          C === -1 && c !== -1 && (C = v);
-        else if (b === 59 || b === 44) {
-          if (c === -1)
-            throw new SyntaxError(`Unexpected character at index ${v}`);
-          C === -1 && (C = v), T(n, x.slice(c, C), !0), b === 44 && (T(d, h, n), n = /* @__PURE__ */ Object.create(null), h = void 0), c = C = -1;
-        } else if (b === 61 && c !== -1 && C === -1)
-          L = x.slice(c, v), c = C = -1;
-        else
-          throw new SyntaxError(`Unexpected character at index ${v}`);
-      else if (a) {
-        if (P[b] !== 1)
-          throw new SyntaxError(`Unexpected character at index ${v}`);
-        c === -1 ? c = v : l || (l = !0), a = !1;
-      } else if (_)
-        if (P[b] === 1)
-          c === -1 && (c = v);
-        else if (b === 34 && c !== -1)
-          _ = !1, C = v;
-        else if (b === 92)
-          a = !0;
-        else
-          throw new SyntaxError(`Unexpected character at index ${v}`);
-      else if (b === 34 && x.charCodeAt(v - 1) === 61)
-        _ = !0;
-      else if (C === -1 && P[b] === 1)
-        c === -1 && (c = v);
-      else if (c !== -1 && (b === 32 || b === 9))
-        C === -1 && (C = v);
-      else if (b === 59 || b === 44) {
-        if (c === -1)
-          throw new SyntaxError(`Unexpected character at index ${v}`);
-        C === -1 && (C = v);
-        let p = x.slice(c, C);
-        l && (p = p.replace(/\\/g, ""), l = !1), T(n, L, p), b === 44 && (T(d, h, n), n = /* @__PURE__ */ Object.create(null), h = void 0), L = void 0, c = C = -1;
-      } else
-        throw new SyntaxError(`Unexpected character at index ${v}`);
-    if (c === -1 || _ || b === 32 || b === 9)
-      throw new SyntaxError("Unexpected end of input");
-    C === -1 && (C = v);
-    const O = x.slice(c, C);
-    return h === void 0 ? T(d, O, n) : (L === void 0 ? T(n, O, !0) : l ? T(n, L, O.replace(/\\/g, "")) : T(n, L, O), T(d, h, n)), d;
-  }
-  function D(x) {
-    return Object.keys(x).map((d) => {
-      let n = x[d];
-      return Array.isArray(n) || (n = [n]), n.map((l) => [d].concat(
-        Object.keys(l).map((a) => {
-          let _ = l[a];
-          return Array.isArray(_) || (_ = [_]), _.map((h) => h === !0 ? a : `${a}=${h}`).join("; ");
-        })
-      ).join("; ")).join(", ");
-    }).join(", ");
-  }
-  return Se = { format: D, parse: M }, Se;
-}
-var xe, Ye;
-function Te() {
-  if (Ye) return xe;
-  Ye = 1;
-  const P = Qe, T = dt, M = Je, D = _t, x = pt, { randomBytes: d, createHash: n } = Oe, { Duplex: l, Readable: a } = se, { URL: _ } = mt, h = le(), L = rt(), c = st(), { isBlob: b } = ie(), {
-    BINARY_TYPES: C,
-    CLOSE_TIMEOUT: v,
-    EMPTY_BUFFER: O,
-    GUID: p,
-    kForOnEventAttribute: f,
-    kListener: E,
-    kStatusCode: w,
-    kWebSocket: t,
-    NOOP: e
-  } = q(), {
-    EventTarget: { addEventListener: s, removeEventListener: i }
-  } = Ct(), { format: m, parse: u } = it(), { toBuffer: R } = ae(), B = /* @__PURE__ */ Symbol("kAborted"), A = [8, 13], N = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"], G = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
-  class S extends P {
-    /**
-     * Create a new `WebSocket`.
-     *
-     * @param {(String|URL)} address The URL to which to connect
-     * @param {(String|String[])} [protocols] The subprotocols
-     * @param {Object} [options] Connection options
-     */
-    constructor(o, y, k) {
-      super(), this._binaryType = C[0], this._closeCode = 1006, this._closeFrameReceived = !1, this._closeFrameSent = !1, this._closeMessage = O, this._closeTimer = null, this._errorEmitted = !1, this._extensions = {}, this._paused = !1, this._protocol = "", this._readyState = S.CONNECTING, this._receiver = null, this._sender = null, this._socket = null, o !== null ? (this._bufferedAmount = 0, this._isServer = !1, this._redirects = 0, y === void 0 ? y = [] : Array.isArray(y) || (typeof y == "object" && y !== null ? (k = y, y = []) : y = [y]), F(this, o, y, k)) : (this._autoPong = k.autoPong, this._closeTimeout = k.closeTimeout, this._isServer = !0);
-    }
-    /**
-     * For historical reasons, the custom "nodebuffer" type is used by the default
-     * instead of "blob".
-     *
-     * @type {String}
-     */
-    get binaryType() {
-      return this._binaryType;
-    }
-    set binaryType(o) {
-      C.includes(o) && (this._binaryType = o, this._receiver && (this._receiver._binaryType = o));
-    }
-    /**
-     * @type {Number}
-     */
-    get bufferedAmount() {
-      return this._socket ? this._socket._writableState.length + this._sender._bufferedBytes : this._bufferedAmount;
-    }
-    /**
-     * @type {String}
-     */
-    get extensions() {
-      return Object.keys(this._extensions).join();
-    }
-    /**
-     * @type {Boolean}
-     */
-    get isPaused() {
-      return this._paused;
-    }
-    /**
-     * @type {Function}
-     */
-    /* istanbul ignore next */
-    get onclose() {
-      return null;
-    }
-    /**
-     * @type {Function}
-     */
-    /* istanbul ignore next */
-    get onerror() {
-      return null;
-    }
-    /**
-     * @type {Function}
-     */
-    /* istanbul ignore next */
-    get onopen() {
-      return null;
-    }
-    /**
-     * @type {Function}
-     */
-    /* istanbul ignore next */
-    get onmessage() {
-      return null;
-    }
-    /**
-     * @type {String}
-     */
-    get protocol() {
-      return this._protocol;
-    }
-    /**
-     * @type {Number}
-     */
-    get readyState() {
-      return this._readyState;
-    }
-    /**
-     * @type {String}
-     */
-    get url() {
-      return this._url;
-    }
-    /**
-     * Set up the socket and the internal resources.
-     *
-     * @param {Duplex} socket The network socket between the server and client
-     * @param {Buffer} head The first packet of the upgraded stream
-     * @param {Object} options Options object
-     * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
-     *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
-     *     multiple times in the same tick
-     * @param {Function} [options.generateMask] The function used to generate the
-     *     masking key
-     * @param {Number} [options.maxPayload=0] The maximum allowed message size
-     * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
-     *     not to skip UTF-8 validation for text and close messages
-     * @private
-     */
-    setSocket(o, y, k) {
-      const g = new L({
-        allowSynchronousEvents: k.allowSynchronousEvents,
-        binaryType: this.binaryType,
-        extensions: this._extensions,
-        isServer: this._isServer,
-        maxPayload: k.maxPayload,
-        skipUTF8Validation: k.skipUTF8Validation
-      }), U = new c(o, this._extensions, k.generateMask);
-      this._receiver = g, this._sender = U, this._socket = o, g[t] = this, U[t] = this, o[t] = this, g.on("conclude", nt), g.on("drain", ot), g.on("error", at), g.on("message", lt), g.on("ping", ft), g.on("pong", ht), U.onerror = ct, o.setTimeout && o.setTimeout(0), o.setNoDelay && o.setNoDelay(), y.length > 0 && o.unshift(y), o.on("close", Ne), o.on("data", oe), o.on("end", Pe), o.on("error", Re), this._readyState = S.OPEN, this.emit("open");
-    }
-    /**
-     * Emit the `'close'` event.
-     *
-     * @private
-     */
-    emitClose() {
-      if (!this._socket) {
-        this._readyState = S.CLOSED, this.emit("close", this._closeCode, this._closeMessage);
-        return;
-      }
-      this._extensions[h.extensionName] && this._extensions[h.extensionName].cleanup(), this._receiver.removeAllListeners(), this._readyState = S.CLOSED, this.emit("close", this._closeCode, this._closeMessage);
-    }
-    /**
-     * Start a closing handshake.
-     *
-     *          +----------+   +-----------+   +----------+
-     *     - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
-     *    |     +----------+   +-----------+   +----------+     |
-     *          +----------+   +-----------+         |
-     * CLOSING  |ws.close()|<--|close frame|<--+-----+       CLOSING
-     *          +----------+   +-----------+   |
-     *    |           |                        |   +---+        |
-     *                +------------------------+-->|fin| - - - -
-     *    |         +---+                      |   +---+
-     *     - - - - -|fin|<---------------------+
-     *              +---+
-     *
-     * @param {Number} [code] Status code explaining why the connection is closing
-     * @param {(String|Buffer)} [data] The reason why the connection is
-     *     closing
-     * @public
-     */
-    close(o, y) {
-      if (this.readyState !== S.CLOSED) {
-        if (this.readyState === S.CONNECTING) {
-          W(this, this._req, "WebSocket was closed before the connection was established");
-          return;
-        }
-        if (this.readyState === S.CLOSING) {
-          this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted) && this._socket.end();
-          return;
-        }
-        this._readyState = S.CLOSING, this._sender.close(o, y, !this._isServer, (k) => {
-          k || (this._closeFrameSent = !0, (this._closeFrameReceived || this._receiver._writableState.errorEmitted) && this._socket.end());
-        }), ke(this);
-      }
-    }
-    /**
-     * Pause the socket.
-     *
-     * @public
-     */
-    pause() {
-      this.readyState === S.CONNECTING || this.readyState === S.CLOSED || (this._paused = !0, this._socket.pause());
-    }
-    /**
-     * Send a ping.
-     *
-     * @param {*} [data] The data to send
-     * @param {Boolean} [mask] Indicates whether or not to mask `data`
-     * @param {Function} [cb] Callback which is executed when the ping is sent
-     * @public
-     */
-    ping(o, y, k) {
-      if (this.readyState === S.CONNECTING)
-        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
-      if (typeof o == "function" ? (k = o, o = y = void 0) : typeof y == "function" && (k = y, y = void 0), typeof o == "number" && (o = o.toString()), this.readyState !== S.OPEN) {
-        ce(this, o, k);
-        return;
-      }
-      y === void 0 && (y = !this._isServer), this._sender.ping(o || O, y, k);
-    }
-    /**
-     * Send a pong.
-     *
-     * @param {*} [data] The data to send
-     * @param {Boolean} [mask] Indicates whether or not to mask `data`
-     * @param {Function} [cb] Callback which is executed when the pong is sent
-     * @public
-     */
-    pong(o, y, k) {
-      if (this.readyState === S.CONNECTING)
-        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
-      if (typeof o == "function" ? (k = o, o = y = void 0) : typeof y == "function" && (k = y, y = void 0), typeof o == "number" && (o = o.toString()), this.readyState !== S.OPEN) {
-        ce(this, o, k);
-        return;
-      }
-      y === void 0 && (y = !this._isServer), this._sender.pong(o || O, y, k);
-    }
-    /**
-     * Resume the socket.
-     *
-     * @public
-     */
-    resume() {
-      this.readyState === S.CONNECTING || this.readyState === S.CLOSED || (this._paused = !1, this._receiver._writableState.needDrain || this._socket.resume());
-    }
-    /**
-     * Send a data message.
-     *
-     * @param {*} data The message to send
-     * @param {Object} [options] Options object
-     * @param {Boolean} [options.binary] Specifies whether `data` is binary or
-     *     text
-     * @param {Boolean} [options.compress] Specifies whether or not to compress
-     *     `data`
-     * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
-     *     last one
-     * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
-     * @param {Function} [cb] Callback which is executed when data is written out
-     * @public
-     */
-    send(o, y, k) {
-      if (this.readyState === S.CONNECTING)
-        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
-      if (typeof y == "function" && (k = y, y = {}), typeof o == "number" && (o = o.toString()), this.readyState !== S.OPEN) {
-        ce(this, o, k);
-        return;
-      }
-      const g = {
-        binary: typeof o != "string",
-        mask: !this._isServer,
-        compress: !0,
-        fin: !0,
-        ...y
-      };
-      this._extensions[h.extensionName] || (g.compress = !1), this._sender.send(o || O, g, k);
-    }
-    /**
-     * Forcibly close the connection.
-     *
-     * @public
-     */
-    terminate() {
-      if (this.readyState !== S.CLOSED) {
-        if (this.readyState === S.CONNECTING) {
-          W(this, this._req, "WebSocket was closed before the connection was established");
-          return;
-        }
-        this._socket && (this._readyState = S.CLOSING, this._socket.destroy());
-      }
-    }
-  }
-  Object.defineProperty(S, "CONNECTING", {
-    enumerable: !0,
-    value: N.indexOf("CONNECTING")
-  }), Object.defineProperty(S.prototype, "CONNECTING", {
-    enumerable: !0,
-    value: N.indexOf("CONNECTING")
-  }), Object.defineProperty(S, "OPEN", {
-    enumerable: !0,
-    value: N.indexOf("OPEN")
-  }), Object.defineProperty(S.prototype, "OPEN", {
-    enumerable: !0,
-    value: N.indexOf("OPEN")
-  }), Object.defineProperty(S, "CLOSING", {
-    enumerable: !0,
-    value: N.indexOf("CLOSING")
-  }), Object.defineProperty(S.prototype, "CLOSING", {
-    enumerable: !0,
-    value: N.indexOf("CLOSING")
-  }), Object.defineProperty(S, "CLOSED", {
-    enumerable: !0,
-    value: N.indexOf("CLOSED")
-  }), Object.defineProperty(S.prototype, "CLOSED", {
-    enumerable: !0,
-    value: N.indexOf("CLOSED")
-  }), [
-    "binaryType",
-    "bufferedAmount",
-    "extensions",
-    "isPaused",
-    "protocol",
-    "readyState",
-    "url"
-  ].forEach((r) => {
-    Object.defineProperty(S.prototype, r, { enumerable: !0 });
-  }), ["open", "error", "close", "message"].forEach((r) => {
-    Object.defineProperty(S.prototype, `on${r}`, {
-      enumerable: !0,
-      get() {
-        for (const o of this.listeners(r))
-          if (o[f]) return o[E];
-        return null;
-      },
-      set(o) {
-        for (const y of this.listeners(r))
-          if (y[f]) {
-            this.removeListener(r, y);
-            break;
-          }
-        typeof o == "function" && this.addEventListener(r, o, {
-          [f]: !0
-        });
-      }
-    });
-  }), S.prototype.addEventListener = s, S.prototype.removeEventListener = i, xe = S;
-  function F(r, o, y, k) {
-    const g = {
-      allowSynchronousEvents: !0,
-      autoPong: !0,
-      closeTimeout: v,
-      protocolVersion: A[1],
-      maxPayload: 104857600,
-      skipUTF8Validation: !1,
-      perMessageDeflate: !0,
-      followRedirects: !1,
-      maxRedirects: 10,
-      ...k,
-      socketPath: void 0,
-      hostname: void 0,
-      protocol: void 0,
-      timeout: void 0,
-      method: "GET",
-      host: void 0,
-      path: void 0,
-      port: void 0
-    };
-    if (r._autoPong = g.autoPong, r._closeTimeout = g.closeTimeout, !A.includes(g.protocolVersion))
-      throw new RangeError(
-        `Unsupported protocol version: ${g.protocolVersion} (supported versions: ${A.join(", ")})`
-      );
-    let U;
-    if (o instanceof _)
-      U = o;
-    else
-      try {
-        U = new _(o);
-      } catch {
-        throw new SyntaxError(`Invalid URL: ${o}`);
-      }
-    U.protocol === "http:" ? U.protocol = "ws:" : U.protocol === "https:" && (U.protocol = "wss:"), r._url = U.href;
-    const z = U.protocol === "wss:", H = U.protocol === "ws+unix:";
-    let X;
-    if (U.protocol !== "ws:" && !z && !H ? X = `The URL's protocol must be one of "ws:", "wss:", "http:", "https:", or "ws+unix:"` : H && !U.pathname ? X = "The URL's pathname is empty" : U.hash && (X = "The URL contains a fragment identifier"), X) {
-      const I = new SyntaxError(X);
-      if (r._redirects === 0)
-        throw I;
-      j(r, I);
-      return;
-    }
-    const Be = z ? 443 : 80, De = d(16).toString("base64"), Ie = z ? T.request : M.request, Z = /* @__PURE__ */ new Set();
-    let Q;
-    if (g.createConnection = g.createConnection || (z ? he : ne), g.defaultPort = g.defaultPort || Be, g.port = U.port || Be, g.host = U.hostname.startsWith("[") ? U.hostname.slice(1, -1) : U.hostname, g.headers = {
-      ...g.headers,
-      "Sec-WebSocket-Version": g.protocolVersion,
-      "Sec-WebSocket-Key": De,
-      Connection: "Upgrade",
-      Upgrade: "websocket"
-    }, g.path = U.pathname + U.search, g.timeout = g.handshakeTimeout, g.perMessageDeflate && (Q = new h(
-      g.perMessageDeflate !== !0 ? g.perMessageDeflate : {},
-      !1,
-      g.maxPayload
-    ), g.headers["Sec-WebSocket-Extensions"] = m({
-      [h.extensionName]: Q.offer()
-    })), y.length) {
-      for (const I of y) {
-        if (typeof I != "string" || !G.test(I) || Z.has(I))
-          throw new SyntaxError(
-            "An invalid or duplicated subprotocol was specified"
-          );
-        Z.add(I);
-      }
-      g.headers["Sec-WebSocket-Protocol"] = y.join(",");
-    }
-    if (g.origin && (g.protocolVersion < 13 ? g.headers["Sec-WebSocket-Origin"] = g.origin : g.headers.Origin = g.origin), (U.username || U.password) && (g.auth = `${U.username}:${U.password}`), H) {
-      const I = g.path.split(":");
-      g.socketPath = I[0], g.path = I[1];
-    }
-    let $;
-    if (g.followRedirects) {
-      if (r._redirects === 0) {
-        r._originalIpc = H, r._originalSecure = z, r._originalHostOrSocketPath = H ? g.socketPath : U.host;
-        const I = k && k.headers;
-        if (k = { ...k, headers: {} }, I)
-          for (const [V, Y] of Object.entries(I))
-            k.headers[V.toLowerCase()] = Y;
-      } else if (r.listenerCount("redirect") === 0) {
-        const I = H ? r._originalIpc ? g.socketPath === r._originalHostOrSocketPath : !1 : r._originalIpc ? !1 : U.host === r._originalHostOrSocketPath;
-        (!I || r._originalSecure && !z) && (delete g.headers.authorization, delete g.headers.cookie, I || delete g.headers.host, g.auth = void 0);
-      }
-      g.auth && !k.headers.authorization && (k.headers.authorization = "Basic " + Buffer.from(g.auth).toString("base64")), $ = r._req = Ie(g), r._redirects && r.emit("redirect", r.url, $);
-    } else
-      $ = r._req = Ie(g);
-    g.timeout && $.on("timeout", () => {
-      W(r, $, "Opening handshake has timed out");
-    }), $.on("error", (I) => {
-      $ === null || $[B] || ($ = r._req = null, j(r, I));
-    }), $.on("response", (I) => {
-      const V = I.headers.location, Y = I.statusCode;
-      if (V && g.followRedirects && Y >= 300 && Y < 400) {
-        if (++r._redirects > g.maxRedirects) {
-          W(r, $, "Maximum redirects exceeded");
-          return;
-        }
-        $.abort();
-        let J;
-        try {
-          J = new _(V, o);
-        } catch {
-          const K = new SyntaxError(`Invalid URL: ${V}`);
-          j(r, K);
-          return;
-        }
-        F(r, J, y, k);
-      } else r.emit("unexpected-response", $, I) || W(
-        r,
-        $,
-        `Unexpected server response: ${I.statusCode}`
-      );
-    }), $.on("upgrade", (I, V, Y) => {
-      if (r.emit("upgrade", I), r.readyState !== S.CONNECTING) return;
-      $ = r._req = null;
-      const J = I.headers.upgrade;
-      if (J === void 0 || J.toLowerCase() !== "websocket") {
-        W(r, V, "Invalid Upgrade header");
-        return;
-      }
-      const Ue = n("sha1").update(De + p).digest("base64");
-      if (I.headers["sec-websocket-accept"] !== Ue) {
-        W(r, V, "Invalid Sec-WebSocket-Accept header");
-        return;
-      }
-      const K = I.headers["sec-websocket-protocol"];
-      let ee;
-      if (K !== void 0 ? Z.size ? Z.has(K) || (ee = "Server sent an invalid subprotocol") : ee = "Server sent a subprotocol but none was requested" : Z.size && (ee = "Server sent no subprotocol"), ee) {
-        W(r, V, ee);
-        return;
-      }
-      K && (r._protocol = K);
-      const Me = I.headers["sec-websocket-extensions"];
-      if (Me !== void 0) {
-        if (!Q) {
-          W(r, V, "Server sent a Sec-WebSocket-Extensions header but no extension was requested");
-          return;
-        }
-        let ue;
-        try {
-          ue = u(Me);
-        } catch {
-          W(r, V, "Invalid Sec-WebSocket-Extensions header");
-          return;
-        }
-        const Ae = Object.keys(ue);
-        if (Ae.length !== 1 || Ae[0] !== h.extensionName) {
-          W(r, V, "Server indicated an extension that was not requested");
-          return;
-        }
-        try {
-          Q.accept(ue[h.extensionName]);
-        } catch {
-          W(r, V, "Invalid Sec-WebSocket-Extensions header");
-          return;
-        }
-        r._extensions[h.extensionName] = Q;
-      }
-      r.setSocket(V, Y, {
-        allowSynchronousEvents: g.allowSynchronousEvents,
-        generateMask: g.generateMask,
-        maxPayload: g.maxPayload,
-        skipUTF8Validation: g.skipUTF8Validation
-      });
-    }), g.finishRequest ? g.finishRequest($, r) : $.end();
-  }
-  function j(r, o) {
-    r._readyState = S.CLOSING, r._errorEmitted = !0, r.emit("error", o), r.emitClose();
-  }
-  function ne(r) {
-    return r.path = r.socketPath, D.connect(r);
-  }
-  function he(r) {
-    return r.path = void 0, !r.servername && r.servername !== "" && (r.servername = D.isIP(r.host) ? "" : r.host), x.connect(r);
-  }
-  function W(r, o, y) {
-    r._readyState = S.CLOSING;
-    const k = new Error(y);
-    Error.captureStackTrace(k, W), o.setHeader ? (o[B] = !0, o.abort(), o.socket && !o.socket.destroyed && o.socket.destroy(), process.nextTick(j, r, k)) : (o.destroy(k), o.once("error", r.emit.bind(r, "error")), o.once("close", r.emitClose.bind(r)));
-  }
-  function ce(r, o, y) {
-    if (o) {
-      const k = b(o) ? o.size : R(o).length;
-      r._socket ? r._sender._bufferedBytes += k : r._bufferedAmount += k;
-    }
-    if (y) {
-      const k = new Error(
-        `WebSocket is not open: readyState ${r.readyState} (${N[r.readyState]})`
-      );
-      process.nextTick(y, k);
-    }
-  }
-  function nt(r, o) {
-    const y = this[t];
-    y._closeFrameReceived = !0, y._closeMessage = o, y._closeCode = r, y._socket[t] !== void 0 && (y._socket.removeListener("data", oe), process.nextTick(Le, y._socket), r === 1005 ? y.close() : y.close(r, o));
-  }
-  function ot() {
-    const r = this[t];
-    r.isPaused || r._socket.resume();
-  }
-  function at(r) {
-    const o = this[t];
-    o._socket[t] !== void 0 && (o._socket.removeListener("data", oe), process.nextTick(Le, o._socket), o.close(r[w])), o._errorEmitted || (o._errorEmitted = !0, o.emit("error", r));
-  }
-  function Ce() {
-    this[t].emitClose();
-  }
-  function lt(r, o) {
-    this[t].emit("message", r, o);
-  }
-  function ft(r) {
-    const o = this[t];
-    o._autoPong && o.pong(r, !this._isServer, e), o.emit("ping", r);
-  }
-  function ht(r) {
-    this[t].emit("pong", r);
-  }
-  function Le(r) {
-    r.resume();
-  }
-  function ct(r) {
-    const o = this[t];
-    o.readyState !== S.CLOSED && (o.readyState === S.OPEN && (o._readyState = S.CLOSING, ke(o)), this._socket.end(), o._errorEmitted || (o._errorEmitted = !0, o.emit("error", r)));
-  }
-  function ke(r) {
-    r._closeTimer = setTimeout(
-      r._socket.destroy.bind(r._socket),
-      r._closeTimeout
-    );
-  }
-  function Ne() {
-    const r = this[t];
-    if (this.removeListener("close", Ne), this.removeListener("data", oe), this.removeListener("end", Pe), r._readyState = S.CLOSING, !this._readableState.endEmitted && !r._closeFrameReceived && !r._receiver._writableState.errorEmitted && this._readableState.length !== 0) {
-      const o = this.read(this._readableState.length);
-      r._receiver.write(o);
-    }
-    r._receiver.end(), this[t] = void 0, clearTimeout(r._closeTimer), r._receiver._writableState.finished || r._receiver._writableState.errorEmitted ? r.emitClose() : (r._receiver.on("error", Ce), r._receiver.on("finish", Ce));
-  }
-  function oe(r) {
-    this[t]._receiver.write(r) || this.pause();
-  }
-  function Pe() {
-    const r = this[t];
-    r._readyState = S.CLOSING, r._receiver.end(), this.end();
-  }
-  function Re() {
-    const r = this[t];
-    this.removeListener("error", Re), this.on("error", e), r && (r._readyState = S.CLOSING, this.destroy());
-  }
-  return xe;
-}
-var ve, Ke;
-function Lt() {
-  if (Ke) return ve;
-  Ke = 1, Te();
-  const { Duplex: P } = se;
-  function T(d) {
-    d.emit("close");
-  }
-  function M() {
-    !this.destroyed && this._writableState.finished && this.destroy();
-  }
-  function D(d) {
-    this.removeListener("error", D), this.destroy(), this.listenerCount("error") === 0 && this.emit("error", d);
-  }
-  function x(d, n) {
-    let l = !0;
-    const a = new P({
-      ...n,
-      autoDestroy: !1,
-      emitClose: !1,
-      objectMode: !1,
-      writableObjectMode: !1
-    });
-    return d.on("message", function(h, L) {
-      const c = !L && a._readableState.objectMode ? h.toString() : h;
-      a.push(c) || d.pause();
-    }), d.once("error", function(h) {
-      a.destroyed || (l = !1, a.destroy(h));
-    }), d.once("close", function() {
-      a.destroyed || a.push(null);
-    }), a._destroy = function(_, h) {
-      if (d.readyState === d.CLOSED) {
-        h(_), process.nextTick(T, a);
-        return;
-      }
-      let L = !1;
-      d.once("error", function(b) {
-        L = !0, h(b);
-      }), d.once("close", function() {
-        L || h(_), process.nextTick(T, a);
-      }), l && d.terminate();
-    }, a._final = function(_) {
-      if (d.readyState === d.CONNECTING) {
-        d.once("open", function() {
-          a._final(_);
-        });
-        return;
-      }
-      d._socket !== null && (d._socket._writableState.finished ? (_(), a._readableState.endEmitted && a.destroy()) : (d._socket.once("finish", function() {
-        _();
-      }), d.close()));
-    }, a._read = function() {
-      d.isPaused && d.resume();
-    }, a._write = function(_, h, L) {
-      if (d.readyState === d.CONNECTING) {
-        d.once("open", function() {
-          a._write(_, h, L);
-        });
-        return;
-      }
-      d.send(_, L);
-    }, a.on("end", M), a.on("error", D), a;
-  }
-  return ve = x, ve;
-}
-Lt();
-rt();
-st();
-var kt = Te();
-const Nt = /* @__PURE__ */ yt(kt);
-var be, Xe;
-function Pt() {
-  if (Xe) return be;
-  Xe = 1;
-  const { tokenChars: P } = ie();
-  function T(M) {
-    const D = /* @__PURE__ */ new Set();
-    let x = -1, d = -1, n = 0;
-    for (n; n < M.length; n++) {
-      const a = M.charCodeAt(n);
-      if (d === -1 && P[a] === 1)
-        x === -1 && (x = n);
-      else if (n !== 0 && (a === 32 || a === 9))
-        d === -1 && x !== -1 && (d = n);
-      else if (a === 44) {
-        if (x === -1)
-          throw new SyntaxError(`Unexpected character at index ${n}`);
-        d === -1 && (d = n);
-        const _ = M.slice(x, d);
-        if (D.has(_))
-          throw new SyntaxError(`The "${_}" subprotocol is duplicated`);
-        D.add(_), x = d = -1;
-      } else
-        throw new SyntaxError(`Unexpected character at index ${n}`);
-    }
-    if (x === -1 || d !== -1)
-      throw new SyntaxError("Unexpected end of input");
-    const l = M.slice(x, n);
-    if (D.has(l))
-      throw new SyntaxError(`The "${l}" subprotocol is duplicated`);
-    return D.add(l), D;
-  }
-  return be = { parse: T }, be;
-}
-var we, Ze;
-function Rt() {
-  if (Ze) return we;
-  Ze = 1;
-  const P = Qe, T = Je, { Duplex: M } = se, { createHash: D } = Oe, x = it(), d = le(), n = Pt(), l = Te(), { CLOSE_TIMEOUT: a, GUID: _, kWebSocket: h } = q(), L = /^[+/0-9A-Za-z]{22}==$/, c = 0, b = 1, C = 2;
-  class v extends P {
-    /**
-     * Create a `WebSocketServer` instance.
-     *
-     * @param {Object} options Configuration options
-     * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
-     *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
-     *     multiple times in the same tick
-     * @param {Boolean} [options.autoPong=true] Specifies whether or not to
-     *     automatically send a pong in response to a ping
-     * @param {Number} [options.backlog=511] The maximum length of the queue of
-     *     pending connections
-     * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
-     *     track clients
-     * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to
-     *     wait for the closing handshake to finish after `websocket.close()` is
-     *     called
-     * @param {Function} [options.handleProtocols] A hook to handle protocols
-     * @param {String} [options.host] The hostname where to bind the server
-     * @param {Number} [options.maxPayload=104857600] The maximum allowed message
-     *     size
-     * @param {Boolean} [options.noServer=false] Enable no server mode
-     * @param {String} [options.path] Accept only connections matching this path
-     * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
-     *     permessage-deflate
-     * @param {Number} [options.port] The port where to bind the server
-     * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
-     *     server to use
-     * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
-     *     not to skip UTF-8 validation for text and close messages
-     * @param {Function} [options.verifyClient] A hook to reject connections
-     * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
-     *     class to use. It must be the `WebSocket` class or class that extends it
-     * @param {Function} [callback] A listener for the `listening` event
-     */
-    constructor(e, s) {
-      if (super(), e = {
-        allowSynchronousEvents: !0,
-        autoPong: !0,
-        maxPayload: 100 * 1024 * 1024,
-        skipUTF8Validation: !1,
-        perMessageDeflate: !1,
-        handleProtocols: null,
-        clientTracking: !0,
-        closeTimeout: a,
-        verifyClient: null,
-        noServer: !1,
-        backlog: null,
-        // use default (511 as implemented in net.js)
-        server: null,
-        host: null,
-        path: null,
-        port: null,
-        WebSocket: l,
-        ...e
-      }, e.port == null && !e.server && !e.noServer || e.port != null && (e.server || e.noServer) || e.server && e.noServer)
-        throw new TypeError(
-          'One and only one of the "port", "server", or "noServer" options must be specified'
-        );
-      if (e.port != null ? (this._server = T.createServer((i, m) => {
-        const u = T.STATUS_CODES[426];
-        m.writeHead(426, {
-          "Content-Length": u.length,
-          "Content-Type": "text/plain"
-        }), m.end(u);
-      }), this._server.listen(
-        e.port,
-        e.host,
-        e.backlog,
-        s
-      )) : e.server && (this._server = e.server), this._server) {
-        const i = this.emit.bind(this, "connection");
-        this._removeListeners = O(this._server, {
-          listening: this.emit.bind(this, "listening"),
-          error: this.emit.bind(this, "error"),
-          upgrade: (m, u, R) => {
-            this.handleUpgrade(m, u, R, i);
-          }
-        });
-      }
-      e.perMessageDeflate === !0 && (e.perMessageDeflate = {}), e.clientTracking && (this.clients = /* @__PURE__ */ new Set(), this._shouldEmitClose = !1), this.options = e, this._state = c;
-    }
-    /**
-     * Returns the bound address, the address family name, and port of the server
-     * as reported by the operating system if listening on an IP socket.
-     * If the server is listening on a pipe or UNIX domain socket, the name is
-     * returned as a string.
-     *
-     * @return {(Object|String|null)} The address of the server
-     * @public
-     */
-    address() {
-      if (this.options.noServer)
-        throw new Error('The server is operating in "noServer" mode');
-      return this._server ? this._server.address() : null;
-    }
-    /**
-     * Stop the server from accepting new connections and emit the `'close'` event
-     * when all existing connections are closed.
-     *
-     * @param {Function} [cb] A one-time listener for the `'close'` event
-     * @public
-     */
-    close(e) {
-      if (this._state === C) {
-        e && this.once("close", () => {
-          e(new Error("The server is not running"));
-        }), process.nextTick(p, this);
-        return;
-      }
-      if (e && this.once("close", e), this._state !== b)
-        if (this._state = b, this.options.noServer || this.options.server)
-          this._server && (this._removeListeners(), this._removeListeners = this._server = null), this.clients ? this.clients.size ? this._shouldEmitClose = !0 : process.nextTick(p, this) : process.nextTick(p, this);
-        else {
-          const s = this._server;
-          this._removeListeners(), this._removeListeners = this._server = null, s.close(() => {
-            p(this);
-          });
-        }
-    }
-    /**
-     * See if a given request should be handled by this server instance.
-     *
-     * @param {http.IncomingMessage} req Request object to inspect
-     * @return {Boolean} `true` if the request is valid, else `false`
-     * @public
-     */
-    shouldHandle(e) {
-      if (this.options.path) {
-        const s = e.url.indexOf("?");
-        if ((s !== -1 ? e.url.slice(0, s) : e.url) !== this.options.path) return !1;
-      }
-      return !0;
-    }
-    /**
-     * Handle a HTTP Upgrade request.
-     *
-     * @param {http.IncomingMessage} req The request object
-     * @param {Duplex} socket The network socket between the server and client
-     * @param {Buffer} head The first packet of the upgraded stream
-     * @param {Function} cb Callback
-     * @public
-     */
-    handleUpgrade(e, s, i, m) {
-      s.on("error", f);
-      const u = e.headers["sec-websocket-key"], R = e.headers.upgrade, B = +e.headers["sec-websocket-version"];
-      if (e.method !== "GET") {
-        w(this, e, s, 405, "Invalid HTTP method");
-        return;
-      }
-      if (R === void 0 || R.toLowerCase() !== "websocket") {
-        w(this, e, s, 400, "Invalid Upgrade header");
-        return;
-      }
-      if (u === void 0 || !L.test(u)) {
-        w(this, e, s, 400, "Missing or invalid Sec-WebSocket-Key header");
-        return;
-      }
-      if (B !== 13 && B !== 8) {
-        w(this, e, s, 400, "Missing or invalid Sec-WebSocket-Version header", {
-          "Sec-WebSocket-Version": "13, 8"
-        });
-        return;
-      }
-      if (!this.shouldHandle(e)) {
-        E(s, 400);
-        return;
-      }
-      const A = e.headers["sec-websocket-protocol"];
-      let N = /* @__PURE__ */ new Set();
-      if (A !== void 0)
-        try {
-          N = n.parse(A);
-        } catch {
-          w(this, e, s, 400, "Invalid Sec-WebSocket-Protocol header");
-          return;
-        }
-      const G = e.headers["sec-websocket-extensions"], S = {};
-      if (this.options.perMessageDeflate && G !== void 0) {
-        const F = new d(
-          this.options.perMessageDeflate,
-          !0,
-          this.options.maxPayload
-        );
-        try {
-          const j = x.parse(G);
-          j[d.extensionName] && (F.accept(j[d.extensionName]), S[d.extensionName] = F);
-        } catch {
-          w(this, e, s, 400, "Invalid or unacceptable Sec-WebSocket-Extensions header");
-          return;
-        }
-      }
-      if (this.options.verifyClient) {
-        const F = {
-          origin: e.headers[`${B === 8 ? "sec-websocket-origin" : "origin"}`],
-          secure: !!(e.socket.authorized || e.socket.encrypted),
-          req: e
-        };
-        if (this.options.verifyClient.length === 2) {
-          this.options.verifyClient(F, (j, ne, he, W) => {
-            if (!j)
-              return E(s, ne || 401, he, W);
-            this.completeUpgrade(
-              S,
-              u,
-              N,
-              e,
-              s,
-              i,
-              m
-            );
-          });
-          return;
-        }
-        if (!this.options.verifyClient(F)) return E(s, 401);
-      }
-      this.completeUpgrade(S, u, N, e, s, i, m);
-    }
-    /**
-     * Upgrade the connection to WebSocket.
-     *
-     * @param {Object} extensions The accepted extensions
-     * @param {String} key The value of the `Sec-WebSocket-Key` header
-     * @param {Set} protocols The subprotocols
-     * @param {http.IncomingMessage} req The request object
-     * @param {Duplex} socket The network socket between the server and client
-     * @param {Buffer} head The first packet of the upgraded stream
-     * @param {Function} cb Callback
-     * @throws {Error} If called more than once with the same socket
-     * @private
-     */
-    completeUpgrade(e, s, i, m, u, R, B) {
-      if (!u.readable || !u.writable) return u.destroy();
-      if (u[h])
-        throw new Error(
-          "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration"
-        );
-      if (this._state > c) return E(u, 503);
-      const N = [
-        "HTTP/1.1 101 Switching Protocols",
-        "Upgrade: websocket",
-        "Connection: Upgrade",
-        `Sec-WebSocket-Accept: ${D("sha1").update(s + _).digest("base64")}`
-      ], G = new this.options.WebSocket(null, void 0, this.options);
-      if (i.size) {
-        const S = this.options.handleProtocols ? this.options.handleProtocols(i, m) : i.values().next().value;
-        S && (N.push(`Sec-WebSocket-Protocol: ${S}`), G._protocol = S);
-      }
-      if (e[d.extensionName]) {
-        const S = e[d.extensionName].params, F = x.format({
-          [d.extensionName]: [S]
-        });
-        N.push(`Sec-WebSocket-Extensions: ${F}`), G._extensions = e;
-      }
-      this.emit("headers", N, m), u.write(N.concat(`\r
-`).join(`\r
-`)), u.removeListener("error", f), G.setSocket(u, R, {
-        allowSynchronousEvents: this.options.allowSynchronousEvents,
-        maxPayload: this.options.maxPayload,
-        skipUTF8Validation: this.options.skipUTF8Validation
-      }), this.clients && (this.clients.add(G), G.on("close", () => {
-        this.clients.delete(G), this._shouldEmitClose && !this.clients.size && process.nextTick(p, this);
-      })), B(G, m);
-    }
-  }
-  we = v;
-  function O(t, e) {
-    for (const s of Object.keys(e)) t.on(s, e[s]);
-    return function() {
-      for (const i of Object.keys(e))
-        t.removeListener(i, e[i]);
-    };
-  }
-  function p(t) {
-    t._state = C, t.emit("close");
-  }
-  function f() {
-    this.destroy();
-  }
-  function E(t, e, s, i) {
-    s = s || T.STATUS_CODES[e], i = {
-      Connection: "close",
-      "Content-Type": "text/html",
-      "Content-Length": Buffer.byteLength(s),
-      ...i
-    }, t.once("finish", t.destroy), t.end(
-      `HTTP/1.1 ${e} ${T.STATUS_CODES[e]}\r
-` + Object.keys(i).map((m) => `${m}: ${i[m]}`).join(`\r
-`) + `\r
-\r
-` + s
-    );
-  }
-  function w(t, e, s, i, m, u) {
-    if (t.listenerCount("wsClientError")) {
-      const R = new Error(m);
-      Error.captureStackTrace(R, w), t.emit("wsClientError", R, s, e);
-    } else
-      E(s, i, m, u);
-  }
-  return we;
-}
-Rt();
-const fe = global;
-fe.WebSocket ||= Nt;
-fe.window ||= global;
-fe.self ||= global;
-fe.window.__REACT_DEVTOOLS_COMPONENT_FILTERS__ = [
-  {
-    // ComponentFilterElementType
-    type: 1,
-    // ElementTypeHostComponent
-    value: 7,
-    isEnabled: !0
-  },
-  {
-    // ComponentFilterDisplayName
-    type: 2,
-    value: "InternalApp",
-    isEnabled: !0,
-    isValid: !0
-  },
-  {
-    // ComponentFilterDisplayName
-    type: 2,
-    value: "InternalAppContext",
-    isEnabled: !0,
-    isValid: !0
-  },
-  {
-    // ComponentFilterDisplayName
-    type: 2,
-    value: "InternalStdoutContext",
-    isEnabled: !0,
-    isValid: !0
-  },
-  {
-    // ComponentFilterDisplayName
-    type: 2,
-    value: "InternalStderrContext",
-    isEnabled: !0,
-    isValid: !0
-  },
-  {
-    // ComponentFilterDisplayName
-    type: 2,
-    value: "InternalStdinContext",
-    isEnabled: !0,
-    isValid: !0
-  },
-  {
-    // ComponentFilterDisplayName
-    type: 2,
-    value: "InternalFocusContext",
-    isEnabled: !0,
-    isValid: !0
-  }
-];
-tt.initialize();
-tt.connectToDevTools();