zen-code 1.0.0

package/dist/devtools-m8Lnvjy_.mjs

@@ -0,0 +1,2658 @@
+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 j() {
+  if ($e) return _e;
+  $e = 1;
+  const P = ["nodebuffer", "arraybuffer", "fragments"], T = typeof Blob < "u";
+  return T && P.push("blob"), _e = {
+    BINARY_TYPES: P,
+    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 xt = {}, St = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: xt
+}, Symbol.toStringTag, { value: "Module" })), vt = /* @__PURE__ */ et(St);
+var Fe;
+function oe() {
+  if (Fe) return te.exports;
+  Fe = 1;
+  const { EMPTY_BUFFER: P } = j(), T = Buffer[Symbol.species];
+  function M(f, a) {
+    if (f.length === 0) return P;
+    if (f.length === 1) return f[0];
+    const _ = Buffer.allocUnsafe(a);
+    let h = 0;
+    for (let C = 0; C < f.length; C++) {
+      const c = f[C];
+      _.set(c, h), h += c.length;
+    }
+    return h < a ? new T(_.buffer, _.byteOffset, h) : _;
+  }
+  function B(f, a, _, h, C) {
+    for (let c = 0; c < C; c++)
+      _[h + c] = f[c] ^ a[c & 3];
+  }
+  function b(f, a) {
+    for (let _ = 0; _ < f.length; _++)
+      f[_] ^= a[_ & 3];
+  }
+  function d(f) {
+    return f.length === f.buffer.byteLength ? f.buffer : f.buffer.slice(f.byteOffset, f.byteOffset + f.length);
+  }
+  function n(f) {
+    if (n.readOnly = !0, Buffer.isBuffer(f)) return f;
+    let a;
+    return f instanceof ArrayBuffer ? a = new T(f) : ArrayBuffer.isView(f) ? a = new T(f.buffer, f.byteOffset, f.byteLength) : (a = Buffer.from(f), n.readOnly = !1), a;
+  }
+  if (te.exports = {
+    concat: M,
+    mask: B,
+    toArrayBuffer: d,
+    toBuffer: n,
+    unmask: b
+  }, !process.env.WS_NO_BUFFER_UTIL)
+    try {
+      const f = vt;
+      te.exports.mask = function(a, _, h, C, c) {
+        c < 48 ? B(a, _, h, C, c) : f.mask(a, _, h, C, c);
+      }, te.exports.unmask = function(a, _) {
+        a.length < 32 ? b(a, _) : f.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(b) {
+      this[P] = () => {
+        this.pending--, this[T]();
+      }, this.concurrency = b || 1 / 0, this.jobs = [], this.pending = 0;
+    }
+    /**
+     * Adds a job to the queue.
+     *
+     * @param {Function} job The job to run
+     * @public
+     */
+    add(b) {
+      this.jobs.push(b), this[T]();
+    }
+    /**
+     * Removes a job from the queue and runs it if possible.
+     *
+     * @private
+     */
+    [T]() {
+      if (this.pending !== this.concurrency && this.jobs.length) {
+        const b = this.jobs.shift();
+        this.pending++, b(this[P]);
+      }
+    }
+  }
+  return pe = M, pe;
+}
+var me, Ve;
+function ae() {
+  if (Ve) return me;
+  Ve = 1;
+  const P = gt, T = oe(), M = bt(), { kStatusCode: B } = j(), b = Buffer[Symbol.species], d = Buffer.from([0, 0, 255, 255]), n = /* @__PURE__ */ Symbol("permessage-deflate"), f = /* @__PURE__ */ Symbol("total-length"), a = /* @__PURE__ */ Symbol("callback"), _ = /* @__PURE__ */ Symbol("buffers"), h = /* @__PURE__ */ Symbol("error");
+  let C;
+  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, l, E) {
+      if (this._maxPayload = E | 0, this._options = p || {}, this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024, this._isServer = !!l, this._deflate = null, this._inflate = null, this.params = null, !C) {
+        const u = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
+        C = new M(u);
+      }
+    }
+    /**
+     * @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 l = this._options, E = p.find((u) => !(l.serverNoContextTakeover === !1 && u.server_no_context_takeover || u.server_max_window_bits && (l.serverMaxWindowBits === !1 || typeof l.serverMaxWindowBits == "number" && l.serverMaxWindowBits > u.server_max_window_bits) || typeof l.clientMaxWindowBits == "number" && !u.client_max_window_bits));
+      if (!E)
+        throw new Error("None of the extension offers can be accepted");
+      return l.serverNoContextTakeover && (E.server_no_context_takeover = !0), l.clientNoContextTakeover && (E.client_no_context_takeover = !0), typeof l.serverMaxWindowBits == "number" && (E.server_max_window_bits = l.serverMaxWindowBits), typeof l.clientMaxWindowBits == "number" ? E.client_max_window_bits = l.clientMaxWindowBits : (E.client_max_window_bits === !0 || l.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 l = p[0];
+      if (this._options.clientNoContextTakeover === !1 && l.client_no_context_takeover)
+        throw new Error('Unexpected parameter "client_no_context_takeover"');
+      if (!l.client_max_window_bits)
+        typeof this._options.clientMaxWindowBits == "number" && (l.client_max_window_bits = this._options.clientMaxWindowBits);
+      else if (this._options.clientMaxWindowBits === !1 || typeof this._options.clientMaxWindowBits == "number" && l.client_max_window_bits > this._options.clientMaxWindowBits)
+        throw new Error(
+          'Unexpected or invalid parameter "client_max_window_bits"'
+        );
+      return l;
+    }
+    /**
+     * Normalize parameters.
+     *
+     * @param {Array} configurations The extension negotiation offers/reponse
+     * @return {Array} The offers/response with normalized parameters
+     * @private
+     */
+    normalizeParams(p) {
+      return p.forEach((l) => {
+        Object.keys(l).forEach((E) => {
+          let u = l[E];
+          if (u.length > 1)
+            throw new Error(`Parameter "${E}" must have only a single value`);
+          if (u = u[0], E === "client_max_window_bits") {
+            if (u !== !0) {
+              const e = +u;
+              if (!Number.isInteger(e) || e < 8 || e > 15)
+                throw new TypeError(
+                  `Invalid value for parameter "${E}": ${u}`
+                );
+              u = e;
+            } else if (!this._isServer)
+              throw new TypeError(
+                `Invalid value for parameter "${E}": ${u}`
+              );
+          } else if (E === "server_max_window_bits") {
+            const e = +u;
+            if (!Number.isInteger(e) || e < 8 || e > 15)
+              throw new TypeError(
+                `Invalid value for parameter "${E}": ${u}`
+              );
+            u = e;
+          } else if (E === "client_no_context_takeover" || E === "server_no_context_takeover") {
+            if (u !== !0)
+              throw new TypeError(
+                `Invalid value for parameter "${E}": ${u}`
+              );
+          } else
+            throw new Error(`Unknown parameter "${E}"`);
+          l[E] = u;
+        });
+      }), 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, l, E) {
+      C.add((u) => {
+        this._decompress(p, l, (e, t) => {
+          u(), E(e, t);
+        });
+      });
+    }
+    /**
+     * 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, l, E) {
+      C.add((u) => {
+        this._compress(p, l, (e, t) => {
+          u(), E(e, t);
+        });
+      });
+    }
+    /**
+     * 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, l, E) {
+      const u = this._isServer ? "client" : "server";
+      if (!this._inflate) {
+        const e = `${u}_max_window_bits`, t = typeof this.params[e] != "number" ? P.Z_DEFAULT_WINDOWBITS : this.params[e];
+        this._inflate = P.createInflateRaw({
+          ...this._options.zlibInflateOptions,
+          windowBits: t
+        }), this._inflate[n] = this, this._inflate[f] = 0, this._inflate[_] = [], this._inflate.on("error", v), this._inflate.on("data", k);
+      }
+      this._inflate[a] = E, this._inflate.write(p), l && this._inflate.write(d), this._inflate.flush(() => {
+        const e = this._inflate[h];
+        if (e) {
+          this._inflate.close(), this._inflate = null, E(e);
+          return;
+        }
+        const t = T.concat(
+          this._inflate[_],
+          this._inflate[f]
+        );
+        this._inflate._readableState.endEmitted ? (this._inflate.close(), this._inflate = null) : (this._inflate[f] = 0, this._inflate[_] = [], l && this.params[`${u}_no_context_takeover`] && this._inflate.reset()), E(null, t);
+      });
+    }
+    /**
+     * 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, l, E) {
+      const u = this._isServer ? "server" : "client";
+      if (!this._deflate) {
+        const e = `${u}_max_window_bits`, t = typeof this.params[e] != "number" ? P.Z_DEFAULT_WINDOWBITS : this.params[e];
+        this._deflate = P.createDeflateRaw({
+          ...this._options.zlibDeflateOptions,
+          windowBits: t
+        }), this._deflate[f] = 0, this._deflate[_] = [], this._deflate.on("data", w);
+      }
+      this._deflate[a] = E, this._deflate.write(p), this._deflate.flush(P.Z_SYNC_FLUSH, () => {
+        if (!this._deflate)
+          return;
+        let e = T.concat(
+          this._deflate[_],
+          this._deflate[f]
+        );
+        l && (e = new b(e.buffer, e.byteOffset, e.length - 4)), this._deflate[a] = null, this._deflate[f] = 0, this._deflate[_] = [], l && this.params[`${u}_no_context_takeover`] && this._deflate.reset(), E(null, e);
+      });
+    }
+  }
+  me = c;
+  function w(O) {
+    this[_].push(O), this[f] += O.length;
+  }
+  function k(O) {
+    if (this[f] += O.length, this[n]._maxPayload < 1 || this[f] <= 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][B] = 1009, this.removeListener("data", k), this.reset();
+  }
+  function v(O) {
+    if (this[n]._inflate = null, this[h]) {
+      this[a](this[h]);
+      return;
+    }
+    O[B] = 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 } = j(), 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 B(n) {
+    return n >= 1e3 && n <= 1014 && n !== 1004 && n !== 1005 && n !== 1006 || n >= 3e3 && n <= 4999;
+  }
+  function b(n) {
+    const f = n.length;
+    let a = 0;
+    for (; a < f; )
+      if ((n[a] & 128) === 0)
+        a++;
+      else if ((n[a] & 224) === 192) {
+        if (a + 1 === f || (n[a + 1] & 192) !== 128 || (n[a] & 254) === 192)
+          return !1;
+        a += 2;
+      } else if ((n[a] & 240) === 224) {
+        if (a + 2 >= f || (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 >= f || (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: B,
+    isValidUTF8: b,
+    tokenChars: M
+  }, P)
+    re.exports.isValidUTF8 = function(n) {
+      return n.length < 24 ? b(n) : P(n);
+    };
+  else if (!process.env.WS_NO_UTF_8_VALIDATE)
+    try {
+      const n = Tt;
+      re.exports.isValidUTF8 = function(f) {
+        return f.length < 32 ? b(f) : n(f);
+      };
+    } catch {
+    }
+  return re.exports;
+}
+var ge, je;
+function rt() {
+  if (je) return ge;
+  je = 1;
+  const { Writable: P } = se, T = ae(), {
+    BINARY_TYPES: M,
+    EMPTY_BUFFER: B,
+    kStatusCode: b,
+    kWebSocket: d
+  } = j(), { concat: n, toArrayBuffer: f, unmask: a } = oe(), { isValidStatusCode: _, isValidUTF8: h } = ie(), C = Buffer[Symbol.species], c = 0, w = 1, k = 2, v = 3, O = 4, p = 5, l = 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(e = {}) {
+      super(), this._allowSynchronousEvents = e.allowSynchronousEvents !== void 0 ? e.allowSynchronousEvents : !0, this._binaryType = e.binaryType || M[0], this._extensions = e.extensions || {}, this._isServer = !!e.isServer, this._maxPayload = e.maxPayload | 0, this._skipUTF8Validation = !!e.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(e, t, i) {
+      if (this._opcode === 8 && this._state == c) return i();
+      this._bufferedBytes += e.length, this._buffers.push(e), this.startLoop(i);
+    }
+    /**
+     * Consumes `n` bytes from the buffered data.
+     *
+     * @param {Number} n The number of bytes to consume
+     * @return {Buffer} The consumed bytes
+     * @private
+     */
+    consume(e) {
+      if (this._bufferedBytes -= e, e === this._buffers[0].length) return this._buffers.shift();
+      if (e < this._buffers[0].length) {
+        const i = this._buffers[0];
+        return this._buffers[0] = new C(
+          i.buffer,
+          i.byteOffset + e,
+          i.length - e
+        ), new C(i.buffer, i.byteOffset, e);
+      }
+      const t = Buffer.allocUnsafe(e);
+      do {
+        const i = this._buffers[0], s = t.length - e;
+        e >= i.length ? t.set(this._buffers.shift(), s) : (t.set(new Uint8Array(i.buffer, i.byteOffset, e), s), this._buffers[0] = new C(
+          i.buffer,
+          i.byteOffset + e,
+          i.length - e
+        )), e -= i.length;
+      } while (e > 0);
+      return t;
+    }
+    /**
+     * Starts the parsing loop.
+     *
+     * @param {Function} cb Callback
+     * @private
+     */
+    startLoop(e) {
+      this._loop = !0;
+      do
+        switch (this._state) {
+          case c:
+            this.getInfo(e);
+            break;
+          case w:
+            this.getPayloadLength16(e);
+            break;
+          case k:
+            this.getPayloadLength64(e);
+            break;
+          case v:
+            this.getMask();
+            break;
+          case O:
+            this.getData(e);
+            break;
+          case p:
+          case l:
+            this._loop = !1;
+            return;
+        }
+      while (this._loop);
+      this._errored || e();
+    }
+    /**
+     * Reads the first two bytes of a frame.
+     *
+     * @param {Function} cb Callback
+     * @private
+     */
+    getInfo(e) {
+      if (this._bufferedBytes < 2) {
+        this._loop = !1;
+        return;
+      }
+      const t = this.consume(2);
+      if ((t[0] & 48) !== 0) {
+        const s = this.createError(
+          RangeError,
+          "RSV2 and RSV3 must be clear",
+          !0,
+          1002,
+          "WS_ERR_UNEXPECTED_RSV_2_3"
+        );
+        e(s);
+        return;
+      }
+      const i = (t[0] & 64) === 64;
+      if (i && !this._extensions[T.extensionName]) {
+        const s = this.createError(
+          RangeError,
+          "RSV1 must be clear",
+          !0,
+          1002,
+          "WS_ERR_UNEXPECTED_RSV_1"
+        );
+        e(s);
+        return;
+      }
+      if (this._fin = (t[0] & 128) === 128, this._opcode = t[0] & 15, this._payloadLength = t[1] & 127, this._opcode === 0) {
+        if (i) {
+          const s = this.createError(
+            RangeError,
+            "RSV1 must be clear",
+            !0,
+            1002,
+            "WS_ERR_UNEXPECTED_RSV_1"
+          );
+          e(s);
+          return;
+        }
+        if (!this._fragmented) {
+          const s = this.createError(
+            RangeError,
+            "invalid opcode 0",
+            !0,
+            1002,
+            "WS_ERR_INVALID_OPCODE"
+          );
+          e(s);
+          return;
+        }
+        this._opcode = this._fragmented;
+      } else if (this._opcode === 1 || this._opcode === 2) {
+        if (this._fragmented) {
+          const s = this.createError(
+            RangeError,
+            `invalid opcode ${this._opcode}`,
+            !0,
+            1002,
+            "WS_ERR_INVALID_OPCODE"
+          );
+          e(s);
+          return;
+        }
+        this._compressed = i;
+      } else if (this._opcode > 7 && this._opcode < 11) {
+        if (!this._fin) {
+          const s = this.createError(
+            RangeError,
+            "FIN must be set",
+            !0,
+            1002,
+            "WS_ERR_EXPECTED_FIN"
+          );
+          e(s);
+          return;
+        }
+        if (i) {
+          const s = this.createError(
+            RangeError,
+            "RSV1 must be clear",
+            !0,
+            1002,
+            "WS_ERR_UNEXPECTED_RSV_1"
+          );
+          e(s);
+          return;
+        }
+        if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
+          const s = this.createError(
+            RangeError,
+            `invalid payload length ${this._payloadLength}`,
+            !0,
+            1002,
+            "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
+          );
+          e(s);
+          return;
+        }
+      } else {
+        const s = this.createError(
+          RangeError,
+          `invalid opcode ${this._opcode}`,
+          !0,
+          1002,
+          "WS_ERR_INVALID_OPCODE"
+        );
+        e(s);
+        return;
+      }
+      if (!this._fin && !this._fragmented && (this._fragmented = this._opcode), this._masked = (t[1] & 128) === 128, this._isServer) {
+        if (!this._masked) {
+          const s = this.createError(
+            RangeError,
+            "MASK must be set",
+            !0,
+            1002,
+            "WS_ERR_EXPECTED_MASK"
+          );
+          e(s);
+          return;
+        }
+      } else if (this._masked) {
+        const s = this.createError(
+          RangeError,
+          "MASK must be clear",
+          !0,
+          1002,
+          "WS_ERR_UNEXPECTED_MASK"
+        );
+        e(s);
+        return;
+      }
+      this._payloadLength === 126 ? this._state = w : this._payloadLength === 127 ? this._state = k : this.haveLength(e);
+    }
+    /**
+     * Gets extended payload length (7+16).
+     *
+     * @param {Function} cb Callback
+     * @private
+     */
+    getPayloadLength16(e) {
+      if (this._bufferedBytes < 2) {
+        this._loop = !1;
+        return;
+      }
+      this._payloadLength = this.consume(2).readUInt16BE(0), this.haveLength(e);
+    }
+    /**
+     * Gets extended payload length (7+64).
+     *
+     * @param {Function} cb Callback
+     * @private
+     */
+    getPayloadLength64(e) {
+      if (this._bufferedBytes < 8) {
+        this._loop = !1;
+        return;
+      }
+      const t = this.consume(8), i = t.readUInt32BE(0);
+      if (i > Math.pow(2, 21) - 1) {
+        const s = this.createError(
+          RangeError,
+          "Unsupported WebSocket frame: payload length > 2^53 - 1",
+          !1,
+          1009,
+          "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
+        );
+        e(s);
+        return;
+      }
+      this._payloadLength = i * Math.pow(2, 32) + t.readUInt32BE(4), this.haveLength(e);
+    }
+    /**
+     * Payload length has been read.
+     *
+     * @param {Function} cb Callback
+     * @private
+     */
+    haveLength(e) {
+      if (this._payloadLength && this._opcode < 8 && (this._totalPayloadLength += this._payloadLength, this._totalPayloadLength > this._maxPayload && this._maxPayload > 0)) {
+        const t = this.createError(
+          RangeError,
+          "Max payload size exceeded",
+          !1,
+          1009,
+          "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
+        );
+        e(t);
+        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(e) {
+      let t = B;
+      if (this._payloadLength) {
+        if (this._bufferedBytes < this._payloadLength) {
+          this._loop = !1;
+          return;
+        }
+        t = this.consume(this._payloadLength), this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0 && a(t, this._mask);
+      }
+      if (this._opcode > 7) {
+        this.controlMessage(t, e);
+        return;
+      }
+      if (this._compressed) {
+        this._state = p, this.decompress(t, e);
+        return;
+      }
+      t.length && (this._messageLength = this._totalPayloadLength, this._fragments.push(t)), this.dataMessage(e);
+    }
+    /**
+     * Decompresses data.
+     *
+     * @param {Buffer} data Compressed data
+     * @param {Function} cb Callback
+     * @private
+     */
+    decompress(e, t) {
+      this._extensions[T.extensionName].decompress(e, this._fin, (s, m) => {
+        if (s) return t(s);
+        if (m.length) {
+          if (this._messageLength += m.length, this._messageLength > this._maxPayload && this._maxPayload > 0) {
+            const y = this.createError(
+              RangeError,
+              "Max payload size exceeded",
+              !1,
+              1009,
+              "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
+            );
+            t(y);
+            return;
+          }
+          this._fragments.push(m);
+        }
+        this.dataMessage(t), this._state === c && this.startLoop(t);
+      });
+    }
+    /**
+     * Handles a data message.
+     *
+     * @param {Function} cb Callback
+     * @private
+     */
+    dataMessage(e) {
+      if (!this._fin) {
+        this._state = c;
+        return;
+      }
+      const t = this._messageLength, i = this._fragments;
+      if (this._totalPayloadLength = 0, this._messageLength = 0, this._fragmented = 0, this._fragments = [], this._opcode === 2) {
+        let s;
+        this._binaryType === "nodebuffer" ? s = n(i, t) : this._binaryType === "arraybuffer" ? s = f(n(i, t)) : this._binaryType === "blob" ? s = new Blob(i) : s = i, this._allowSynchronousEvents ? (this.emit("message", s, !0), this._state = c) : (this._state = l, setImmediate(() => {
+          this.emit("message", s, !0), this._state = c, this.startLoop(e);
+        }));
+      } else {
+        const s = n(i, t);
+        if (!this._skipUTF8Validation && !h(s)) {
+          const m = this.createError(
+            Error,
+            "invalid UTF-8 sequence",
+            !0,
+            1007,
+            "WS_ERR_INVALID_UTF8"
+          );
+          e(m);
+          return;
+        }
+        this._state === p || this._allowSynchronousEvents ? (this.emit("message", s, !1), this._state = c) : (this._state = l, setImmediate(() => {
+          this.emit("message", s, !1), this._state = c, this.startLoop(e);
+        }));
+      }
+    }
+    /**
+     * Handles a control message.
+     *
+     * @param {Buffer} data Data to handle
+     * @return {(Error|RangeError|undefined)} A possible error
+     * @private
+     */
+    controlMessage(e, t) {
+      if (this._opcode === 8) {
+        if (e.length === 0)
+          this._loop = !1, this.emit("conclude", 1005, B), this.end();
+        else {
+          const i = e.readUInt16BE(0);
+          if (!_(i)) {
+            const m = this.createError(
+              RangeError,
+              `invalid status code ${i}`,
+              !0,
+              1002,
+              "WS_ERR_INVALID_CLOSE_CODE"
+            );
+            t(m);
+            return;
+          }
+          const s = new C(
+            e.buffer,
+            e.byteOffset + 2,
+            e.length - 2
+          );
+          if (!this._skipUTF8Validation && !h(s)) {
+            const m = this.createError(
+              Error,
+              "invalid UTF-8 sequence",
+              !0,
+              1007,
+              "WS_ERR_INVALID_UTF8"
+            );
+            t(m);
+            return;
+          }
+          this._loop = !1, this.emit("conclude", i, s), this.end();
+        }
+        this._state = c;
+        return;
+      }
+      this._allowSynchronousEvents ? (this.emit(this._opcode === 9 ? "ping" : "pong", e), this._state = c) : (this._state = l, setImmediate(() => {
+        this.emit(this._opcode === 9 ? "ping" : "pong", e), this._state = c, this.startLoop(t);
+      }));
+    }
+    /**
+     * 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(e, t, i, s, m) {
+      this._loop = !1, this._errored = !0;
+      const y = new e(
+        i ? `Invalid WebSocket frame: ${t}` : t
+      );
+      return Error.captureStackTrace(y, this.createError), y.code = m, y[b] = s, y;
+    }
+  }
+  return ge = E, ge;
+}
+var ye, qe;
+function st() {
+  if (qe) return ye;
+  qe = 1;
+  const { Duplex: P } = se, { randomFillSync: T } = Oe, M = ae(), { EMPTY_BUFFER: B, kWebSocket: b, NOOP: d } = j(), { isBlob: n, isValidStatusCode: f } = ie(), { mask: a, toBuffer: _ } = oe(), h = /* @__PURE__ */ Symbol("kByteLength"), C = Buffer.alloc(4), c = 8 * 1024;
+  let w, k = c;
+  const v = 0, O = 1, p = 2;
+  class l {
+    /**
+     * 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(t, i, s) {
+      this._extensions = i || {}, s && (this._generateMask = s, this._maskBuffer = Buffer.alloc(4)), this._socket = t, this._firstFragment = !0, this._compress = !1, this._bufferedBytes = 0, this._queue = [], this._state = v, this.onerror = d, this[b] = 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(t, i) {
+      let s, m = !1, y = 2, R = !1;
+      i.mask && (s = i.maskBuffer || C, i.generateMask ? i.generateMask(s) : (k === c && (w === void 0 && (w = Buffer.alloc(c)), T(w, 0, c), k = 0), s[0] = w[k++], s[1] = w[k++], s[2] = w[k++], s[3] = w[k++]), R = (s[0] | s[1] | s[2] | s[3]) === 0, y = 6);
+      let D;
+      typeof t == "string" ? (!i.mask || R) && i[h] !== void 0 ? D = i[h] : (t = Buffer.from(t), D = t.length) : (D = t.length, m = i.mask && i.readOnly && !R);
+      let A = D;
+      D >= 65536 ? (y += 8, A = 127) : D > 125 && (y += 2, A = 126);
+      const N = Buffer.allocUnsafe(m ? D + y : y);
+      return N[0] = i.fin ? i.opcode | 128 : i.opcode, i.rsv1 && (N[0] |= 64), N[1] = A, A === 126 ? N.writeUInt16BE(D, 2) : A === 127 && (N[2] = N[3] = 0, N.writeUIntBE(D, 4, 6)), i.mask ? (N[1] |= 128, N[y - 4] = s[0], N[y - 3] = s[1], N[y - 2] = s[2], N[y - 1] = s[3], R ? [N, t] : m ? (a(t, s, N, y, D), [N]) : (a(t, s, t, 0, D), [N, t])) : [N, t];
+    }
+    /**
+     * 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(t, i, s, m) {
+      let y;
+      if (t === void 0)
+        y = B;
+      else {
+        if (typeof t != "number" || !f(t))
+          throw new TypeError("First argument must be a valid error code number");
+        if (i === void 0 || !i.length)
+          y = Buffer.allocUnsafe(2), y.writeUInt16BE(t, 0);
+        else {
+          const D = Buffer.byteLength(i);
+          if (D > 123)
+            throw new RangeError("The message must not be greater than 123 bytes");
+          y = Buffer.allocUnsafe(2 + D), y.writeUInt16BE(t, 0), typeof i == "string" ? y.write(i, 2) : y.set(i, 2);
+        }
+      }
+      const R = {
+        [h]: y.length,
+        fin: !0,
+        generateMask: this._generateMask,
+        mask: s,
+        maskBuffer: this._maskBuffer,
+        opcode: 8,
+        readOnly: !1,
+        rsv1: !1
+      };
+      this._state !== v ? this.enqueue([this.dispatch, y, !1, R, m]) : this.sendFrame(l.frame(y, 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(t, i, s) {
+      let m, y;
+      if (typeof t == "string" ? (m = Buffer.byteLength(t), y = !1) : n(t) ? (m = t.size, y = !1) : (t = _(t), m = t.length, y = _.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: i,
+        maskBuffer: this._maskBuffer,
+        opcode: 9,
+        readOnly: y,
+        rsv1: !1
+      };
+      n(t) ? this._state !== v ? this.enqueue([this.getBlobData, t, !1, R, s]) : this.getBlobData(t, !1, R, s) : this._state !== v ? this.enqueue([this.dispatch, t, !1, R, s]) : this.sendFrame(l.frame(t, R), s);
+    }
+    /**
+     * 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(t, i, s) {
+      let m, y;
+      if (typeof t == "string" ? (m = Buffer.byteLength(t), y = !1) : n(t) ? (m = t.size, y = !1) : (t = _(t), m = t.length, y = _.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: i,
+        maskBuffer: this._maskBuffer,
+        opcode: 10,
+        readOnly: y,
+        rsv1: !1
+      };
+      n(t) ? this._state !== v ? this.enqueue([this.getBlobData, t, !1, R, s]) : this.getBlobData(t, !1, R, s) : this._state !== v ? this.enqueue([this.dispatch, t, !1, R, s]) : this.sendFrame(l.frame(t, R), s);
+    }
+    /**
+     * 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(t, i, s) {
+      const m = this._extensions[M.extensionName];
+      let y = i.binary ? 2 : 1, R = i.compress, D, A;
+      typeof t == "string" ? (D = Buffer.byteLength(t), A = !1) : n(t) ? (D = t.size, A = !1) : (t = _(t), D = t.length, A = _.readOnly), this._firstFragment ? (this._firstFragment = !1, R && m && m.params[m._isServer ? "server_no_context_takeover" : "client_no_context_takeover"] && (R = D >= m._threshold), this._compress = R) : (R = !1, y = 0), i.fin && (this._firstFragment = !0);
+      const N = {
+        [h]: D,
+        fin: i.fin,
+        generateMask: this._generateMask,
+        mask: i.mask,
+        maskBuffer: this._maskBuffer,
+        opcode: y,
+        readOnly: A,
+        rsv1: R
+      };
+      n(t) ? this._state !== v ? this.enqueue([this.getBlobData, t, this._compress, N, s]) : this.getBlobData(t, this._compress, N, s) : this._state !== v ? this.enqueue([this.dispatch, t, this._compress, N, s]) : this.dispatch(t, this._compress, N, s);
+    }
+    /**
+     * 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(t, i, s, m) {
+      this._bufferedBytes += s[h], this._state = p, t.arrayBuffer().then((y) => {
+        if (this._socket.destroyed) {
+          const D = new Error(
+            "The socket was closed while the blob was being read"
+          );
+          process.nextTick(E, this, D, m);
+          return;
+        }
+        this._bufferedBytes -= s[h];
+        const R = _(y);
+        i ? this.dispatch(R, i, s, m) : (this._state = v, this.sendFrame(l.frame(R, s), m), this.dequeue());
+      }).catch((y) => {
+        process.nextTick(u, this, y, 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(t, i, s, m) {
+      if (!i) {
+        this.sendFrame(l.frame(t, s), m);
+        return;
+      }
+      const y = this._extensions[M.extensionName];
+      this._bufferedBytes += s[h], this._state = O, y.compress(t, s.fin, (R, D) => {
+        if (this._socket.destroyed) {
+          const A = new Error(
+            "The socket was closed while data was being compressed"
+          );
+          E(this, A, m);
+          return;
+        }
+        this._bufferedBytes -= s[h], this._state = v, s.readOnly = !1, this.sendFrame(l.frame(D, s), m), this.dequeue();
+      });
+    }
+    /**
+     * Executes queued send operations.
+     *
+     * @private
+     */
+    dequeue() {
+      for (; this._state === v && this._queue.length; ) {
+        const t = this._queue.shift();
+        this._bufferedBytes -= t[3][h], Reflect.apply(t[0], this, t.slice(1));
+      }
+    }
+    /**
+     * Enqueues a send operation.
+     *
+     * @param {Array} params Send operation parameters.
+     * @private
+     */
+    enqueue(t) {
+      this._bufferedBytes += t[3][h], this._queue.push(t);
+    }
+    /**
+     * Sends a frame.
+     *
+     * @param {(Buffer | String)[]} list The frame to send
+     * @param {Function} [cb] Callback
+     * @private
+     */
+    sendFrame(t, i) {
+      t.length === 2 ? (this._socket.cork(), this._socket.write(t[0]), this._socket.write(t[1], i), this._socket.uncork()) : this._socket.write(t[0], i);
+    }
+  }
+  ye = l;
+  function E(e, t, i) {
+    typeof i == "function" && i(t);
+    for (let s = 0; s < e._queue.length; s++) {
+      const m = e._queue[s], y = m[m.length - 1];
+      typeof y == "function" && y(t);
+    }
+  }
+  function u(e, t, i) {
+    E(e, t, i), e.onerror(t);
+  }
+  return ye;
+}
+var Ee, ze;
+function Ct() {
+  if (ze) return Ee;
+  ze = 1;
+  const { kForOnEventAttribute: P, kListener: T } = j(), M = /* @__PURE__ */ Symbol("kCode"), B = /* @__PURE__ */ Symbol("kData"), b = /* @__PURE__ */ Symbol("kError"), d = /* @__PURE__ */ Symbol("kMessage"), n = /* @__PURE__ */ Symbol("kReason"), f = /* @__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[f] = null, this[a] = p;
+    }
+    /**
+     * @type {*}
+     */
+    get target() {
+      return this[f];
+    }
+    /**
+     * @type {String}
+     */
+    get type() {
+      return this[a];
+    }
+  }
+  Object.defineProperty(h.prototype, "target", { enumerable: !0 }), Object.defineProperty(h.prototype, "type", { enumerable: !0 });
+  class C 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, l = {}) {
+      super(p), this[M] = l.code === void 0 ? 0 : l.code, this[n] = l.reason === void 0 ? "" : l.reason, this[_] = l.wasClean === void 0 ? !1 : l.wasClean;
+    }
+    /**
+     * @type {Number}
+     */
+    get code() {
+      return this[M];
+    }
+    /**
+     * @type {String}
+     */
+    get reason() {
+      return this[n];
+    }
+    /**
+     * @type {Boolean}
+     */
+    get wasClean() {
+      return this[_];
+    }
+  }
+  Object.defineProperty(C.prototype, "code", { enumerable: !0 }), Object.defineProperty(C.prototype, "reason", { enumerable: !0 }), Object.defineProperty(C.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, l = {}) {
+      super(p), this[b] = l.error === void 0 ? null : l.error, this[d] = l.message === void 0 ? "" : l.message;
+    }
+    /**
+     * @type {*}
+     */
+    get error() {
+      return this[b];
+    }
+    /**
+     * @type {String}
+     */
+    get message() {
+      return this[d];
+    }
+  }
+  Object.defineProperty(c.prototype, "error", { enumerable: !0 }), Object.defineProperty(c.prototype, "message", { enumerable: !0 });
+  class w 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, l = {}) {
+      super(p), this[B] = l.data === void 0 ? null : l.data;
+    }
+    /**
+     * @type {*}
+     */
+    get data() {
+      return this[B];
+    }
+  }
+  Object.defineProperty(w.prototype, "data", { enumerable: !0 }), Ee = {
+    CloseEvent: C,
+    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, l = {}) {
+        for (const u of this.listeners(O))
+          if (!l[P] && u[T] === p && !u[P])
+            return;
+        let E;
+        if (O === "message")
+          E = function(e, t) {
+            const i = new w("message", {
+              data: t ? e : e.toString()
+            });
+            i[f] = this, v(p, this, i);
+          };
+        else if (O === "close")
+          E = function(e, t) {
+            const i = new C("close", {
+              code: e,
+              reason: t.toString(),
+              wasClean: this._closeFrameReceived && this._closeFrameSent
+            });
+            i[f] = this, v(p, this, i);
+          };
+        else if (O === "error")
+          E = function(e) {
+            const t = new c("error", {
+              error: e,
+              message: e.message
+            });
+            t[f] = this, v(p, this, t);
+          };
+        else if (O === "open")
+          E = function() {
+            const e = new h("open");
+            e[f] = this, v(p, this, e);
+          };
+        else
+          return;
+        E[P] = !!l[P], E[T] = p, l.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 l of this.listeners(O))
+          if (l[T] === p && !l[P]) {
+            this.removeListener(O, l);
+            break;
+          }
+      }
+    },
+    MessageEvent: w
+  };
+  function v(O, p, l) {
+    typeof O == "object" && O.handleEvent ? O.handleEvent.call(O, l) : O.call(p, l);
+  }
+  return Ee;
+}
+var xe, He;
+function it() {
+  if (He) return xe;
+  He = 1;
+  const { tokenChars: P } = ie();
+  function T(b, d, n) {
+    b[d] === void 0 ? b[d] = [n] : b[d].push(n);
+  }
+  function M(b) {
+    const d = /* @__PURE__ */ Object.create(null);
+    let n = /* @__PURE__ */ Object.create(null), f = !1, a = !1, _ = !1, h, C, c = -1, w = -1, k = -1, v = 0;
+    for (; v < b.length; v++)
+      if (w = b.charCodeAt(v), h === void 0)
+        if (k === -1 && P[w] === 1)
+          c === -1 && (c = v);
+        else if (v !== 0 && (w === 32 || w === 9))
+          k === -1 && c !== -1 && (k = v);
+        else if (w === 59 || w === 44) {
+          if (c === -1)
+            throw new SyntaxError(`Unexpected character at index ${v}`);
+          k === -1 && (k = v);
+          const p = b.slice(c, k);
+          w === 44 ? (T(d, p, n), n = /* @__PURE__ */ Object.create(null)) : h = p, c = k = -1;
+        } else
+          throw new SyntaxError(`Unexpected character at index ${v}`);
+      else if (C === void 0)
+        if (k === -1 && P[w] === 1)
+          c === -1 && (c = v);
+        else if (w === 32 || w === 9)
+          k === -1 && c !== -1 && (k = v);
+        else if (w === 59 || w === 44) {
+          if (c === -1)
+            throw new SyntaxError(`Unexpected character at index ${v}`);
+          k === -1 && (k = v), T(n, b.slice(c, k), !0), w === 44 && (T(d, h, n), n = /* @__PURE__ */ Object.create(null), h = void 0), c = k = -1;
+        } else if (w === 61 && c !== -1 && k === -1)
+          C = b.slice(c, v), c = k = -1;
+        else
+          throw new SyntaxError(`Unexpected character at index ${v}`);
+      else if (a) {
+        if (P[w] !== 1)
+          throw new SyntaxError(`Unexpected character at index ${v}`);
+        c === -1 ? c = v : f || (f = !0), a = !1;
+      } else if (_)
+        if (P[w] === 1)
+          c === -1 && (c = v);
+        else if (w === 34 && c !== -1)
+          _ = !1, k = v;
+        else if (w === 92)
+          a = !0;
+        else
+          throw new SyntaxError(`Unexpected character at index ${v}`);
+      else if (w === 34 && b.charCodeAt(v - 1) === 61)
+        _ = !0;
+      else if (k === -1 && P[w] === 1)
+        c === -1 && (c = v);
+      else if (c !== -1 && (w === 32 || w === 9))
+        k === -1 && (k = v);
+      else if (w === 59 || w === 44) {
+        if (c === -1)
+          throw new SyntaxError(`Unexpected character at index ${v}`);
+        k === -1 && (k = v);
+        let p = b.slice(c, k);
+        f && (p = p.replace(/\\/g, ""), f = !1), T(n, C, p), w === 44 && (T(d, h, n), n = /* @__PURE__ */ Object.create(null), h = void 0), C = void 0, c = k = -1;
+      } else
+        throw new SyntaxError(`Unexpected character at index ${v}`);
+    if (c === -1 || _ || w === 32 || w === 9)
+      throw new SyntaxError("Unexpected end of input");
+    k === -1 && (k = v);
+    const O = b.slice(c, k);
+    return h === void 0 ? T(d, O, n) : (C === void 0 ? T(n, O, !0) : f ? T(n, C, O.replace(/\\/g, "")) : T(n, C, O), T(d, h, n)), d;
+  }
+  function B(b) {
+    return Object.keys(b).map((d) => {
+      let n = b[d];
+      return Array.isArray(n) || (n = [n]), n.map((f) => [d].concat(
+        Object.keys(f).map((a) => {
+          let _ = f[a];
+          return Array.isArray(_) || (_ = [_]), _.map((h) => h === !0 ? a : `${a}=${h}`).join("; ");
+        })
+      ).join("; ")).join(", ");
+    }).join(", ");
+  }
+  return xe = { format: B, parse: M }, xe;
+}
+var Se, Ye;
+function Te() {
+  if (Ye) return Se;
+  Ye = 1;
+  const P = Qe, T = dt, M = Je, B = _t, b = pt, { randomBytes: d, createHash: n } = Oe, { Duplex: f, Readable: a } = se, { URL: _ } = mt, h = ae(), C = rt(), c = st(), { isBlob: w } = ie(), {
+    BINARY_TYPES: k,
+    EMPTY_BUFFER: v,
+    GUID: O,
+    kForOnEventAttribute: p,
+    kListener: l,
+    kStatusCode: E,
+    kWebSocket: u,
+    NOOP: e
+  } = j(), {
+    EventTarget: { addEventListener: t, removeEventListener: i }
+  } = Ct(), { format: s, parse: m } = it(), { toBuffer: y } = oe(), R = 30 * 1e3, D = /* @__PURE__ */ Symbol("kAborted"), A = [8, 13], N = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"], V = /^[!#$%&'*+\-.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, x, L) {
+      super(), this._binaryType = k[0], this._closeCode = 1006, this._closeFrameReceived = !1, this._closeFrameSent = !1, this._closeMessage = v, 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, x === void 0 ? x = [] : Array.isArray(x) || (typeof x == "object" && x !== null ? (L = x, x = []) : x = [x]), G(this, o, x, L)) : (this._autoPong = L.autoPong, 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) {
+      k.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, x, L) {
+      const g = new C({
+        allowSynchronousEvents: L.allowSynchronousEvents,
+        binaryType: this.binaryType,
+        extensions: this._extensions,
+        isServer: this._isServer,
+        maxPayload: L.maxPayload,
+        skipUTF8Validation: L.skipUTF8Validation
+      }), U = new c(o, this._extensions, L.generateMask);
+      this._receiver = g, this._sender = U, this._socket = o, g[u] = this, U[u] = this, o[u] = 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(), x.length > 0 && o.unshift(x), o.on("close", Ne), o.on("data", ne), 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, x) {
+      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, x, !this._isServer, (L) => {
+          L || (this._closeFrameSent = !0, (this._closeFrameReceived || this._receiver._writableState.errorEmitted) && this._socket.end());
+        }), Le(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, x, L) {
+      if (this.readyState === S.CONNECTING)
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      if (typeof o == "function" ? (L = o, o = x = void 0) : typeof x == "function" && (L = x, x = void 0), typeof o == "number" && (o = o.toString()), this.readyState !== S.OPEN) {
+        ce(this, o, L);
+        return;
+      }
+      x === void 0 && (x = !this._isServer), this._sender.ping(o || v, x, L);
+    }
+    /**
+     * 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, x, L) {
+      if (this.readyState === S.CONNECTING)
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      if (typeof o == "function" ? (L = o, o = x = void 0) : typeof x == "function" && (L = x, x = void 0), typeof o == "number" && (o = o.toString()), this.readyState !== S.OPEN) {
+        ce(this, o, L);
+        return;
+      }
+      x === void 0 && (x = !this._isServer), this._sender.pong(o || v, x, L);
+    }
+    /**
+     * 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, x, L) {
+      if (this.readyState === S.CONNECTING)
+        throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
+      if (typeof x == "function" && (L = x, x = {}), typeof o == "number" && (o = o.toString()), this.readyState !== S.OPEN) {
+        ce(this, o, L);
+        return;
+      }
+      const g = {
+        binary: typeof o != "string",
+        mask: !this._isServer,
+        compress: !0,
+        fin: !0,
+        ...x
+      };
+      this._extensions[h.extensionName] || (g.compress = !1), this._sender.send(o || v, g, L);
+    }
+    /**
+     * 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[p]) return o[l];
+        return null;
+      },
+      set(o) {
+        for (const x of this.listeners(r))
+          if (x[p]) {
+            this.removeListener(r, x);
+            break;
+          }
+        typeof o == "function" && this.addEventListener(r, o, {
+          [p]: !0
+        });
+      }
+    });
+  }), S.prototype.addEventListener = t, S.prototype.removeEventListener = i, Se = S;
+  function G(r, o, x, L) {
+    const g = {
+      allowSynchronousEvents: !0,
+      autoPong: !0,
+      protocolVersion: A[1],
+      maxPayload: 104857600,
+      skipUTF8Validation: !1,
+      perMessageDeflate: !0,
+      followRedirects: !1,
+      maxRedirects: 10,
+      ...L,
+      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, !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;
+      q(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 : fe), 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"] = s({
+      [h.extensionName]: Q.offer()
+    })), x.length) {
+      for (const I of x) {
+        if (typeof I != "string" || !V.test(I) || Z.has(I))
+          throw new SyntaxError(
+            "An invalid or duplicated subprotocol was specified"
+          );
+        Z.add(I);
+      }
+      g.headers["Sec-WebSocket-Protocol"] = x.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 = L && L.headers;
+        if (L = { ...L, headers: {} }, I)
+          for (const [F, Y] of Object.entries(I))
+            L.headers[F.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 && !L.headers.authorization && (L.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 || $[D] || ($ = r._req = null, q(r, I));
+    }), $.on("response", (I) => {
+      const F = I.headers.location, Y = I.statusCode;
+      if (F && g.followRedirects && Y >= 300 && Y < 400) {
+        if (++r._redirects > g.maxRedirects) {
+          W(r, $, "Maximum redirects exceeded");
+          return;
+        }
+        $.abort();
+        let J;
+        try {
+          J = new _(F, o);
+        } catch {
+          const K = new SyntaxError(`Invalid URL: ${F}`);
+          q(r, K);
+          return;
+        }
+        G(r, J, x, L);
+      } else r.emit("unexpected-response", $, I) || W(
+        r,
+        $,
+        `Unexpected server response: ${I.statusCode}`
+      );
+    }), $.on("upgrade", (I, F, 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, F, "Invalid Upgrade header");
+        return;
+      }
+      const Ue = n("sha1").update(De + O).digest("base64");
+      if (I.headers["sec-websocket-accept"] !== Ue) {
+        W(r, F, "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, F, ee);
+        return;
+      }
+      K && (r._protocol = K);
+      const Me = I.headers["sec-websocket-extensions"];
+      if (Me !== void 0) {
+        if (!Q) {
+          W(r, F, "Server sent a Sec-WebSocket-Extensions header but no extension was requested");
+          return;
+        }
+        let ue;
+        try {
+          ue = m(Me);
+        } catch {
+          W(r, F, "Invalid Sec-WebSocket-Extensions header");
+          return;
+        }
+        const Ae = Object.keys(ue);
+        if (Ae.length !== 1 || Ae[0] !== h.extensionName) {
+          W(r, F, "Server indicated an extension that was not requested");
+          return;
+        }
+        try {
+          Q.accept(ue[h.extensionName]);
+        } catch {
+          W(r, F, "Invalid Sec-WebSocket-Extensions header");
+          return;
+        }
+        r._extensions[h.extensionName] = Q;
+      }
+      r.setSocket(F, Y, {
+        allowSynchronousEvents: g.allowSynchronousEvents,
+        generateMask: g.generateMask,
+        maxPayload: g.maxPayload,
+        skipUTF8Validation: g.skipUTF8Validation
+      });
+    }), g.finishRequest ? g.finishRequest($, r) : $.end();
+  }
+  function q(r, o) {
+    r._readyState = S.CLOSING, r._errorEmitted = !0, r.emit("error", o), r.emitClose();
+  }
+  function fe(r) {
+    return r.path = r.socketPath, B.connect(r);
+  }
+  function he(r) {
+    return r.path = void 0, !r.servername && r.servername !== "" && (r.servername = B.isIP(r.host) ? "" : r.host), b.connect(r);
+  }
+  function W(r, o, x) {
+    r._readyState = S.CLOSING;
+    const L = new Error(x);
+    Error.captureStackTrace(L, W), o.setHeader ? (o[D] = !0, o.abort(), o.socket && !o.socket.destroyed && o.socket.destroy(), process.nextTick(q, r, L)) : (o.destroy(L), o.once("error", r.emit.bind(r, "error")), o.once("close", r.emitClose.bind(r)));
+  }
+  function ce(r, o, x) {
+    if (o) {
+      const L = w(o) ? o.size : y(o).length;
+      r._socket ? r._sender._bufferedBytes += L : r._bufferedAmount += L;
+    }
+    if (x) {
+      const L = new Error(
+        `WebSocket is not open: readyState ${r.readyState} (${N[r.readyState]})`
+      );
+      process.nextTick(x, L);
+    }
+  }
+  function nt(r, o) {
+    const x = this[u];
+    x._closeFrameReceived = !0, x._closeMessage = o, x._closeCode = r, x._socket[u] !== void 0 && (x._socket.removeListener("data", ne), process.nextTick(ke, x._socket), r === 1005 ? x.close() : x.close(r, o));
+  }
+  function ot() {
+    const r = this[u];
+    r.isPaused || r._socket.resume();
+  }
+  function at(r) {
+    const o = this[u];
+    o._socket[u] !== void 0 && (o._socket.removeListener("data", ne), process.nextTick(ke, o._socket), o.close(r[E])), o._errorEmitted || (o._errorEmitted = !0, o.emit("error", r));
+  }
+  function Ce() {
+    this[u].emitClose();
+  }
+  function lt(r, o) {
+    this[u].emit("message", r, o);
+  }
+  function ft(r) {
+    const o = this[u];
+    o._autoPong && o.pong(r, !this._isServer, e), o.emit("ping", r);
+  }
+  function ht(r) {
+    this[u].emit("pong", r);
+  }
+  function ke(r) {
+    r.resume();
+  }
+  function ct(r) {
+    const o = this[u];
+    o.readyState !== S.CLOSED && (o.readyState === S.OPEN && (o._readyState = S.CLOSING, Le(o)), this._socket.end(), o._errorEmitted || (o._errorEmitted = !0, o.emit("error", r)));
+  }
+  function Le(r) {
+    r._closeTimer = setTimeout(
+      r._socket.destroy.bind(r._socket),
+      R
+    );
+  }
+  function Ne() {
+    const r = this[u];
+    this.removeListener("close", Ne), this.removeListener("data", ne), this.removeListener("end", Pe), r._readyState = S.CLOSING;
+    let o;
+    !this._readableState.endEmitted && !r._closeFrameReceived && !r._receiver._writableState.errorEmitted && (o = r._socket.read()) !== null && r._receiver.write(o), r._receiver.end(), this[u] = 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 ne(r) {
+    this[u]._receiver.write(r) || this.pause();
+  }
+  function Pe() {
+    const r = this[u];
+    r._readyState = S.CLOSING, r._receiver.end(), this.end();
+  }
+  function Re() {
+    const r = this[u];
+    this.removeListener("error", Re), this.on("error", e), r && (r._readyState = S.CLOSING, this.destroy());
+  }
+  return Se;
+}
+var ve, Ke;
+function kt() {
+  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 B(d) {
+    this.removeListener("error", B), this.destroy(), this.listenerCount("error") === 0 && this.emit("error", d);
+  }
+  function b(d, n) {
+    let f = !0;
+    const a = new P({
+      ...n,
+      autoDestroy: !1,
+      emitClose: !1,
+      objectMode: !1,
+      writableObjectMode: !1
+    });
+    return d.on("message", function(h, C) {
+      const c = !C && a._readableState.objectMode ? h.toString() : h;
+      a.push(c) || d.pause();
+    }), d.once("error", function(h) {
+      a.destroyed || (f = !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 C = !1;
+      d.once("error", function(w) {
+        C = !0, h(w);
+      }), d.once("close", function() {
+        C || h(_), process.nextTick(T, a);
+      }), f && 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, C) {
+      if (d.readyState === d.CONNECTING) {
+        d.once("open", function() {
+          a._write(_, h, C);
+        });
+        return;
+      }
+      d.send(_, C);
+    }, a.on("end", M), a.on("error", B), a;
+  }
+  return ve = b, ve;
+}
+kt();
+rt();
+st();
+var Lt = Te();
+const Nt = /* @__PURE__ */ yt(Lt);
+var be, Xe;
+function Pt() {
+  if (Xe) return be;
+  Xe = 1;
+  const { tokenChars: P } = ie();
+  function T(M) {
+    const B = /* @__PURE__ */ new Set();
+    let b = -1, d = -1, n = 0;
+    for (n; n < M.length; n++) {
+      const a = M.charCodeAt(n);
+      if (d === -1 && P[a] === 1)
+        b === -1 && (b = n);
+      else if (n !== 0 && (a === 32 || a === 9))
+        d === -1 && b !== -1 && (d = n);
+      else if (a === 44) {
+        if (b === -1)
+          throw new SyntaxError(`Unexpected character at index ${n}`);
+        d === -1 && (d = n);
+        const _ = M.slice(b, d);
+        if (B.has(_))
+          throw new SyntaxError(`The "${_}" subprotocol is duplicated`);
+        B.add(_), b = d = -1;
+      } else
+        throw new SyntaxError(`Unexpected character at index ${n}`);
+    }
+    if (b === -1 || d !== -1)
+      throw new SyntaxError("Unexpected end of input");
+    const f = M.slice(b, n);
+    if (B.has(f))
+      throw new SyntaxError(`The "${f}" subprotocol is duplicated`);
+    return B.add(f), B;
+  }
+  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: B } = Oe, b = it(), d = ae(), n = Pt(), f = Te(), { GUID: a, kWebSocket: _ } = j(), h = /^[+/0-9A-Za-z]{22}==$/, C = 0, c = 1, w = 2;
+  class k 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 {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, t) {
+      if (super(), e = {
+        allowSynchronousEvents: !0,
+        autoPong: !0,
+        maxPayload: 100 * 1024 * 1024,
+        skipUTF8Validation: !1,
+        perMessageDeflate: !1,
+        handleProtocols: null,
+        clientTracking: !0,
+        verifyClient: null,
+        noServer: !1,
+        backlog: null,
+        // use default (511 as implemented in net.js)
+        server: null,
+        host: null,
+        path: null,
+        port: null,
+        WebSocket: f,
+        ...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, s) => {
+        const m = T.STATUS_CODES[426];
+        s.writeHead(426, {
+          "Content-Length": m.length,
+          "Content-Type": "text/plain"
+        }), s.end(m);
+      }), this._server.listen(
+        e.port,
+        e.host,
+        e.backlog,
+        t
+      )) : e.server && (this._server = e.server), this._server) {
+        const i = this.emit.bind(this, "connection");
+        this._removeListeners = v(this._server, {
+          listening: this.emit.bind(this, "listening"),
+          error: this.emit.bind(this, "error"),
+          upgrade: (s, m, y) => {
+            this.handleUpgrade(s, m, y, 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 === w) {
+        e && this.once("close", () => {
+          e(new Error("The server is not running"));
+        }), process.nextTick(O, this);
+        return;
+      }
+      if (e && this.once("close", e), this._state !== c)
+        if (this._state = c, 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(O, this) : process.nextTick(O, this);
+        else {
+          const t = this._server;
+          this._removeListeners(), this._removeListeners = this._server = null, t.close(() => {
+            O(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 t = e.url.indexOf("?");
+        if ((t !== -1 ? e.url.slice(0, t) : 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, t, i, s) {
+      t.on("error", p);
+      const m = e.headers["sec-websocket-key"], y = e.headers.upgrade, R = +e.headers["sec-websocket-version"];
+      if (e.method !== "GET") {
+        E(this, e, t, 405, "Invalid HTTP method");
+        return;
+      }
+      if (y === void 0 || y.toLowerCase() !== "websocket") {
+        E(this, e, t, 400, "Invalid Upgrade header");
+        return;
+      }
+      if (m === void 0 || !h.test(m)) {
+        E(this, e, t, 400, "Missing or invalid Sec-WebSocket-Key header");
+        return;
+      }
+      if (R !== 13 && R !== 8) {
+        E(this, e, t, 400, "Missing or invalid Sec-WebSocket-Version header", {
+          "Sec-WebSocket-Version": "13, 8"
+        });
+        return;
+      }
+      if (!this.shouldHandle(e)) {
+        l(t, 400);
+        return;
+      }
+      const D = e.headers["sec-websocket-protocol"];
+      let A = /* @__PURE__ */ new Set();
+      if (D !== void 0)
+        try {
+          A = n.parse(D);
+        } catch {
+          E(this, e, t, 400, "Invalid Sec-WebSocket-Protocol header");
+          return;
+        }
+      const N = e.headers["sec-websocket-extensions"], V = {};
+      if (this.options.perMessageDeflate && N !== void 0) {
+        const S = new d(
+          this.options.perMessageDeflate,
+          !0,
+          this.options.maxPayload
+        );
+        try {
+          const G = b.parse(N);
+          G[d.extensionName] && (S.accept(G[d.extensionName]), V[d.extensionName] = S);
+        } catch {
+          E(this, e, t, 400, "Invalid or unacceptable Sec-WebSocket-Extensions header");
+          return;
+        }
+      }
+      if (this.options.verifyClient) {
+        const S = {
+          origin: e.headers[`${R === 8 ? "sec-websocket-origin" : "origin"}`],
+          secure: !!(e.socket.authorized || e.socket.encrypted),
+          req: e
+        };
+        if (this.options.verifyClient.length === 2) {
+          this.options.verifyClient(S, (G, q, fe, he) => {
+            if (!G)
+              return l(t, q || 401, fe, he);
+            this.completeUpgrade(
+              V,
+              m,
+              A,
+              e,
+              t,
+              i,
+              s
+            );
+          });
+          return;
+        }
+        if (!this.options.verifyClient(S)) return l(t, 401);
+      }
+      this.completeUpgrade(V, m, A, e, t, i, s);
+    }
+    /**
+     * 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, t, i, s, m, y, R) {
+      if (!m.readable || !m.writable) return m.destroy();
+      if (m[_])
+        throw new Error(
+          "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration"
+        );
+      if (this._state > C) return l(m, 503);
+      const A = [
+        "HTTP/1.1 101 Switching Protocols",
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        `Sec-WebSocket-Accept: ${B("sha1").update(t + a).digest("base64")}`
+      ], N = new this.options.WebSocket(null, void 0, this.options);
+      if (i.size) {
+        const V = this.options.handleProtocols ? this.options.handleProtocols(i, s) : i.values().next().value;
+        V && (A.push(`Sec-WebSocket-Protocol: ${V}`), N._protocol = V);
+      }
+      if (e[d.extensionName]) {
+        const V = e[d.extensionName].params, S = b.format({
+          [d.extensionName]: [V]
+        });
+        A.push(`Sec-WebSocket-Extensions: ${S}`), N._extensions = e;
+      }
+      this.emit("headers", A, s), m.write(A.concat(`\r
+`).join(`\r
+`)), m.removeListener("error", p), N.setSocket(m, y, {
+        allowSynchronousEvents: this.options.allowSynchronousEvents,
+        maxPayload: this.options.maxPayload,
+        skipUTF8Validation: this.options.skipUTF8Validation
+      }), this.clients && (this.clients.add(N), N.on("close", () => {
+        this.clients.delete(N), this._shouldEmitClose && !this.clients.size && process.nextTick(O, this);
+      })), R(N, s);
+    }
+  }
+  we = k;
+  function v(u, e) {
+    for (const t of Object.keys(e)) u.on(t, e[t]);
+    return function() {
+      for (const i of Object.keys(e))
+        u.removeListener(i, e[i]);
+    };
+  }
+  function O(u) {
+    u._state = w, u.emit("close");
+  }
+  function p() {
+    this.destroy();
+  }
+  function l(u, e, t, i) {
+    t = t || T.STATUS_CODES[e], i = {
+      Connection: "close",
+      "Content-Type": "text/html",
+      "Content-Length": Buffer.byteLength(t),
+      ...i
+    }, u.once("finish", u.destroy), u.end(
+      `HTTP/1.1 ${e} ${T.STATUS_CODES[e]}\r
+` + Object.keys(i).map((s) => `${s}: ${i[s]}`).join(`\r
+`) + `\r
+\r
+` + t
+    );
+  }
+  function E(u, e, t, i, s, m) {
+    if (u.listenerCount("wsClientError")) {
+      const y = new Error(s);
+      Error.captureStackTrace(y, E), u.emit("wsClientError", y, t, e);
+    } else
+      l(t, i, s, m);
+  }
+  return we;
+}
+Rt();
+const le = global;
+le.WebSocket ||= Nt;
+le.window ||= global;
+le.self ||= global;
+le.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();