pptx-svelte-viewer 0.1.2 → 0.2.0

package/dist/y-webrtc-BdH40MC6.js

@@ -0,0 +1,3388 @@
+import { a as at, c as ct, d as ut, i as Ye, l as lt, n as ht, o as $e, r as Oe, s as ft, t as dt, u as pt } from "./awareness-CkFlr7xx.js";
+import { A as Re, B as gt, C as re, D as Je, E as yt, F as Pe, I as bt, L as mt, M as _t, N as vt, O as Fe, P as Xe, R as wt, S as De, T as ie, U as je, V as Et, _ as qe, a as Qe, b as Ze, i as ue, j as ze, k as se, l as Ct, n as We, o as Te, r as Rt, s as et, t as St, u as Tt, v as At, x as kt, y as Ot } from "./yjs-CE9F053g.js";
+var Lt = Object.create, Le = Object.defineProperty, xt = Object.getOwnPropertyDescriptor, Nt = Object.getOwnPropertyNames, It = Object.getPrototypeOf, Mt = Object.prototype.hasOwnProperty, Pt = (m, x) => () => (x || (m((x = { exports: {} }).exports, x), m = null), x.exports), er = (m, x) => {
+  let j = {};
+  for (var U in m)
+    Le(j, U, {
+      get: m[U],
+      enumerable: !0
+    });
+  return x || Le(j, Symbol.toStringTag, { value: "Module" }), j;
+}, Dt = (m, x, j, U) => {
+  if (x && typeof x == "object" || typeof x == "function")
+    for (var F = Nt(x), R = 0, M = F.length, _; R < M; R++)
+      _ = F[R], !Mt.call(m, _) && _ !== j && Le(m, _, {
+        get: ((c) => x[c]).bind(null, _),
+        enumerable: !(U = xt(x, _)) || U.enumerable
+      });
+  return m;
+}, jt = (m, x, j) => (j = m != null ? Lt(It(m)) : {}, Dt(x || !m || !m.__esModule ? Le(j, "default", {
+  value: m,
+  enumerable: !0
+}) : j, m)), ke = /* @__PURE__ */ ((m) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(m, { get: (x, j) => (typeof require < "u" ? require : x)[j] }) : m)(function(m) {
+  if (typeof require < "u") return require.apply(this, arguments);
+  throw Error('Calling `require` for "' + m + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+}), Bt = 1200, Ut = 2500, xe = 3e4, Be = (m) => {
+  if (m.shouldConnect && m.ws === null) {
+    const x = new WebSocket(m.url), j = m.binaryType;
+    let U = null;
+    j && (x.binaryType = j), m.ws = x, m.connecting = !0, m.connected = !1, x.onmessage = (M) => {
+      m.lastMessageReceived = Pe();
+      const _ = M.data, c = typeof _ == "string" ? JSON.parse(_) : _;
+      c && c.type === "pong" && (clearTimeout(U), U = setTimeout(R, xe / 2)), m.emit("message", [c, m]);
+    };
+    const F = (M) => {
+      m.ws !== null && (m.ws = null, m.connecting = !1, m.connected ? (m.connected = !1, m.emit("disconnect", [{
+        type: "disconnect",
+        error: M
+      }, m])) : m.unsuccessfulReconnects++, setTimeout(Be, wt(mt(m.unsuccessfulReconnects + 1) * Bt, Ut), m)), clearTimeout(U);
+    }, R = () => {
+      m.ws === x && m.send({ type: "ping" });
+    };
+    x.onclose = () => F(null), x.onerror = (M) => F(M), x.onopen = () => {
+      m.lastMessageReceived = Pe(), m.connecting = !1, m.connected = !0, m.unsuccessfulReconnects = 0, m.emit("connect", [{ type: "connect" }, m]), U = setTimeout(R, xe / 2);
+    };
+  }
+}, Ft = class extends gt {
+  constructor(m, { binaryType: x } = {}) {
+    super(), this.url = m, this.ws = null, this.binaryType = x || null, this.connected = !1, this.connecting = !1, this.unsuccessfulReconnects = 0, this.lastMessageReceived = 0, this.shouldConnect = !0, this._checkInterval = setInterval(() => {
+      this.connected && xe < Pe() - this.lastMessageReceived && this.ws.close();
+    }, xe / 2), Be(this);
+  }
+  send(m) {
+    this.ws && this.ws.send(JSON.stringify(m));
+  }
+  destroy() {
+    clearInterval(this._checkInterval), this.disconnect(), super.destroy();
+  }
+  disconnect() {
+    this.shouldConnect = !1, this.ws !== null && this.ws.close();
+  }
+  connect() {
+    this.shouldConnect = !0, !this.connected && this.ws === null && Be(this);
+  }
+}, qt = () => {
+  let m = !0;
+  return (x, j) => {
+    if (m) {
+      m = !1;
+      try {
+        x();
+      } finally {
+        m = !0;
+      }
+    } else j !== void 0 && j();
+  };
+}, Wt = /* @__PURE__ */ Pt(((m, x) => {
+  (function(j) {
+    if (typeof m == "object" && typeof x < "u") x.exports = j();
+    else if (typeof define == "function" && define.amd) define([], j);
+    else {
+      var U = typeof window > "u" ? typeof global > "u" ? typeof self > "u" ? this : self : global : window;
+      U.SimplePeer = j();
+    }
+  })(function() {
+    var j = Math.floor, U = Math.abs, F = Math.pow;
+    return (/* @__PURE__ */ (function() {
+      function R(M, _, c) {
+        function S(l, d) {
+          if (!_[l]) {
+            if (!M[l]) {
+              var a = typeof ke == "function" && ke;
+              if (!d && a) return a(l, !0);
+              if (O) return O(l, !0);
+              var g = /* @__PURE__ */ new Error("Cannot find module '" + l + "'");
+              throw g.code = "MODULE_NOT_FOUND", g;
+            }
+            var L = _[l] = { exports: {} };
+            M[l][0].call(L.exports, function(w) {
+              var b = M[l][1][w];
+              return S(b || w);
+            }, L, L.exports, R, M, _, c);
+          }
+          return _[l].exports;
+        }
+        for (var O = typeof ke == "function" && ke, i = 0; i < c.length; i++) S(c[i]);
+        return S;
+      }
+      return R;
+    })())({
+      1: [function(R, M, _) {
+        "use strict";
+        function c(h) {
+          var y = h.length;
+          if (0 < y % 4) throw new Error("Invalid string. Length must be a multiple of 4");
+          var k = h.indexOf("=");
+          k === -1 && (k = y);
+          var f = k === y ? 0 : 4 - k % 4;
+          return [k, f];
+        }
+        function S(h, y, k) {
+          return 3 * (y + k) / 4 - k;
+        }
+        function O(h) {
+          var y, k, f = c(h), T = f[0], P = f[1], p = new L(S(h, T, P)), v = 0, I = 0 < P ? T - 4 : T;
+          for (k = 0; k < I; k += 4) y = g[h.charCodeAt(k)] << 18 | g[h.charCodeAt(k + 1)] << 12 | g[h.charCodeAt(k + 2)] << 6 | g[h.charCodeAt(k + 3)], p[v++] = 255 & y >> 16, p[v++] = 255 & y >> 8, p[v++] = 255 & y;
+          return P === 2 && (y = g[h.charCodeAt(k)] << 2 | g[h.charCodeAt(k + 1)] >> 4, p[v++] = 255 & y), P === 1 && (y = g[h.charCodeAt(k)] << 10 | g[h.charCodeAt(k + 1)] << 4 | g[h.charCodeAt(k + 2)] >> 2, p[v++] = 255 & y >> 8, p[v++] = 255 & y), p;
+        }
+        function i(h) {
+          return a[63 & h >> 18] + a[63 & h >> 12] + a[63 & h >> 6] + a[63 & h];
+        }
+        function l(h, y, k) {
+          for (var f, T = [], P = y; P < k; P += 3) f = (16711680 & h[P] << 16) + (65280 & h[P + 1] << 8) + (255 & h[P + 2]), T.push(i(f));
+          return T.join("");
+        }
+        function d(h) {
+          for (var y, k = h.length, f = k % 3, T = [], P = 16383, p = 0, v = k - f; p < v; p += P) T.push(l(h, p, p + P > v ? v : p + P));
+          return f === 1 ? (y = h[k - 1], T.push(a[y >> 2] + a[63 & y << 4] + "==")) : f === 2 && (y = (h[k - 2] << 8) + h[k - 1], T.push(a[y >> 10] + a[63 & y >> 4] + a[63 & y << 2] + "=")), T.join("");
+        }
+        _.byteLength = function(h) {
+          var y = c(h), k = y[0], f = y[1];
+          return 3 * (k + f) / 4 - f;
+        }, _.toByteArray = O, _.fromByteArray = d;
+        for (var a = [], g = [], L = typeof Uint8Array > "u" ? Array : Uint8Array, w = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", b = 0, n = w.length; b < n; ++b) a[b] = w[b], g[w.charCodeAt(b)] = b;
+        g[45] = 62, g[95] = 63;
+      }, {}],
+      2: [function() {
+      }, {}],
+      3: [function(R, M, _) {
+        (function() {
+          (function() {
+            "use strict";
+            var c = String.fromCharCode, S = Math.min;
+            function O(e) {
+              if (2147483647 < e) throw new RangeError('The value "' + e + '" is invalid for option "size"');
+              var t = new Uint8Array(e);
+              return t.__proto__ = i.prototype, t;
+            }
+            function i(e, t, r) {
+              if (typeof e == "number") {
+                if (typeof t == "string") throw new TypeError('The "string" argument must be of type string. Received type number');
+                return g(e);
+              }
+              return l(e, t, r);
+            }
+            function l(e, t, r) {
+              if (typeof e == "string") return L(e, t);
+              if (ArrayBuffer.isView(e)) return w(e);
+              if (e == null) throw TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof e);
+              if (A(e, ArrayBuffer) || e && A(e.buffer, ArrayBuffer)) return b(e, t, r);
+              if (typeof e == "number") throw new TypeError('The "value" argument must not be of type number. Received type number');
+              var u = e.valueOf && e.valueOf();
+              if (u != null && u !== e) return i.from(u, t, r);
+              var E = n(e);
+              if (E) return E;
+              if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof e[Symbol.toPrimitive] == "function") return i.from(e[Symbol.toPrimitive]("string"), t, r);
+              throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof e);
+            }
+            function d(e) {
+              if (typeof e != "number") throw new TypeError('"size" argument must be of type number');
+              if (0 > e) throw new RangeError('The value "' + e + '" is invalid for option "size"');
+            }
+            function a(e, t, r) {
+              return d(e), 0 >= e || t === void 0 ? O(e) : typeof r == "string" ? O(e).fill(t, r) : O(e).fill(t);
+            }
+            function g(e) {
+              return d(e), O(0 > e ? 0 : 0 | h(e));
+            }
+            function L(e, t) {
+              if ((typeof t != "string" || t === "") && (t = "utf8"), !i.isEncoding(t)) throw new TypeError("Unknown encoding: " + t);
+              var r = 0 | y(e, t), u = O(r), E = u.write(e, t);
+              return E !== r && (u = u.slice(0, E)), u;
+            }
+            function w(e) {
+              for (var t = 0 > e.length ? 0 : 0 | h(e.length), r = O(t), u = 0; u < t; u += 1) r[u] = 255 & e[u];
+              return r;
+            }
+            function b(e, t, r) {
+              if (0 > t || e.byteLength < t) throw new RangeError('"offset" is outside of buffer bounds');
+              if (e.byteLength < t + (r || 0)) throw new RangeError('"length" is outside of buffer bounds');
+              var u;
+              return u = t === void 0 && r === void 0 ? new Uint8Array(e) : r === void 0 ? new Uint8Array(e, t) : new Uint8Array(e, t, r), u.__proto__ = i.prototype, u;
+            }
+            function n(e) {
+              if (i.isBuffer(e)) {
+                var t = 0 | h(e.length), r = O(t);
+                return r.length === 0 || e.copy(r, 0, 0, t), r;
+              }
+              return e.length === void 0 ? e.type === "Buffer" && Array.isArray(e.data) ? w(e.data) : void 0 : typeof e.length != "number" || D(e.length) ? O(0) : w(e);
+            }
+            function h(e) {
+              if (e >= 2147483647) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x7fffffff bytes");
+              return 0 | e;
+            }
+            function y(e, t) {
+              if (i.isBuffer(e)) return e.length;
+              if (ArrayBuffer.isView(e) || A(e, ArrayBuffer)) return e.byteLength;
+              if (typeof e != "string") throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof e);
+              var r = e.length, u = 2 < arguments.length && arguments[2] === !0;
+              if (!u && r === 0) return 0;
+              for (var E = !1; ; ) switch (t) {
+                case "ascii":
+                case "latin1":
+                case "binary":
+                  return r;
+                case "utf8":
+                case "utf-8":
+                  return _e(e).length;
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return 2 * r;
+                case "hex":
+                  return r >>> 1;
+                case "base64":
+                  return le(e).length;
+                default:
+                  if (E) return u ? -1 : _e(e).length;
+                  t = ("" + t).toLowerCase(), E = !0;
+              }
+            }
+            function k(e, t, r) {
+              var u = !1;
+              if ((t === void 0 || 0 > t) && (t = 0), t > this.length || ((r === void 0 || r > this.length) && (r = this.length), 0 >= r) || (r >>>= 0, t >>>= 0, r <= t)) return "";
+              for (e || (e = "utf8"); ; ) switch (e) {
+                case "hex":
+                  return oe(this, t, r);
+                case "utf8":
+                case "utf-8":
+                  return Z(this, t, r);
+                case "ascii":
+                  return H(this, t, r);
+                case "latin1":
+                case "binary":
+                  return Ee(this, t, r);
+                case "base64":
+                  return K(this, t, r);
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return de(this, t, r);
+                default:
+                  if (u) throw new TypeError("Unknown encoding: " + e);
+                  e = (e + "").toLowerCase(), u = !0;
+              }
+            }
+            function f(e, t, r) {
+              var u = e[t];
+              e[t] = e[r], e[r] = u;
+            }
+            function T(e, t, r, u, E) {
+              if (e.length === 0) return -1;
+              if (typeof r == "string" ? (u = r, r = 0) : 2147483647 < r ? r = 2147483647 : -2147483648 > r && (r = -2147483648), r = +r, D(r) && (r = E ? 0 : e.length - 1), 0 > r && (r = e.length + r), r >= e.length) {
+                if (E) return -1;
+                r = e.length - 1;
+              } else if (0 > r) if (E) r = 0;
+              else return -1;
+              if (typeof t == "string" && (t = i.from(t, u)), i.isBuffer(t)) return t.length === 0 ? -1 : P(e, t, r, u, E);
+              if (typeof t == "number") return t &= 255, typeof Uint8Array.prototype.indexOf == "function" ? E ? Uint8Array.prototype.indexOf.call(e, t, r) : Uint8Array.prototype.lastIndexOf.call(e, t, r) : P(e, [t], r, u, E);
+              throw new TypeError("val must be string, number or Buffer");
+            }
+            function P(e, t, r, u, E) {
+              function N(he, fe) {
+                return q === 1 ? he[fe] : he.readUInt16BE(fe * q);
+              }
+              var q = 1, G = e.length, $ = t.length;
+              if (u !== void 0 && (u = (u + "").toLowerCase(), u === "ucs2" || u === "ucs-2" || u === "utf16le" || u === "utf-16le")) {
+                if (2 > e.length || 2 > t.length) return -1;
+                q = 2, G /= 2, $ /= 2, r /= 2;
+              }
+              var Y;
+              if (E) {
+                var X = -1;
+                for (Y = r; Y < G; Y++) if (N(e, Y) !== N(t, X === -1 ? 0 : Y - X)) X !== -1 && (Y -= Y - X), X = -1;
+                else if (X === -1 && (X = Y), Y - X + 1 === $) return X * q;
+              } else for (r + $ > G && (r = G - $), Y = r; 0 <= Y; Y--) {
+                for (var ee = !0, ve = 0; ve < $; ve++) if (N(e, Y + ve) !== N(t, ve)) {
+                  ee = !1;
+                  break;
+                }
+                if (ee) return Y;
+              }
+              return -1;
+            }
+            function p(e, t, r, u) {
+              r = +r || 0;
+              var E = e.length - r;
+              u ? (u = +u, u > E && (u = E)) : u = E;
+              var N = t.length;
+              u > N / 2 && (u = N / 2);
+              for (var q, G = 0; G < u; ++G) {
+                if (q = parseInt(t.substr(2 * G, 2), 16), D(q)) return G;
+                e[r + G] = q;
+              }
+              return G;
+            }
+            function v(e, t, r, u) {
+              return C(_e(t, e.length - r), e, r, u);
+            }
+            function I(e, t, r, u) {
+              return C(ye(t), e, r, u);
+            }
+            function B(e, t, r, u) {
+              return I(e, t, r, u);
+            }
+            function V(e, t, r, u) {
+              return C(le(t), e, r, u);
+            }
+            function z(e, t, r, u) {
+              return C(ce(t, e.length - r), e, r, u);
+            }
+            function K(e, t, r) {
+              return t === 0 && r === e.length ? W.fromByteArray(e) : W.fromByteArray(e.slice(t, r));
+            }
+            function Z(e, t, r) {
+              r = S(e.length, r);
+              for (var u = [], E = t; E < r; ) {
+                var N = e[E], q = null, G = 239 < N ? 4 : 223 < N ? 3 : 191 < N ? 2 : 1;
+                if (E + G <= r) {
+                  var $, Y, X, ee;
+                  G === 1 ? 128 > N && (q = N) : G === 2 ? ($ = e[E + 1], (192 & $) == 128 && (ee = (31 & N) << 6 | 63 & $, 127 < ee && (q = ee))) : G === 3 ? ($ = e[E + 1], Y = e[E + 2], (192 & $) == 128 && (192 & Y) == 128 && (ee = (15 & N) << 12 | (63 & $) << 6 | 63 & Y, 2047 < ee && (55296 > ee || 57343 < ee) && (q = ee))) : G === 4 && ($ = e[E + 1], Y = e[E + 2], X = e[E + 3], (192 & $) == 128 && (192 & Y) == 128 && (192 & X) == 128 && (ee = (15 & N) << 18 | (63 & $) << 12 | (63 & Y) << 6 | 63 & X, 65535 < ee && 1114112 > ee && (q = ee)));
+                }
+                q === null ? (q = 65533, G = 1) : 65535 < q && (q -= 65536, u.push(55296 | 1023 & q >>> 10), q = 56320 | 1023 & q), u.push(q), E += G;
+              }
+              return te(u);
+            }
+            function te(e) {
+              var t = e.length;
+              if (t <= 4096) return c.apply(String, e);
+              for (var r = "", u = 0; u < t; ) r += c.apply(String, e.slice(u, u += 4096));
+              return r;
+            }
+            function H(e, t, r) {
+              var u = "";
+              r = S(e.length, r);
+              for (var E = t; E < r; ++E) u += c(127 & e[E]);
+              return u;
+            }
+            function Ee(e, t, r) {
+              var u = "";
+              r = S(e.length, r);
+              for (var E = t; E < r; ++E) u += c(e[E]);
+              return u;
+            }
+            function oe(e, t, r) {
+              var u = e.length;
+              (!t || 0 > t) && (t = 0), (!r || 0 > r || r > u) && (r = u);
+              for (var E = "", N = t; N < r; ++N) E += me(e[N]);
+              return E;
+            }
+            function de(e, t, r) {
+              for (var u = e.slice(t, r), E = "", N = 0; N < u.length; N += 2) E += c(u[N] + 256 * u[N + 1]);
+              return E;
+            }
+            function J(e, t, r) {
+              if (e % 1 != 0 || 0 > e) throw new RangeError("offset is not uint");
+              if (e + t > r) throw new RangeError("Trying to access beyond buffer length");
+            }
+            function Q(e, t, r, u, E, N) {
+              if (!i.isBuffer(e)) throw new TypeError('"buffer" argument must be a Buffer instance');
+              if (t > E || t < N) throw new RangeError('"value" argument is out of bounds');
+              if (r + u > e.length) throw new RangeError("Index out of range");
+            }
+            function ae(e, t, r, u) {
+              if (r + u > e.length) throw new RangeError("Index out of range");
+              if (0 > r) throw new RangeError("Index out of range");
+            }
+            function pe(e, t, r, u, E) {
+              return t = +t, r >>>= 0, E || ae(e, t, r, 4, 34028234663852886e22, -34028234663852886e22), s.write(e, t, r, u, 23, 4), r + 4;
+            }
+            function ge(e, t, r, u, E) {
+              return t = +t, r >>>= 0, E || ae(e, t, r, 8, 17976931348623157e292, -17976931348623157e292), s.write(e, t, r, u, 52, 8), r + 8;
+            }
+            function Se(e) {
+              if (e = e.split("=")[0], e = e.trim().replace(o, ""), 2 > e.length) return "";
+              for (; e.length % 4 != 0; ) e += "=";
+              return e;
+            }
+            function me(e) {
+              return 16 > e ? "0" + e.toString(16) : e.toString(16);
+            }
+            function _e(e, t) {
+              t = t || 1 / 0;
+              for (var r, u = e.length, E = null, N = [], q = 0; q < u; ++q) {
+                if (r = e.charCodeAt(q), 55295 < r && 57344 > r) {
+                  if (!E) {
+                    if (56319 < r) {
+                      -1 < (t -= 3) && N.push(239, 191, 189);
+                      continue;
+                    } else if (q + 1 === u) {
+                      -1 < (t -= 3) && N.push(239, 191, 189);
+                      continue;
+                    }
+                    E = r;
+                    continue;
+                  }
+                  if (56320 > r) {
+                    -1 < (t -= 3) && N.push(239, 191, 189), E = r;
+                    continue;
+                  }
+                  r = (E - 55296 << 10 | r - 56320) + 65536;
+                } else E && -1 < (t -= 3) && N.push(239, 191, 189);
+                if (E = null, 128 > r) {
+                  if (0 > (t -= 1)) break;
+                  N.push(r);
+                } else if (2048 > r) {
+                  if (0 > (t -= 2)) break;
+                  N.push(192 | r >> 6, 128 | 63 & r);
+                } else if (65536 > r) {
+                  if (0 > (t -= 3)) break;
+                  N.push(224 | r >> 12, 128 | 63 & r >> 6, 128 | 63 & r);
+                } else if (1114112 > r) {
+                  if (0 > (t -= 4)) break;
+                  N.push(240 | r >> 18, 128 | 63 & r >> 12, 128 | 63 & r >> 6, 128 | 63 & r);
+                } else throw new Error("Invalid code point");
+              }
+              return N;
+            }
+            function ye(e) {
+              for (var t = [], r = 0; r < e.length; ++r) t.push(255 & e.charCodeAt(r));
+              return t;
+            }
+            function ce(e, t) {
+              for (var r, u, E, N = [], q = 0; q < e.length && !(0 > (t -= 2)); ++q) r = e.charCodeAt(q), u = r >> 8, E = r % 256, N.push(E), N.push(u);
+              return N;
+            }
+            function le(e) {
+              return W.toByteArray(Se(e));
+            }
+            function C(e, t, r, u) {
+              for (var E = 0; E < u && !(E + r >= t.length || E >= e.length); ++E) t[E + r] = e[E];
+              return E;
+            }
+            function A(e, t) {
+              return e instanceof t || e != null && e.constructor != null && e.constructor.name != null && e.constructor.name === t.name;
+            }
+            function D(e) {
+              return e !== e;
+            }
+            var W = R("base64-js"), s = R("ieee754");
+            _.Buffer = i, _.SlowBuffer = function(e) {
+              return +e != e && (e = 0), i.alloc(+e);
+            }, _.INSPECT_MAX_BYTES = 50, _.kMaxLength = 2147483647, i.TYPED_ARRAY_SUPPORT = (function() {
+              try {
+                var e = /* @__PURE__ */ new Uint8Array(1);
+                return e.__proto__ = {
+                  __proto__: Uint8Array.prototype,
+                  foo: function() {
+                    return 42;
+                  }
+                }, e.foo() === 42;
+              } catch {
+                return !1;
+              }
+            })(), i.TYPED_ARRAY_SUPPORT || typeof console > "u" || typeof console.error != "function" || console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."), Object.defineProperty(i.prototype, "parent", {
+              enumerable: !0,
+              get: function() {
+                return i.isBuffer(this) ? this.buffer : void 0;
+              }
+            }), Object.defineProperty(i.prototype, "offset", {
+              enumerable: !0,
+              get: function() {
+                return i.isBuffer(this) ? this.byteOffset : void 0;
+              }
+            }), typeof Symbol < "u" && Symbol.species != null && i[Symbol.species] === i && Object.defineProperty(i, Symbol.species, {
+              value: null,
+              configurable: !0,
+              enumerable: !1,
+              writable: !1
+            }), i.poolSize = 8192, i.from = function(e, t, r) {
+              return l(e, t, r);
+            }, i.prototype.__proto__ = Uint8Array.prototype, i.__proto__ = Uint8Array, i.alloc = function(e, t, r) {
+              return a(e, t, r);
+            }, i.allocUnsafe = function(e) {
+              return g(e);
+            }, i.allocUnsafeSlow = function(e) {
+              return g(e);
+            }, i.isBuffer = function(e) {
+              return e != null && e._isBuffer === !0 && e !== i.prototype;
+            }, i.compare = function(e, t) {
+              if (A(e, Uint8Array) && (e = i.from(e, e.offset, e.byteLength)), A(t, Uint8Array) && (t = i.from(t, t.offset, t.byteLength)), !i.isBuffer(e) || !i.isBuffer(t)) throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
+              if (e === t) return 0;
+              for (var r = e.length, u = t.length, E = 0, N = S(r, u); E < N; ++E) if (e[E] !== t[E]) {
+                r = e[E], u = t[E];
+                break;
+              }
+              return r < u ? -1 : u < r ? 1 : 0;
+            }, i.isEncoding = function(e) {
+              switch ((e + "").toLowerCase()) {
+                case "hex":
+                case "utf8":
+                case "utf-8":
+                case "ascii":
+                case "latin1":
+                case "binary":
+                case "base64":
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return !0;
+                default:
+                  return !1;
+              }
+            }, i.concat = function(e, t) {
+              if (!Array.isArray(e)) throw new TypeError('"list" argument must be an Array of Buffers');
+              if (e.length === 0) return i.alloc(0);
+              var r;
+              if (t === void 0) for (t = 0, r = 0; r < e.length; ++r) t += e[r].length;
+              var u = i.allocUnsafe(t), E = 0;
+              for (r = 0; r < e.length; ++r) {
+                var N = e[r];
+                if (A(N, Uint8Array) && (N = i.from(N)), !i.isBuffer(N)) throw new TypeError('"list" argument must be an Array of Buffers');
+                N.copy(u, E), E += N.length;
+              }
+              return u;
+            }, i.byteLength = y, i.prototype._isBuffer = !0, i.prototype.swap16 = function() {
+              var e = this.length;
+              if (e % 2 != 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
+              for (var t = 0; t < e; t += 2) f(this, t, t + 1);
+              return this;
+            }, i.prototype.swap32 = function() {
+              var e = this.length;
+              if (e % 4 != 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
+              for (var t = 0; t < e; t += 4) f(this, t, t + 3), f(this, t + 1, t + 2);
+              return this;
+            }, i.prototype.swap64 = function() {
+              var e = this.length;
+              if (e % 8 != 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
+              for (var t = 0; t < e; t += 8) f(this, t, t + 7), f(this, t + 1, t + 6), f(this, t + 2, t + 5), f(this, t + 3, t + 4);
+              return this;
+            }, i.prototype.toString = function() {
+              var e = this.length;
+              return e === 0 ? "" : arguments.length === 0 ? Z(this, 0, e) : k.apply(this, arguments);
+            }, i.prototype.toLocaleString = i.prototype.toString, i.prototype.equals = function(e) {
+              if (!i.isBuffer(e)) throw new TypeError("Argument must be a Buffer");
+              return this === e || i.compare(this, e) === 0;
+            }, i.prototype.inspect = function() {
+              var e = "", t = _.INSPECT_MAX_BYTES;
+              return e = this.toString("hex", 0, t).replace(/(.{2})/g, "$1 ").trim(), this.length > t && (e += " ... "), "<Buffer " + e + ">";
+            }, i.prototype.compare = function(e, t, r, u, E) {
+              if (A(e, Uint8Array) && (e = i.from(e, e.offset, e.byteLength)), !i.isBuffer(e)) throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof e);
+              if (t === void 0 && (t = 0), r === void 0 && (r = e ? e.length : 0), u === void 0 && (u = 0), E === void 0 && (E = this.length), 0 > t || r > e.length || 0 > u || E > this.length) throw new RangeError("out of range index");
+              if (u >= E && t >= r) return 0;
+              if (u >= E) return -1;
+              if (t >= r) return 1;
+              if (t >>>= 0, r >>>= 0, u >>>= 0, E >>>= 0, this === e) return 0;
+              for (var N = E - u, q = r - t, G = S(N, q), $ = this.slice(u, E), Y = e.slice(t, r), X = 0; X < G; ++X) if ($[X] !== Y[X]) {
+                N = $[X], q = Y[X];
+                break;
+              }
+              return N < q ? -1 : q < N ? 1 : 0;
+            }, i.prototype.includes = function(e, t, r) {
+              return this.indexOf(e, t, r) !== -1;
+            }, i.prototype.indexOf = function(e, t, r) {
+              return T(this, e, t, r, !0);
+            }, i.prototype.lastIndexOf = function(e, t, r) {
+              return T(this, e, t, r, !1);
+            }, i.prototype.write = function(e, t, r, u) {
+              if (t === void 0) u = "utf8", r = this.length, t = 0;
+              else if (r === void 0 && typeof t == "string") u = t, r = this.length, t = 0;
+              else if (isFinite(t)) t >>>= 0, isFinite(r) ? (r >>>= 0, u === void 0 && (u = "utf8")) : (u = r, r = void 0);
+              else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+              var E = this.length - t;
+              if ((r === void 0 || r > E) && (r = E), 0 < e.length && (0 > r || 0 > t) || t > this.length) throw new RangeError("Attempt to write outside buffer bounds");
+              u || (u = "utf8");
+              for (var N = !1; ; ) switch (u) {
+                case "hex":
+                  return p(this, e, t, r);
+                case "utf8":
+                case "utf-8":
+                  return v(this, e, t, r);
+                case "ascii":
+                  return I(this, e, t, r);
+                case "latin1":
+                case "binary":
+                  return B(this, e, t, r);
+                case "base64":
+                  return V(this, e, t, r);
+                case "ucs2":
+                case "ucs-2":
+                case "utf16le":
+                case "utf-16le":
+                  return z(this, e, t, r);
+                default:
+                  if (N) throw new TypeError("Unknown encoding: " + u);
+                  u = ("" + u).toLowerCase(), N = !0;
+              }
+            }, i.prototype.toJSON = function() {
+              return {
+                type: "Buffer",
+                data: Array.prototype.slice.call(this._arr || this, 0)
+              };
+            }, i.prototype.slice = function(e, t) {
+              var r = this.length;
+              e = ~~e, t = t === void 0 ? r : ~~t, 0 > e ? (e += r, 0 > e && (e = 0)) : e > r && (e = r), 0 > t ? (t += r, 0 > t && (t = 0)) : t > r && (t = r), t < e && (t = e);
+              var u = this.subarray(e, t);
+              return u.__proto__ = i.prototype, u;
+            }, i.prototype.readUIntLE = function(e, t, r) {
+              e >>>= 0, t >>>= 0, r || J(e, t, this.length);
+              for (var u = this[e], E = 1, N = 0; ++N < t && (E *= 256); ) u += this[e + N] * E;
+              return u;
+            }, i.prototype.readUIntBE = function(e, t, r) {
+              e >>>= 0, t >>>= 0, r || J(e, t, this.length);
+              for (var u = this[e + --t], E = 1; 0 < t && (E *= 256); ) u += this[e + --t] * E;
+              return u;
+            }, i.prototype.readUInt8 = function(e, t) {
+              return e >>>= 0, t || J(e, 1, this.length), this[e];
+            }, i.prototype.readUInt16LE = function(e, t) {
+              return e >>>= 0, t || J(e, 2, this.length), this[e] | this[e + 1] << 8;
+            }, i.prototype.readUInt16BE = function(e, t) {
+              return e >>>= 0, t || J(e, 2, this.length), this[e] << 8 | this[e + 1];
+            }, i.prototype.readUInt32LE = function(e, t) {
+              return e >>>= 0, t || J(e, 4, this.length), (this[e] | this[e + 1] << 8 | this[e + 2] << 16) + 16777216 * this[e + 3];
+            }, i.prototype.readUInt32BE = function(e, t) {
+              return e >>>= 0, t || J(e, 4, this.length), 16777216 * this[e] + (this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3]);
+            }, i.prototype.readIntLE = function(e, t, r) {
+              e >>>= 0, t >>>= 0, r || J(e, t, this.length);
+              for (var u = this[e], E = 1, N = 0; ++N < t && (E *= 256); ) u += this[e + N] * E;
+              return E *= 128, u >= E && (u -= F(2, 8 * t)), u;
+            }, i.prototype.readIntBE = function(e, t, r) {
+              e >>>= 0, t >>>= 0, r || J(e, t, this.length);
+              for (var u = t, E = 1, N = this[e + --u]; 0 < u && (E *= 256); ) N += this[e + --u] * E;
+              return E *= 128, N >= E && (N -= F(2, 8 * t)), N;
+            }, i.prototype.readInt8 = function(e, t) {
+              return e >>>= 0, t || J(e, 1, this.length), 128 & this[e] ? -1 * (255 - this[e] + 1) : this[e];
+            }, i.prototype.readInt16LE = function(e, t) {
+              e >>>= 0, t || J(e, 2, this.length);
+              var r = this[e] | this[e + 1] << 8;
+              return 32768 & r ? 4294901760 | r : r;
+            }, i.prototype.readInt16BE = function(e, t) {
+              e >>>= 0, t || J(e, 2, this.length);
+              var r = this[e + 1] | this[e] << 8;
+              return 32768 & r ? 4294901760 | r : r;
+            }, i.prototype.readInt32LE = function(e, t) {
+              return e >>>= 0, t || J(e, 4, this.length), this[e] | this[e + 1] << 8 | this[e + 2] << 16 | this[e + 3] << 24;
+            }, i.prototype.readInt32BE = function(e, t) {
+              return e >>>= 0, t || J(e, 4, this.length), this[e] << 24 | this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3];
+            }, i.prototype.readFloatLE = function(e, t) {
+              return e >>>= 0, t || J(e, 4, this.length), s.read(this, e, !0, 23, 4);
+            }, i.prototype.readFloatBE = function(e, t) {
+              return e >>>= 0, t || J(e, 4, this.length), s.read(this, e, !1, 23, 4);
+            }, i.prototype.readDoubleLE = function(e, t) {
+              return e >>>= 0, t || J(e, 8, this.length), s.read(this, e, !0, 52, 8);
+            }, i.prototype.readDoubleBE = function(e, t) {
+              return e >>>= 0, t || J(e, 8, this.length), s.read(this, e, !1, 52, 8);
+            }, i.prototype.writeUIntLE = function(e, t, r, u) {
+              if (e = +e, t >>>= 0, r >>>= 0, !u) {
+                var E = F(2, 8 * r) - 1;
+                Q(this, e, t, r, E, 0);
+              }
+              var N = 1, q = 0;
+              for (this[t] = 255 & e; ++q < r && (N *= 256); ) this[t + q] = 255 & e / N;
+              return t + r;
+            }, i.prototype.writeUIntBE = function(e, t, r, u) {
+              if (e = +e, t >>>= 0, r >>>= 0, !u) {
+                var E = F(2, 8 * r) - 1;
+                Q(this, e, t, r, E, 0);
+              }
+              var N = r - 1, q = 1;
+              for (this[t + N] = 255 & e; 0 <= --N && (q *= 256); ) this[t + N] = 255 & e / q;
+              return t + r;
+            }, i.prototype.writeUInt8 = function(e, t, r) {
+              return e = +e, t >>>= 0, r || Q(this, e, t, 1, 255, 0), this[t] = 255 & e, t + 1;
+            }, i.prototype.writeUInt16LE = function(e, t, r) {
+              return e = +e, t >>>= 0, r || Q(this, e, t, 2, 65535, 0), this[t] = 255 & e, this[t + 1] = e >>> 8, t + 2;
+            }, i.prototype.writeUInt16BE = function(e, t, r) {
+              return e = +e, t >>>= 0, r || Q(this, e, t, 2, 65535, 0), this[t] = e >>> 8, this[t + 1] = 255 & e, t + 2;
+            }, i.prototype.writeUInt32LE = function(e, t, r) {
+              return e = +e, t >>>= 0, r || Q(this, e, t, 4, 4294967295, 0), this[t + 3] = e >>> 24, this[t + 2] = e >>> 16, this[t + 1] = e >>> 8, this[t] = 255 & e, t + 4;
+            }, i.prototype.writeUInt32BE = function(e, t, r) {
+              return e = +e, t >>>= 0, r || Q(this, e, t, 4, 4294967295, 0), this[t] = e >>> 24, this[t + 1] = e >>> 16, this[t + 2] = e >>> 8, this[t + 3] = 255 & e, t + 4;
+            }, i.prototype.writeIntLE = function(e, t, r, u) {
+              if (e = +e, t >>>= 0, !u) {
+                var E = F(2, 8 * r - 1);
+                Q(this, e, t, r, E - 1, -E);
+              }
+              var N = 0, q = 1, G = 0;
+              for (this[t] = 255 & e; ++N < r && (q *= 256); ) 0 > e && G === 0 && this[t + N - 1] !== 0 && (G = 1), this[t + N] = 255 & (e / q >> 0) - G;
+              return t + r;
+            }, i.prototype.writeIntBE = function(e, t, r, u) {
+              if (e = +e, t >>>= 0, !u) {
+                var E = F(2, 8 * r - 1);
+                Q(this, e, t, r, E - 1, -E);
+              }
+              var N = r - 1, q = 1, G = 0;
+              for (this[t + N] = 255 & e; 0 <= --N && (q *= 256); ) 0 > e && G === 0 && this[t + N + 1] !== 0 && (G = 1), this[t + N] = 255 & (e / q >> 0) - G;
+              return t + r;
+            }, i.prototype.writeInt8 = function(e, t, r) {
+              return e = +e, t >>>= 0, r || Q(this, e, t, 1, 127, -128), 0 > e && (e = 255 + e + 1), this[t] = 255 & e, t + 1;
+            }, i.prototype.writeInt16LE = function(e, t, r) {
+              return e = +e, t >>>= 0, r || Q(this, e, t, 2, 32767, -32768), this[t] = 255 & e, this[t + 1] = e >>> 8, t + 2;
+            }, i.prototype.writeInt16BE = function(e, t, r) {
+              return e = +e, t >>>= 0, r || Q(this, e, t, 2, 32767, -32768), this[t] = e >>> 8, this[t + 1] = 255 & e, t + 2;
+            }, i.prototype.writeInt32LE = function(e, t, r) {
+              return e = +e, t >>>= 0, r || Q(this, e, t, 4, 2147483647, -2147483648), this[t] = 255 & e, this[t + 1] = e >>> 8, this[t + 2] = e >>> 16, this[t + 3] = e >>> 24, t + 4;
+            }, i.prototype.writeInt32BE = function(e, t, r) {
+              return e = +e, t >>>= 0, r || Q(this, e, t, 4, 2147483647, -2147483648), 0 > e && (e = 4294967295 + e + 1), this[t] = e >>> 24, this[t + 1] = e >>> 16, this[t + 2] = e >>> 8, this[t + 3] = 255 & e, t + 4;
+            }, i.prototype.writeFloatLE = function(e, t, r) {
+              return pe(this, e, t, !0, r);
+            }, i.prototype.writeFloatBE = function(e, t, r) {
+              return pe(this, e, t, !1, r);
+            }, i.prototype.writeDoubleLE = function(e, t, r) {
+              return ge(this, e, t, !0, r);
+            }, i.prototype.writeDoubleBE = function(e, t, r) {
+              return ge(this, e, t, !1, r);
+            }, i.prototype.copy = function(e, t, r, u) {
+              if (!i.isBuffer(e)) throw new TypeError("argument should be a Buffer");
+              if (r || (r = 0), u || u === 0 || (u = this.length), t >= e.length && (t = e.length), t || (t = 0), 0 < u && u < r && (u = r), u === r || e.length === 0 || this.length === 0) return 0;
+              if (0 > t) throw new RangeError("targetStart out of bounds");
+              if (0 > r || r >= this.length) throw new RangeError("Index out of range");
+              if (0 > u) throw new RangeError("sourceEnd out of bounds");
+              u > this.length && (u = this.length), e.length - t < u - r && (u = e.length - t + r);
+              var E = u - r;
+              if (this === e && typeof Uint8Array.prototype.copyWithin == "function") this.copyWithin(t, r, u);
+              else if (this === e && r < t && t < u) for (var N = E - 1; 0 <= N; --N) e[N + t] = this[N + r];
+              else Uint8Array.prototype.set.call(e, this.subarray(r, u), t);
+              return E;
+            }, i.prototype.fill = function(e, t, r, u) {
+              if (typeof e == "string") {
+                if (typeof t == "string" ? (u = t, t = 0, r = this.length) : typeof r == "string" && (u = r, r = this.length), u !== void 0 && typeof u != "string") throw new TypeError("encoding must be a string");
+                if (typeof u == "string" && !i.isEncoding(u)) throw new TypeError("Unknown encoding: " + u);
+                if (e.length === 1) {
+                  var E = e.charCodeAt(0);
+                  (u === "utf8" && 128 > E || u === "latin1") && (e = E);
+                }
+              } else typeof e == "number" && (e &= 255);
+              if (0 > t || this.length < t || this.length < r) throw new RangeError("Out of range index");
+              if (r <= t) return this;
+              t >>>= 0, r = r === void 0 ? this.length : r >>> 0, e || (e = 0);
+              var N;
+              if (typeof e == "number") for (N = t; N < r; ++N) this[N] = e;
+              else {
+                var q = i.isBuffer(e) ? e : i.from(e, u), G = q.length;
+                if (G === 0) throw new TypeError('The value "' + e + '" is invalid for argument "value"');
+                for (N = 0; N < r - t; ++N) this[N + t] = q[N % G];
+              }
+              return this;
+            };
+            var o = /[^+/0-9A-Za-z-_]/g;
+          }).call(this);
+        }).call(this, R("buffer").Buffer);
+      }, {
+        "base64-js": 1,
+        buffer: 3,
+        ieee754: 9
+      }],
+      4: [function(R, M, _) {
+        (function(c) {
+          (function() {
+            function S() {
+              let i;
+              try {
+                i = _.storage.getItem("debug");
+              } catch {
+              }
+              return !i && typeof c < "u" && "env" in c && (i = c.env.DEBUG), i;
+            }
+            _.formatArgs = function(i) {
+              if (i[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + i[0] + (this.useColors ? "%c " : " ") + "+" + M.exports.humanize(this.diff), !this.useColors) return;
+              const l = "color: " + this.color;
+              i.splice(1, 0, l, "color: inherit");
+              let d = 0, a = 0;
+              i[0].replace(/%[a-zA-Z%]/g, (g) => {
+                g === "%%" || (d++, g === "%c" && (a = d));
+              }), i.splice(a, 0, l);
+            }, _.save = function(i) {
+              try {
+                i ? _.storage.setItem("debug", i) : _.storage.removeItem("debug");
+              } catch {
+              }
+            }, _.load = S, _.useColors = function() {
+              return !!(typeof window < "u" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) || !(typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) && (typeof document < "u" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window < "u" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && 31 <= parseInt(RegExp.$1, 10) || typeof navigator < "u" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
+            }, _.storage = (function() {
+              try {
+                return localStorage;
+              } catch {
+              }
+            })(), _.destroy = /* @__PURE__ */ (() => {
+              let i = !1;
+              return () => {
+                i || (i = !0, console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."));
+              };
+            })(), _.colors = [
+              "#0000CC",
+              "#0000FF",
+              "#0033CC",
+              "#0033FF",
+              "#0066CC",
+              "#0066FF",
+              "#0099CC",
+              "#0099FF",
+              "#00CC00",
+              "#00CC33",
+              "#00CC66",
+              "#00CC99",
+              "#00CCCC",
+              "#00CCFF",
+              "#3300CC",
+              "#3300FF",
+              "#3333CC",
+              "#3333FF",
+              "#3366CC",
+              "#3366FF",
+              "#3399CC",
+              "#3399FF",
+              "#33CC00",
+              "#33CC33",
+              "#33CC66",
+              "#33CC99",
+              "#33CCCC",
+              "#33CCFF",
+              "#6600CC",
+              "#6600FF",
+              "#6633CC",
+              "#6633FF",
+              "#66CC00",
+              "#66CC33",
+              "#9900CC",
+              "#9900FF",
+              "#9933CC",
+              "#9933FF",
+              "#99CC00",
+              "#99CC33",
+              "#CC0000",
+              "#CC0033",
+              "#CC0066",
+              "#CC0099",
+              "#CC00CC",
+              "#CC00FF",
+              "#CC3300",
+              "#CC3333",
+              "#CC3366",
+              "#CC3399",
+              "#CC33CC",
+              "#CC33FF",
+              "#CC6600",
+              "#CC6633",
+              "#CC9900",
+              "#CC9933",
+              "#CCCC00",
+              "#CCCC33",
+              "#FF0000",
+              "#FF0033",
+              "#FF0066",
+              "#FF0099",
+              "#FF00CC",
+              "#FF00FF",
+              "#FF3300",
+              "#FF3333",
+              "#FF3366",
+              "#FF3399",
+              "#FF33CC",
+              "#FF33FF",
+              "#FF6600",
+              "#FF6633",
+              "#FF9900",
+              "#FF9933",
+              "#FFCC00",
+              "#FFCC33"
+            ], _.log = console.debug || console.log || (() => {
+            }), M.exports = R("./common")(_);
+            const { formatters: O } = M.exports;
+            O.j = function(i) {
+              try {
+                return JSON.stringify(i);
+              } catch (l) {
+                return "[UnexpectedJSONParseError]: " + l.message;
+              }
+            };
+          }).call(this);
+        }).call(this, R("_process"));
+      }, {
+        "./common": 5,
+        _process: 12
+      }],
+      5: [function(R, M) {
+        M.exports = function(_) {
+          function c(i) {
+            function l(...g) {
+              if (!l.enabled) return;
+              const L = l, w = +/* @__PURE__ */ new Date();
+              L.diff = w - (d || w), L.prev = d, L.curr = w, d = w, g[0] = c.coerce(g[0]), typeof g[0] != "string" && g.unshift("%O");
+              let b = 0;
+              g[0] = g[0].replace(/%([a-zA-Z%])/g, (n, h) => {
+                if (n === "%%") return "%";
+                b++;
+                const y = c.formatters[h];
+                if (typeof y == "function") {
+                  const k = g[b];
+                  n = y.call(L, k), g.splice(b, 1), b--;
+                }
+                return n;
+              }), c.formatArgs.call(L, g), (L.log || c.log).apply(L, g);
+            }
+            let d, a = null;
+            return l.namespace = i, l.useColors = c.useColors(), l.color = c.selectColor(i), l.extend = S, l.destroy = c.destroy, Object.defineProperty(l, "enabled", {
+              enumerable: !0,
+              configurable: !1,
+              get: () => a === null ? c.enabled(i) : a,
+              set: (g) => {
+                a = g;
+              }
+            }), typeof c.init == "function" && c.init(l), l;
+          }
+          function S(i, l) {
+            const d = c(this.namespace + (typeof l > "u" ? ":" : l) + i);
+            return d.log = this.log, d;
+          }
+          function O(i) {
+            return i.toString().substring(2, i.toString().length - 2).replace(/\.\*\?$/, "*");
+          }
+          return c.debug = c, c.default = c, c.coerce = function(i) {
+            return i instanceof Error ? i.stack || i.message : i;
+          }, c.disable = function() {
+            const i = [...c.names.map(O), ...c.skips.map(O).map((l) => "-" + l)].join(",");
+            return c.enable(""), i;
+          }, c.enable = function(i) {
+            c.save(i), c.names = [], c.skips = [];
+            let l;
+            const d = (typeof i == "string" ? i : "").split(/[\s,]+/), a = d.length;
+            for (l = 0; l < a; l++) d[l] && (i = d[l].replace(/\*/g, ".*?"), i[0] === "-" ? c.skips.push(new RegExp("^" + i.substr(1) + "$")) : c.names.push(new RegExp("^" + i + "$")));
+          }, c.enabled = function(i) {
+            if (i[i.length - 1] === "*") return !0;
+            let l, d;
+            for (l = 0, d = c.skips.length; l < d; l++) if (c.skips[l].test(i)) return !1;
+            for (l = 0, d = c.names.length; l < d; l++) if (c.names[l].test(i)) return !0;
+            return !1;
+          }, c.humanize = R("ms"), c.destroy = function() {
+            console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+          }, Object.keys(_).forEach((i) => {
+            c[i] = _[i];
+          }), c.names = [], c.skips = [], c.formatters = {}, c.selectColor = function(i) {
+            let l = 0;
+            for (let d = 0; d < i.length; d++) l = (l << 5) - l + i.charCodeAt(d), l |= 0;
+            return c.colors[U(l) % c.colors.length];
+          }, c.enable(c.load()), c;
+        };
+      }, { ms: 11 }],
+      6: [function(R, M) {
+        "use strict";
+        function _(c, S) {
+          for (const O in S) Object.defineProperty(c, O, {
+            value: S[O],
+            enumerable: !0,
+            configurable: !0
+          });
+          return c;
+        }
+        M.exports = function(c, S, O) {
+          if (!c || typeof c == "string") throw new TypeError("Please pass an Error to err-code");
+          O || (O = {}), typeof S == "object" && (O = S, S = ""), S && (O.code = S);
+          try {
+            return _(c, O);
+          } catch {
+            O.message = c.message, O.stack = c.stack;
+            const l = function() {
+            };
+            return l.prototype = Object.create(Object.getPrototypeOf(c)), _(new l(), O);
+          }
+        };
+      }, {}],
+      7: [function(R, M) {
+        "use strict";
+        function _(p) {
+          console && console.warn && console.warn(p);
+        }
+        function c() {
+          c.init.call(this);
+        }
+        function S(p) {
+          if (typeof p != "function") throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof p);
+        }
+        function O(p) {
+          return p._maxListeners === void 0 ? c.defaultMaxListeners : p._maxListeners;
+        }
+        function i(p, v, I, B) {
+          var V, z, K;
+          if (S(I), z = p._events, z === void 0 ? (z = p._events = /* @__PURE__ */ Object.create(null), p._eventsCount = 0) : (z.newListener !== void 0 && (p.emit("newListener", v, I.listener ? I.listener : I), z = p._events), K = z[v]), K === void 0) K = z[v] = I, ++p._eventsCount;
+          else if (typeof K == "function" ? K = z[v] = B ? [I, K] : [K, I] : B ? K.unshift(I) : K.push(I), V = O(p), 0 < V && K.length > V && !K.warned) {
+            K.warned = !0;
+            var Z = /* @__PURE__ */ new Error("Possible EventEmitter memory leak detected. " + K.length + " " + (v + " listeners added. Use emitter.setMaxListeners() to increase limit"));
+            Z.name = "MaxListenersExceededWarning", Z.emitter = p, Z.type = v, Z.count = K.length, _(Z);
+          }
+          return p;
+        }
+        function l() {
+          if (!this.fired) return this.target.removeListener(this.type, this.wrapFn), this.fired = !0, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
+        }
+        function d(p, v, I) {
+          var B = {
+            fired: !1,
+            wrapFn: void 0,
+            target: p,
+            type: v,
+            listener: I
+          }, V = l.bind(B);
+          return V.listener = I, B.wrapFn = V, V;
+        }
+        function a(p, v, I) {
+          var B = p._events;
+          if (B === void 0) return [];
+          var V = B[v];
+          return V === void 0 ? [] : typeof V == "function" ? I ? [V.listener || V] : [V] : I ? b(V) : L(V, V.length);
+        }
+        function g(p) {
+          var v = this._events;
+          if (v !== void 0) {
+            var I = v[p];
+            if (typeof I == "function") return 1;
+            if (I !== void 0) return I.length;
+          }
+          return 0;
+        }
+        function L(p, v) {
+          for (var I = Array(v), B = 0; B < v; ++B) I[B] = p[B];
+          return I;
+        }
+        function w(p, v) {
+          for (; v + 1 < p.length; v++) p[v] = p[v + 1];
+          p.pop();
+        }
+        function b(p) {
+          for (var v = Array(p.length), I = 0; I < v.length; ++I) v[I] = p[I].listener || p[I];
+          return v;
+        }
+        function n(p, v, I) {
+          typeof p.on == "function" && h(p, "error", v, I);
+        }
+        function h(p, v, I, B) {
+          if (typeof p.on == "function") B.once ? p.once(v, I) : p.on(v, I);
+          else if (typeof p.addEventListener == "function") p.addEventListener(v, function V(z) {
+            B.once && p.removeEventListener(v, V), I(z);
+          });
+          else throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof p);
+        }
+        var y, k = typeof Reflect == "object" ? Reflect : null, f = k && typeof k.apply == "function" ? k.apply : function(p, v, I) {
+          return Function.prototype.apply.call(p, v, I);
+        };
+        y = k && typeof k.ownKeys == "function" ? k.ownKeys : Object.getOwnPropertySymbols ? function(p) {
+          return Object.getOwnPropertyNames(p).concat(Object.getOwnPropertySymbols(p));
+        } : function(p) {
+          return Object.getOwnPropertyNames(p);
+        };
+        var T = Number.isNaN || function(p) {
+          return p !== p;
+        };
+        M.exports = c, M.exports.once = function(p, v) {
+          return new Promise(function(I, B) {
+            function V(K) {
+              p.removeListener(v, z), B(K);
+            }
+            function z() {
+              typeof p.removeListener == "function" && p.removeListener("error", V), I([].slice.call(arguments));
+            }
+            h(p, v, z, { once: !0 }), v !== "error" && n(p, V, { once: !0 });
+          });
+        }, c.EventEmitter = c, c.prototype._events = void 0, c.prototype._eventsCount = 0, c.prototype._maxListeners = void 0;
+        var P = 10;
+        Object.defineProperty(c, "defaultMaxListeners", {
+          enumerable: !0,
+          get: function() {
+            return P;
+          },
+          set: function(p) {
+            if (typeof p != "number" || 0 > p || T(p)) throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + p + ".");
+            P = p;
+          }
+        }), c.init = function() {
+          (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+        }, c.prototype.setMaxListeners = function(p) {
+          if (typeof p != "number" || 0 > p || T(p)) throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + p + ".");
+          return this._maxListeners = p, this;
+        }, c.prototype.getMaxListeners = function() {
+          return O(this);
+        }, c.prototype.emit = function(p) {
+          for (var v = [], I = 1; I < arguments.length; I++) v.push(arguments[I]);
+          var B = p === "error", V = this._events;
+          if (V !== void 0) B = B && V.error === void 0;
+          else if (!B) return !1;
+          if (B) {
+            var z;
+            if (0 < v.length && (z = v[0]), z instanceof Error) throw z;
+            var K = /* @__PURE__ */ new Error("Unhandled error." + (z ? " (" + z.message + ")" : ""));
+            throw K.context = z, K;
+          }
+          var Z = V[p];
+          if (Z === void 0) return !1;
+          if (typeof Z == "function") f(Z, this, v);
+          else for (var te = Z.length, H = L(Z, te), I = 0; I < te; ++I) f(H[I], this, v);
+          return !0;
+        }, c.prototype.addListener = function(p, v) {
+          return i(this, p, v, !1);
+        }, c.prototype.on = c.prototype.addListener, c.prototype.prependListener = function(p, v) {
+          return i(this, p, v, !0);
+        }, c.prototype.once = function(p, v) {
+          return S(v), this.on(p, d(this, p, v)), this;
+        }, c.prototype.prependOnceListener = function(p, v) {
+          return S(v), this.prependListener(p, d(this, p, v)), this;
+        }, c.prototype.removeListener = function(p, v) {
+          var I, B, V, z, K;
+          if (S(v), B = this._events, B === void 0) return this;
+          if (I = B[p], I === void 0) return this;
+          if (I === v || I.listener === v) --this._eventsCount == 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete B[p], B.removeListener && this.emit("removeListener", p, I.listener || v));
+          else if (typeof I != "function") {
+            for (V = -1, z = I.length - 1; 0 <= z; z--) if (I[z] === v || I[z].listener === v) {
+              K = I[z].listener, V = z;
+              break;
+            }
+            if (0 > V) return this;
+            V === 0 ? I.shift() : w(I, V), I.length === 1 && (B[p] = I[0]), B.removeListener !== void 0 && this.emit("removeListener", p, K || v);
+          }
+          return this;
+        }, c.prototype.off = c.prototype.removeListener, c.prototype.removeAllListeners = function(p) {
+          var v, I, B;
+          if (I = this._events, I === void 0) return this;
+          if (I.removeListener === void 0) return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : I[p] !== void 0 && (--this._eventsCount == 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete I[p]), this;
+          if (arguments.length === 0) {
+            var V, z = Object.keys(I);
+            for (B = 0; B < z.length; ++B) V = z[B], V !== "removeListener" && this.removeAllListeners(V);
+            return this.removeAllListeners("removeListener"), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
+          }
+          if (v = I[p], typeof v == "function") this.removeListener(p, v);
+          else if (v !== void 0) for (B = v.length - 1; 0 <= B; B--) this.removeListener(p, v[B]);
+          return this;
+        }, c.prototype.listeners = function(p) {
+          return a(this, p, !0);
+        }, c.prototype.rawListeners = function(p) {
+          return a(this, p, !1);
+        }, c.listenerCount = function(p, v) {
+          return typeof p.listenerCount == "function" ? p.listenerCount(v) : g.call(p, v);
+        }, c.prototype.listenerCount = g, c.prototype.eventNames = function() {
+          return 0 < this._eventsCount ? y(this._events) : [];
+        };
+      }, {}],
+      8: [function(R, M) {
+        M.exports = function() {
+          if (typeof globalThis > "u") return null;
+          var _ = {
+            RTCPeerConnection: globalThis.RTCPeerConnection || globalThis.mozRTCPeerConnection || globalThis.webkitRTCPeerConnection,
+            RTCSessionDescription: globalThis.RTCSessionDescription || globalThis.mozRTCSessionDescription || globalThis.webkitRTCSessionDescription,
+            RTCIceCandidate: globalThis.RTCIceCandidate || globalThis.mozRTCIceCandidate || globalThis.webkitRTCIceCandidate
+          };
+          return _.RTCPeerConnection ? _ : null;
+        };
+      }, {}],
+      9: [function(R, M, _) {
+        _.read = function(c, S, O, i, l) {
+          var d, a, g = 8 * l - i - 1, L = (1 << g) - 1, w = L >> 1, b = -7, n = O ? l - 1 : 0, h = O ? -1 : 1, y = c[S + n];
+          for (n += h, d = y & (1 << -b) - 1, y >>= -b, b += g; 0 < b; d = 256 * d + c[S + n], n += h, b -= 8) ;
+          for (a = d & (1 << -b) - 1, d >>= -b, b += i; 0 < b; a = 256 * a + c[S + n], n += h, b -= 8) ;
+          if (d === 0) d = 1 - w;
+          else {
+            if (d === L) return a ? NaN : (y ? -1 : 1) * (1 / 0);
+            a += F(2, i), d -= w;
+          }
+          return (y ? -1 : 1) * a * F(2, d - i);
+        }, _.write = function(c, S, O, i, l, d) {
+          var a, g, L, w = Math.LN2, b = Math.log, n = 8 * d - l - 1, h = (1 << n) - 1, y = h >> 1, k = l === 23 ? F(2, -24) - F(2, -77) : 0, f = i ? 0 : d - 1, T = i ? 1 : -1, P = 0 > S || S === 0 && 0 > 1 / S ? 1 : 0;
+          for (S = U(S), isNaN(S) || S === 1 / 0 ? (g = isNaN(S) ? 1 : 0, a = h) : (a = j(b(S) / w), 1 > S * (L = F(2, -a)) && (a--, L *= 2), S += 1 <= a + y ? k / L : k * F(2, 1 - y), 2 <= S * L && (a++, L /= 2), a + y >= h ? (g = 0, a = h) : 1 <= a + y ? (g = (S * L - 1) * F(2, l), a += y) : (g = S * F(2, y - 1) * F(2, l), a = 0)); 8 <= l; c[O + f] = 255 & g, f += T, g /= 256, l -= 8) ;
+          for (a = a << l | g, n += l; 0 < n; c[O + f] = 255 & a, f += T, a /= 256, n -= 8) ;
+          c[O + f - T] |= 128 * P;
+        };
+      }, {}],
+      10: [function(R, M) {
+        M.exports = typeof Object.create == "function" ? function(_, c) {
+          c && (_.super_ = c, _.prototype = Object.create(c.prototype, { constructor: {
+            value: _,
+            enumerable: !1,
+            writable: !0,
+            configurable: !0
+          } }));
+        } : function(_, c) {
+          if (c) {
+            _.super_ = c;
+            var S = function() {
+            };
+            S.prototype = c.prototype, _.prototype = new S(), _.prototype.constructor = _;
+          }
+        };
+      }, {}],
+      11: [function(R, M) {
+        var _ = Math.round;
+        function c(l) {
+          if (l += "", !(100 < l.length)) {
+            var d = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(l);
+            if (d) {
+              var a = parseFloat(d[1]), g = (d[2] || "ms").toLowerCase();
+              return g === "years" || g === "year" || g === "yrs" || g === "yr" || g === "y" ? 315576e5 * a : g === "weeks" || g === "week" || g === "w" ? 6048e5 * a : g === "days" || g === "day" || g === "d" ? 864e5 * a : g === "hours" || g === "hour" || g === "hrs" || g === "hr" || g === "h" ? 36e5 * a : g === "minutes" || g === "minute" || g === "mins" || g === "min" || g === "m" ? 6e4 * a : g === "seconds" || g === "second" || g === "secs" || g === "sec" || g === "s" ? 1e3 * a : g === "milliseconds" || g === "millisecond" || g === "msecs" || g === "msec" || g === "ms" ? a : void 0;
+            }
+          }
+        }
+        function S(l) {
+          var d = U(l);
+          return 864e5 <= d ? _(l / 864e5) + "d" : 36e5 <= d ? _(l / 36e5) + "h" : 6e4 <= d ? _(l / 6e4) + "m" : 1e3 <= d ? _(l / 1e3) + "s" : l + "ms";
+        }
+        function O(l) {
+          var d = U(l);
+          return 864e5 <= d ? i(l, d, 864e5, "day") : 36e5 <= d ? i(l, d, 36e5, "hour") : 6e4 <= d ? i(l, d, 6e4, "minute") : 1e3 <= d ? i(l, d, 1e3, "second") : l + " ms";
+        }
+        function i(l, d, a, g) {
+          return _(l / a) + " " + g + (d >= 1.5 * a ? "s" : "");
+        }
+        M.exports = function(l, d) {
+          d = d || {};
+          var a = typeof l;
+          if (a == "string" && 0 < l.length) return c(l);
+          if (a === "number" && isFinite(l)) return d.long ? O(l) : S(l);
+          throw new Error("val is not a non-empty string or a valid number. val=" + JSON.stringify(l));
+        };
+      }, {}],
+      12: [function(R, M) {
+        function _() {
+          throw new Error("setTimeout has not been defined");
+        }
+        function c() {
+          throw new Error("clearTimeout has not been defined");
+        }
+        function S(k) {
+          if (g === setTimeout) return setTimeout(k, 0);
+          if ((g === _ || !g) && setTimeout) return g = setTimeout, setTimeout(k, 0);
+          try {
+            return g(k, 0);
+          } catch {
+            try {
+              return g.call(null, k, 0);
+            } catch {
+              return g.call(this, k, 0);
+            }
+          }
+        }
+        function O(k) {
+          if (L === clearTimeout) return clearTimeout(k);
+          if ((L === c || !L) && clearTimeout) return L = clearTimeout, clearTimeout(k);
+          try {
+            return L(k);
+          } catch {
+            try {
+              return L.call(null, k);
+            } catch {
+              return L.call(this, k);
+            }
+          }
+        }
+        function i() {
+          h && b && (h = !1, b.length ? n = b.concat(n) : y = -1, n.length && l());
+        }
+        function l() {
+          if (!h) {
+            var k = S(i);
+            h = !0;
+            for (var f = n.length; f; ) {
+              for (b = n, n = []; ++y < f; ) b && b[y].run();
+              y = -1, f = n.length;
+            }
+            b = null, h = !1, O(k);
+          }
+        }
+        function d(k, f) {
+          this.fun = k, this.array = f;
+        }
+        function a() {
+        }
+        var g, L, w = M.exports = {};
+        (function() {
+          try {
+            g = typeof setTimeout == "function" ? setTimeout : _;
+          } catch {
+            g = _;
+          }
+          try {
+            L = typeof clearTimeout == "function" ? clearTimeout : c;
+          } catch {
+            L = c;
+          }
+        })();
+        var b, n = [], h = !1, y = -1;
+        w.nextTick = function(k) {
+          var f = Array(arguments.length - 1);
+          if (1 < arguments.length) for (var T = 1; T < arguments.length; T++) f[T - 1] = arguments[T];
+          n.push(new d(k, f)), n.length !== 1 || h || S(l);
+        }, d.prototype.run = function() {
+          this.fun.apply(null, this.array);
+        }, w.title = "browser", w.browser = !0, w.env = {}, w.argv = [], w.version = "", w.versions = {}, w.on = a, w.addListener = a, w.once = a, w.off = a, w.removeListener = a, w.removeAllListeners = a, w.emit = a, w.prependListener = a, w.prependOnceListener = a, w.listeners = function() {
+          return [];
+        }, w.binding = function() {
+          throw new Error("process.binding is not supported");
+        }, w.cwd = function() {
+          return "/";
+        }, w.chdir = function() {
+          throw new Error("process.chdir is not supported");
+        }, w.umask = function() {
+          return 0;
+        };
+      }, {}],
+      13: [function(R, M) {
+        (function(_) {
+          (function() {
+            let c;
+            M.exports = typeof queueMicrotask == "function" ? queueMicrotask.bind(typeof window > "u" ? _ : window) : (S) => (c || (c = Promise.resolve())).then(S).catch((O) => setTimeout(() => {
+              throw O;
+            }, 0));
+          }).call(this);
+        }).call(this, typeof global > "u" ? typeof self > "u" ? typeof window > "u" ? {} : window : self : global);
+      }, {}],
+      14: [function(R, M) {
+        (function(_, c) {
+          (function() {
+            "use strict";
+            var S = R("safe-buffer").Buffer, O = c.crypto || c.msCrypto;
+            M.exports = O && O.getRandomValues ? function(i, l) {
+              if (i > 4294967295) throw new RangeError("requested too many random bytes");
+              var d = S.allocUnsafe(i);
+              if (0 < i) if (65536 < i) for (var a = 0; a < i; a += 65536) O.getRandomValues(d.slice(a, a + 65536));
+              else O.getRandomValues(d);
+              return typeof l == "function" ? _.nextTick(function() {
+                l(null, d);
+              }) : d;
+            } : function() {
+              throw new Error(`Secure random number generation is not supported by this browser.
+Use Chrome, Firefox or Internet Explorer 11`);
+            };
+          }).call(this);
+        }).call(this, R("_process"), typeof global > "u" ? typeof self > "u" ? typeof window > "u" ? {} : window : self : global);
+      }, {
+        _process: 12,
+        "safe-buffer": 30
+      }],
+      15: [function(R, M) {
+        "use strict";
+        function _(a, g) {
+          a.prototype = Object.create(g.prototype), a.prototype.constructor = a, a.__proto__ = g;
+        }
+        function c(a, g, L) {
+          function w(n, h, y) {
+            return typeof g == "string" ? g : g(n, h, y);
+          }
+          L || (L = Error);
+          var b = (function(n) {
+            function h(y, k, f) {
+              return n.call(this, w(y, k, f)) || this;
+            }
+            return _(h, n), h;
+          })(L);
+          b.prototype.name = L.name, b.prototype.code = a, d[a] = b;
+        }
+        function S(a, g) {
+          if (Array.isArray(a)) {
+            var L = a.length;
+            return a = a.map(function(w) {
+              return w + "";
+            }), 2 < L ? "one of ".concat(g, " ").concat(a.slice(0, L - 1).join(", "), ", or ") + a[L - 1] : L === 2 ? "one of ".concat(g, " ").concat(a[0], " or ").concat(a[1]) : "of ".concat(g, " ").concat(a[0]);
+          }
+          return "of ".concat(g, " ").concat(a + "");
+        }
+        function O(a, g, L) {
+          return a.substr(!L || 0 > L ? 0 : +L, g.length) === g;
+        }
+        function i(a, g, L) {
+          return (L === void 0 || L > a.length) && (L = a.length), a.substring(L - g.length, L) === g;
+        }
+        function l(a, g, L) {
+          return typeof L != "number" && (L = 0), !(L + g.length > a.length) && a.indexOf(g, L) !== -1;
+        }
+        var d = {};
+        c("ERR_INVALID_OPT_VALUE", function(a, g) {
+          return 'The value "' + g + '" is invalid for option "' + a + '"';
+        }, TypeError), c("ERR_INVALID_ARG_TYPE", function(a, g, L) {
+          var w;
+          typeof g == "string" && O(g, "not ") ? (w = "must not be", g = g.replace(/^not /, "")) : w = "must be";
+          var b;
+          if (i(a, " argument")) b = "The ".concat(a, " ").concat(w, " ").concat(S(g, "type"));
+          else {
+            var n = l(a, ".") ? "property" : "argument";
+            b = 'The "'.concat(a, '" ').concat(n, " ").concat(w, " ").concat(S(g, "type"));
+          }
+          return b += ". Received type ".concat(typeof L), b;
+        }, TypeError), c("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF"), c("ERR_METHOD_NOT_IMPLEMENTED", function(a) {
+          return "The " + a + " method is not implemented";
+        }), c("ERR_STREAM_PREMATURE_CLOSE", "Premature close"), c("ERR_STREAM_DESTROYED", function(a) {
+          return "Cannot call " + a + " after a stream was destroyed";
+        }), c("ERR_MULTIPLE_CALLBACK", "Callback called multiple times"), c("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable"), c("ERR_STREAM_WRITE_AFTER_END", "write after end"), c("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError), c("ERR_UNKNOWN_ENCODING", function(a) {
+          return "Unknown encoding: " + a;
+        }, TypeError), c("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event"), M.exports.codes = d;
+      }, {}],
+      16: [function(R, M) {
+        (function(_) {
+          (function() {
+            "use strict";
+            function c(w) {
+              return this instanceof c ? (l.call(this, w), d.call(this, w), this.allowHalfOpen = !0, void (w && (w.readable === !1 && (this.readable = !1), w.writable === !1 && (this.writable = !1), w.allowHalfOpen === !1 && (this.allowHalfOpen = !1, this.once("end", S))))) : new c(w);
+            }
+            function S() {
+              this._writableState.ended || _.nextTick(O, this);
+            }
+            function O(w) {
+              w.end();
+            }
+            var i = Object.keys || function(w) {
+              var b = [];
+              for (var n in w) b.push(n);
+              return b;
+            };
+            M.exports = c;
+            var l = R("./_stream_readable"), d = R("./_stream_writable");
+            R("inherits")(c, l);
+            for (var a, g = i(d.prototype), L = 0; L < g.length; L++) a = g[L], c.prototype[a] || (c.prototype[a] = d.prototype[a]);
+            Object.defineProperty(c.prototype, "writableHighWaterMark", {
+              enumerable: !1,
+              get: function() {
+                return this._writableState.highWaterMark;
+              }
+            }), Object.defineProperty(c.prototype, "writableBuffer", {
+              enumerable: !1,
+              get: function() {
+                return this._writableState && this._writableState.getBuffer();
+              }
+            }), Object.defineProperty(c.prototype, "writableLength", {
+              enumerable: !1,
+              get: function() {
+                return this._writableState.length;
+              }
+            }), Object.defineProperty(c.prototype, "destroyed", {
+              enumerable: !1,
+              get: function() {
+                return this._readableState !== void 0 && this._writableState !== void 0 && this._readableState.destroyed && this._writableState.destroyed;
+              },
+              set: function(w) {
+                this._readableState === void 0 || this._writableState === void 0 || (this._readableState.destroyed = w, this._writableState.destroyed = w);
+              }
+            });
+          }).call(this);
+        }).call(this, R("_process"));
+      }, {
+        "./_stream_readable": 18,
+        "./_stream_writable": 20,
+        _process: 12,
+        inherits: 10
+      }],
+      17: [function(R, M) {
+        "use strict";
+        function _(S) {
+          return this instanceof _ ? void c.call(this, S) : new _(S);
+        }
+        M.exports = _;
+        var c = R("./_stream_transform");
+        R("inherits")(_, c), _.prototype._transform = function(S, O, i) {
+          i(null, S);
+        };
+      }, {
+        "./_stream_transform": 19,
+        inherits: 10
+      }],
+      18: [function(R, M) {
+        (function(_, c) {
+          (function() {
+            "use strict";
+            function S(s) {
+              return de.from(s);
+            }
+            function O(s) {
+              return de.isBuffer(s) || s instanceof J;
+            }
+            function i(s, o, e) {
+              return typeof s.prependListener == "function" ? s.prependListener(o, e) : void (s._events && s._events[o] ? Array.isArray(s._events[o]) ? s._events[o].unshift(e) : s._events[o] = [e, s._events[o]] : s.on(o, e));
+            }
+            function l(s, o, e) {
+              te = te || R("./_stream_duplex"), s = s || {}, typeof e != "boolean" && (e = o instanceof te), this.objectMode = !!s.objectMode, e && (this.objectMode = this.objectMode || !!s.readableObjectMode), this.highWaterMark = _e(this, s, "readableHighWaterMark", e), this.buffer = new Se(), this.length = 0, this.pipes = null, this.pipesCount = 0, this.flowing = null, this.ended = !1, this.endEmitted = !1, this.reading = !1, this.sync = !0, this.needReadable = !1, this.emittedReadable = !1, this.readableListening = !1, this.resumeScheduled = !1, this.paused = !0, this.emitClose = s.emitClose !== !1, this.autoDestroy = !!s.autoDestroy, this.destroyed = !1, this.defaultEncoding = s.defaultEncoding || "utf8", this.awaitDrain = 0, this.readingMore = !1, this.decoder = null, this.encoding = null, s.encoding && (!ae && (ae = R("string_decoder/").StringDecoder), this.decoder = new ae(s.encoding), this.encoding = s.encoding);
+            }
+            function d(s) {
+              if (te = te || R("./_stream_duplex"), !(this instanceof d)) return new d(s);
+              var o = this instanceof te;
+              this._readableState = new l(s, this, o), this.readable = !0, s && (typeof s.read == "function" && (this._read = s.read), typeof s.destroy == "function" && (this._destroy = s.destroy)), oe.call(this);
+            }
+            function a(s, o, e, t, r) {
+              H("readableAddChunk", o);
+              var u = s._readableState;
+              if (o === null) u.reading = !1, n(s, u);
+              else {
+                var E;
+                if (r || (E = L(u, o)), E) D(s, E);
+                else if (!(u.objectMode || o && 0 < o.length)) t || (u.reading = !1, k(s, u));
+                else if (typeof o == "string" || u.objectMode || Object.getPrototypeOf(o) === de.prototype || (o = S(o)), t) u.endEmitted ? D(s, new A()) : g(s, u, o, !0);
+                else if (u.ended) D(s, new le());
+                else {
+                  if (u.destroyed) return !1;
+                  u.reading = !1, u.decoder && !e ? (o = u.decoder.write(o), u.objectMode || o.length !== 0 ? g(s, u, o, !1) : k(s, u)) : g(s, u, o, !1);
+                }
+              }
+              return !u.ended && (u.length < u.highWaterMark || u.length === 0);
+            }
+            function g(s, o, e, t) {
+              o.flowing && o.length === 0 && !o.sync ? (o.awaitDrain = 0, s.emit("data", e)) : (o.length += o.objectMode ? 1 : e.length, t ? o.buffer.unshift(e) : o.buffer.push(e), o.needReadable && h(s)), k(s, o);
+            }
+            function L(s, o) {
+              var e;
+              return O(o) || typeof o == "string" || o === void 0 || s.objectMode || (e = new ce("chunk", [
+                "string",
+                "Buffer",
+                "Uint8Array"
+              ], o)), e;
+            }
+            function w(s) {
+              return 1073741824 <= s ? s = 1073741824 : (s--, s |= s >>> 1, s |= s >>> 2, s |= s >>> 4, s |= s >>> 8, s |= s >>> 16, s++), s;
+            }
+            function b(s, o) {
+              return 0 >= s || o.length === 0 && o.ended ? 0 : o.objectMode ? 1 : s === s ? (s > o.highWaterMark && (o.highWaterMark = w(s)), s <= o.length ? s : o.ended ? o.length : (o.needReadable = !0, 0)) : o.flowing && o.length ? o.buffer.head.data.length : o.length;
+            }
+            function n(s, o) {
+              if (H("onEofChunk"), !o.ended) {
+                if (o.decoder) {
+                  var e = o.decoder.end();
+                  e && e.length && (o.buffer.push(e), o.length += o.objectMode ? 1 : e.length);
+                }
+                o.ended = !0, o.sync ? h(s) : (o.needReadable = !1, !o.emittedReadable && (o.emittedReadable = !0, y(s)));
+              }
+            }
+            function h(s) {
+              var o = s._readableState;
+              H("emitReadable", o.needReadable, o.emittedReadable), o.needReadable = !1, o.emittedReadable || (H("emitReadable", o.flowing), o.emittedReadable = !0, _.nextTick(y, s));
+            }
+            function y(s) {
+              var o = s._readableState;
+              H("emitReadable_", o.destroyed, o.length, o.ended), !o.destroyed && (o.length || o.ended) && (s.emit("readable"), o.emittedReadable = !1), o.needReadable = !o.flowing && !o.ended && o.length <= o.highWaterMark, B(s);
+            }
+            function k(s, o) {
+              o.readingMore || (o.readingMore = !0, _.nextTick(f, s, o));
+            }
+            function f(s, o) {
+              for (; !o.reading && !o.ended && (o.length < o.highWaterMark || o.flowing && o.length === 0); ) {
+                var e = o.length;
+                if (H("maybeReadMore read 0"), s.read(0), e === o.length) break;
+              }
+              o.readingMore = !1;
+            }
+            function T(s) {
+              return function() {
+                var o = s._readableState;
+                H("pipeOnDrain", o.awaitDrain), o.awaitDrain && o.awaitDrain--, o.awaitDrain === 0 && Ee(s, "data") && (o.flowing = !0, B(s));
+              };
+            }
+            function P(s) {
+              var o = s._readableState;
+              o.readableListening = 0 < s.listenerCount("readable"), o.resumeScheduled && !o.paused ? o.flowing = !0 : 0 < s.listenerCount("data") && s.resume();
+            }
+            function p(s) {
+              H("readable nexttick read 0"), s.read(0);
+            }
+            function v(s, o) {
+              o.resumeScheduled || (o.resumeScheduled = !0, _.nextTick(I, s, o));
+            }
+            function I(s, o) {
+              H("resume", o.reading), o.reading || s.read(0), o.resumeScheduled = !1, s.emit("resume"), B(s), o.flowing && !o.reading && s.read(0);
+            }
+            function B(s) {
+              var o = s._readableState;
+              for (H("flow", o.flowing); o.flowing && s.read() !== null; ) ;
+            }
+            function V(s, o) {
+              if (o.length === 0) return null;
+              var e;
+              return o.objectMode ? e = o.buffer.shift() : !s || s >= o.length ? (e = o.decoder ? o.buffer.join("") : o.buffer.length === 1 ? o.buffer.first() : o.buffer.concat(o.length), o.buffer.clear()) : e = o.buffer.consume(s, o.decoder), e;
+            }
+            function z(s) {
+              var o = s._readableState;
+              H("endReadable", o.endEmitted), o.endEmitted || (o.ended = !0, _.nextTick(K, o, s));
+            }
+            function K(s, o) {
+              if (H("endReadableNT", s.endEmitted, s.length), !s.endEmitted && s.length === 0 && (s.endEmitted = !0, o.readable = !1, o.emit("end"), s.autoDestroy)) {
+                var e = o._writableState;
+                (!e || e.autoDestroy && e.finished) && o.destroy();
+              }
+            }
+            function Z(s, o) {
+              for (var e = 0, t = s.length; e < t; e++) if (s[e] === o) return e;
+              return -1;
+            }
+            M.exports = d;
+            var te;
+            d.ReadableState = l;
+            var H;
+            R("events").EventEmitter;
+            var Ee = function(s, o) {
+              return s.listeners(o).length;
+            }, oe = R("./internal/streams/stream"), de = R("buffer").Buffer, J = c.Uint8Array || function() {
+            }, Q = R("util");
+            H = Q && Q.debuglog ? Q.debuglog("stream") : function() {
+            };
+            var ae, pe, ge, Se = R("./internal/streams/buffer_list"), me = R("./internal/streams/destroy"), _e = R("./internal/streams/state").getHighWaterMark, ye = R("../errors").codes, ce = ye.ERR_INVALID_ARG_TYPE, le = ye.ERR_STREAM_PUSH_AFTER_EOF, C = ye.ERR_METHOD_NOT_IMPLEMENTED, A = ye.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
+            R("inherits")(d, oe);
+            var D = me.errorOrDestroy, W = [
+              "error",
+              "close",
+              "destroy",
+              "pause",
+              "resume"
+            ];
+            Object.defineProperty(d.prototype, "destroyed", {
+              enumerable: !1,
+              get: function() {
+                return this._readableState !== void 0 && this._readableState.destroyed;
+              },
+              set: function(s) {
+                this._readableState && (this._readableState.destroyed = s);
+              }
+            }), d.prototype.destroy = me.destroy, d.prototype._undestroy = me.undestroy, d.prototype._destroy = function(s, o) {
+              o(s);
+            }, d.prototype.push = function(s, o) {
+              var e, t = this._readableState;
+              return t.objectMode ? e = !0 : typeof s == "string" && (o = o || t.defaultEncoding, o !== t.encoding && (s = de.from(s, o), o = ""), e = !0), a(this, s, o, !1, e);
+            }, d.prototype.unshift = function(s) {
+              return a(this, s, null, !0, !1);
+            }, d.prototype.isPaused = function() {
+              return this._readableState.flowing === !1;
+            }, d.prototype.setEncoding = function(s) {
+              ae || (ae = R("string_decoder/").StringDecoder);
+              var o = new ae(s);
+              this._readableState.decoder = o, this._readableState.encoding = this._readableState.decoder.encoding;
+              for (var e = this._readableState.buffer.head, t = ""; e !== null; ) t += o.write(e.data), e = e.next;
+              return this._readableState.buffer.clear(), t !== "" && this._readableState.buffer.push(t), this._readableState.length = t.length, this;
+            }, d.prototype.read = function(s) {
+              H("read", s), s = parseInt(s, 10);
+              var o = this._readableState, e = s;
+              if (s !== 0 && (o.emittedReadable = !1), s === 0 && o.needReadable && ((o.highWaterMark === 0 ? 0 < o.length : o.length >= o.highWaterMark) || o.ended)) return H("read: emitReadable", o.length, o.ended), o.length === 0 && o.ended ? z(this) : h(this), null;
+              if (s = b(s, o), s === 0 && o.ended) return o.length === 0 && z(this), null;
+              var t = o.needReadable;
+              H("need readable", t), (o.length === 0 || o.length - s < o.highWaterMark) && (t = !0, H("length less than watermark", t)), o.ended || o.reading ? (t = !1, H("reading or ended", t)) : t && (H("do read"), o.reading = !0, o.sync = !0, o.length === 0 && (o.needReadable = !0), this._read(o.highWaterMark), o.sync = !1, !o.reading && (s = b(e, o)));
+              var r;
+              return r = 0 < s ? V(s, o) : null, r === null ? (o.needReadable = o.length <= o.highWaterMark, s = 0) : (o.length -= s, o.awaitDrain = 0), o.length === 0 && (!o.ended && (o.needReadable = !0), e !== s && o.ended && z(this)), r !== null && this.emit("data", r), r;
+            }, d.prototype._read = function() {
+              D(this, new C("_read()"));
+            }, d.prototype.pipe = function(s, o) {
+              function e(he, fe) {
+                H("onunpipe"), he === $ && fe && fe.hasUnpiped === !1 && (fe.hasUnpiped = !0, r());
+              }
+              function t() {
+                H("onend"), s.end();
+              }
+              function r() {
+                H("cleanup"), s.removeListener("close", N), s.removeListener("finish", q), s.removeListener("drain", ee), s.removeListener("error", E), s.removeListener("unpipe", e), $.removeListener("end", t), $.removeListener("end", G), $.removeListener("data", u), ve = !0, Y.awaitDrain && (!s._writableState || s._writableState.needDrain) && ee();
+              }
+              function u(he) {
+                H("ondata");
+                var fe = s.write(he);
+                H("dest.write", fe), fe === !1 && ((Y.pipesCount === 1 && Y.pipes === s || 1 < Y.pipesCount && Z(Y.pipes, s) !== -1) && !ve && (H("false write response, pause", Y.awaitDrain), Y.awaitDrain++), $.pause());
+              }
+              function E(he) {
+                H("onerror", he), G(), s.removeListener("error", E), Ee(s, "error") === 0 && D(s, he);
+              }
+              function N() {
+                s.removeListener("finish", q), G();
+              }
+              function q() {
+                H("onfinish"), s.removeListener("close", N), G();
+              }
+              function G() {
+                H("unpipe"), $.unpipe(s);
+              }
+              var $ = this, Y = this._readableState;
+              switch (Y.pipesCount) {
+                case 0:
+                  Y.pipes = s;
+                  break;
+                case 1:
+                  Y.pipes = [Y.pipes, s];
+                  break;
+                default:
+                  Y.pipes.push(s);
+              }
+              Y.pipesCount += 1, H("pipe count=%d opts=%j", Y.pipesCount, o);
+              var X = (!o || o.end !== !1) && s !== _.stdout && s !== _.stderr ? t : G;
+              Y.endEmitted ? _.nextTick(X) : $.once("end", X), s.on("unpipe", e);
+              var ee = T($);
+              s.on("drain", ee);
+              var ve = !1;
+              return $.on("data", u), i(s, "error", E), s.once("close", N), s.once("finish", q), s.emit("pipe", $), Y.flowing || (H("pipe resume"), $.resume()), s;
+            }, d.prototype.unpipe = function(s) {
+              var o = this._readableState, e = { hasUnpiped: !1 };
+              if (o.pipesCount === 0) return this;
+              if (o.pipesCount === 1) return s && s !== o.pipes ? this : (s || (s = o.pipes), o.pipes = null, o.pipesCount = 0, o.flowing = !1, s && s.emit("unpipe", this, e), this);
+              if (!s) {
+                var t = o.pipes, r = o.pipesCount;
+                o.pipes = null, o.pipesCount = 0, o.flowing = !1;
+                for (var u = 0; u < r; u++) t[u].emit("unpipe", this, { hasUnpiped: !1 });
+                return this;
+              }
+              var E = Z(o.pipes, s);
+              return E === -1 ? this : (o.pipes.splice(E, 1), o.pipesCount -= 1, o.pipesCount === 1 && (o.pipes = o.pipes[0]), s.emit("unpipe", this, e), this);
+            }, d.prototype.on = function(s, o) {
+              var e = oe.prototype.on.call(this, s, o), t = this._readableState;
+              return s === "data" ? (t.readableListening = 0 < this.listenerCount("readable"), t.flowing !== !1 && this.resume()) : s == "readable" && !t.endEmitted && !t.readableListening && (t.readableListening = t.needReadable = !0, t.flowing = !1, t.emittedReadable = !1, H("on readable", t.length, t.reading), t.length ? h(this) : !t.reading && _.nextTick(p, this)), e;
+            }, d.prototype.addListener = d.prototype.on, d.prototype.removeListener = function(s, o) {
+              var e = oe.prototype.removeListener.call(this, s, o);
+              return s === "readable" && _.nextTick(P, this), e;
+            }, d.prototype.removeAllListeners = function(s) {
+              var o = oe.prototype.removeAllListeners.apply(this, arguments);
+              return (s === "readable" || s === void 0) && _.nextTick(P, this), o;
+            }, d.prototype.resume = function() {
+              var s = this._readableState;
+              return s.flowing || (H("resume"), s.flowing = !s.readableListening, v(this, s)), s.paused = !1, this;
+            }, d.prototype.pause = function() {
+              return H("call pause flowing=%j", this._readableState.flowing), this._readableState.flowing !== !1 && (H("pause"), this._readableState.flowing = !1, this.emit("pause")), this._readableState.paused = !0, this;
+            }, d.prototype.wrap = function(s) {
+              var o = this, e = this._readableState, t = !1;
+              for (var r in s.on("end", function() {
+                if (H("wrapped end"), e.decoder && !e.ended) {
+                  var E = e.decoder.end();
+                  E && E.length && o.push(E);
+                }
+                o.push(null);
+              }), s.on("data", function(E) {
+                H("wrapped data"), e.decoder && (E = e.decoder.write(E)), !(e.objectMode && E == null) && (e.objectMode || E && E.length) && (o.push(E) || (t = !0, s.pause()));
+              }), s) this[r] === void 0 && typeof s[r] == "function" && (this[r] = /* @__PURE__ */ (function(E) {
+                return function() {
+                  return s[E].apply(s, arguments);
+                };
+              })(r));
+              for (var u = 0; u < W.length; u++) s.on(W[u], this.emit.bind(this, W[u]));
+              return this._read = function(E) {
+                H("wrapped _read", E), t && (t = !1, s.resume());
+              }, this;
+            }, typeof Symbol == "function" && (d.prototype[Symbol.asyncIterator] = function() {
+              return pe === void 0 && (pe = R("./internal/streams/async_iterator")), pe(this);
+            }), Object.defineProperty(d.prototype, "readableHighWaterMark", {
+              enumerable: !1,
+              get: function() {
+                return this._readableState.highWaterMark;
+              }
+            }), Object.defineProperty(d.prototype, "readableBuffer", {
+              enumerable: !1,
+              get: function() {
+                return this._readableState && this._readableState.buffer;
+              }
+            }), Object.defineProperty(d.prototype, "readableFlowing", {
+              enumerable: !1,
+              get: function() {
+                return this._readableState.flowing;
+              },
+              set: function(s) {
+                this._readableState && (this._readableState.flowing = s);
+              }
+            }), d._fromList = V, Object.defineProperty(d.prototype, "readableLength", {
+              enumerable: !1,
+              get: function() {
+                return this._readableState.length;
+              }
+            }), typeof Symbol == "function" && (d.from = function(s, o) {
+              return ge === void 0 && (ge = R("./internal/streams/from")), ge(d, s, o);
+            });
+          }).call(this);
+        }).call(this, R("_process"), typeof global > "u" ? typeof self > "u" ? typeof window > "u" ? {} : window : self : global);
+      }, {
+        "../errors": 15,
+        "./_stream_duplex": 16,
+        "./internal/streams/async_iterator": 21,
+        "./internal/streams/buffer_list": 22,
+        "./internal/streams/destroy": 23,
+        "./internal/streams/from": 25,
+        "./internal/streams/state": 27,
+        "./internal/streams/stream": 28,
+        _process: 12,
+        buffer: 3,
+        events: 7,
+        inherits: 10,
+        "string_decoder/": 31,
+        util: 2
+      }],
+      19: [function(R, M) {
+        "use strict";
+        function _(w, b) {
+          var n = this._transformState;
+          n.transforming = !1;
+          var h = n.writecb;
+          if (h === null) return this.emit("error", new d());
+          n.writechunk = null, n.writecb = null, b != null && this.push(b), h(w);
+          var y = this._readableState;
+          y.reading = !1, (y.needReadable || y.length < y.highWaterMark) && this._read(y.highWaterMark);
+        }
+        function c(w) {
+          return this instanceof c ? (L.call(this, w), this._transformState = {
+            afterTransform: _.bind(this),
+            needTransform: !1,
+            transforming: !1,
+            writecb: null,
+            writechunk: null,
+            writeencoding: null
+          }, this._readableState.needReadable = !0, this._readableState.sync = !1, w && (typeof w.transform == "function" && (this._transform = w.transform), typeof w.flush == "function" && (this._flush = w.flush)), void this.on("prefinish", S)) : new c(w);
+        }
+        function S() {
+          var w = this;
+          typeof this._flush != "function" || this._readableState.destroyed ? O(this, null, null) : this._flush(function(b, n) {
+            O(w, b, n);
+          });
+        }
+        function O(w, b, n) {
+          if (b) return w.emit("error", b);
+          if (n != null && w.push(n), w._writableState.length) throw new g();
+          if (w._transformState.transforming) throw new a();
+          return w.push(null);
+        }
+        M.exports = c;
+        var i = R("../errors").codes, l = i.ERR_METHOD_NOT_IMPLEMENTED, d = i.ERR_MULTIPLE_CALLBACK, a = i.ERR_TRANSFORM_ALREADY_TRANSFORMING, g = i.ERR_TRANSFORM_WITH_LENGTH_0, L = R("./_stream_duplex");
+        R("inherits")(c, L), c.prototype.push = function(w, b) {
+          return this._transformState.needTransform = !1, L.prototype.push.call(this, w, b);
+        }, c.prototype._transform = function(w, b, n) {
+          n(new l("_transform()"));
+        }, c.prototype._write = function(w, b, n) {
+          var h = this._transformState;
+          if (h.writecb = n, h.writechunk = w, h.writeencoding = b, !h.transforming) {
+            var y = this._readableState;
+            (h.needTransform || y.needReadable || y.length < y.highWaterMark) && this._read(y.highWaterMark);
+          }
+        }, c.prototype._read = function() {
+          var w = this._transformState;
+          w.writechunk === null || w.transforming ? w.needTransform = !0 : (w.transforming = !0, this._transform(w.writechunk, w.writeencoding, w.afterTransform));
+        }, c.prototype._destroy = function(w, b) {
+          L.prototype._destroy.call(this, w, function(n) {
+            b(n);
+          });
+        };
+      }, {
+        "../errors": 15,
+        "./_stream_duplex": 16,
+        inherits: 10
+      }],
+      20: [function(R, M) {
+        (function(_, c) {
+          (function() {
+            "use strict";
+            function S(C) {
+              var A = this;
+              this.next = null, this.entry = null, this.finish = function() {
+                z(A, C);
+              };
+            }
+            function O(C) {
+              return H.from(C);
+            }
+            function i(C) {
+              return H.isBuffer(C) || C instanceof Ee;
+            }
+            function l() {
+            }
+            function d(C, A, D) {
+              K = K || R("./_stream_duplex"), C = C || {}, typeof D != "boolean" && (D = A instanceof K), this.objectMode = !!C.objectMode, D && (this.objectMode = this.objectMode || !!C.writableObjectMode), this.highWaterMark = de(this, C, "writableHighWaterMark", D), this.finalCalled = !1, this.needDrain = !1, this.ending = !1, this.ended = !1, this.finished = !1, this.destroyed = !1;
+              var W = C.decodeStrings === !1;
+              this.decodeStrings = !W, this.defaultEncoding = C.defaultEncoding || "utf8", this.length = 0, this.writing = !1, this.corked = 0, this.sync = !0, this.bufferProcessing = !1, this.onwrite = function(s) {
+                k(A, s);
+              }, this.writecb = null, this.writelen = 0, this.bufferedRequest = null, this.lastBufferedRequest = null, this.pendingcb = 0, this.prefinished = !1, this.errorEmitted = !1, this.emitClose = C.emitClose !== !1, this.autoDestroy = !!C.autoDestroy, this.bufferedRequestCount = 0, this.corkedRequestsFree = new S(this);
+            }
+            function a(C) {
+              K = K || R("./_stream_duplex");
+              var A = this instanceof K;
+              return A || le.call(a, this) ? (this._writableState = new d(C, this, A), this.writable = !0, C && (typeof C.write == "function" && (this._write = C.write), typeof C.writev == "function" && (this._writev = C.writev), typeof C.destroy == "function" && (this._destroy = C.destroy), typeof C.final == "function" && (this._final = C.final)), void te.call(this)) : new a(C);
+            }
+            function g(C, A) {
+              var D = new _e();
+              ce(C, D), _.nextTick(A, D);
+            }
+            function L(C, A, D, W) {
+              var s;
+              return D === null ? s = new me() : typeof D != "string" && !A.objectMode && (s = new Q("chunk", ["string", "Buffer"], D)), !s || (ce(C, s), _.nextTick(W, s), !1);
+            }
+            function w(C, A, D) {
+              return C.objectMode || C.decodeStrings === !1 || typeof A != "string" || (A = H.from(A, D)), A;
+            }
+            function b(C, A, D, W, s, o) {
+              if (!D) {
+                var e = w(A, W, s);
+                W !== e && (D = !0, s = "buffer", W = e);
+              }
+              var t = A.objectMode ? 1 : W.length;
+              A.length += t;
+              var r = A.length < A.highWaterMark;
+              if (r || (A.needDrain = !0), A.writing || A.corked) {
+                var u = A.lastBufferedRequest;
+                A.lastBufferedRequest = {
+                  chunk: W,
+                  encoding: s,
+                  isBuf: D,
+                  callback: o,
+                  next: null
+                }, u ? u.next = A.lastBufferedRequest : A.bufferedRequest = A.lastBufferedRequest, A.bufferedRequestCount += 1;
+              } else n(C, A, !1, t, W, s, o);
+              return r;
+            }
+            function n(C, A, D, W, s, o, e) {
+              A.writelen = W, A.writecb = e, A.writing = !0, A.sync = !0, A.destroyed ? A.onwrite(new Se("write")) : D ? C._writev(s, A.onwrite) : C._write(s, o, A.onwrite), A.sync = !1;
+            }
+            function h(C, A, D, W, s) {
+              --A.pendingcb, D ? (_.nextTick(s, W), _.nextTick(B, C, A), C._writableState.errorEmitted = !0, ce(C, W)) : (s(W), C._writableState.errorEmitted = !0, ce(C, W), B(C, A));
+            }
+            function y(C) {
+              C.writing = !1, C.writecb = null, C.length -= C.writelen, C.writelen = 0;
+            }
+            function k(C, A) {
+              var D = C._writableState, W = D.sync, s = D.writecb;
+              if (typeof s != "function") throw new pe();
+              if (y(D), A) h(C, D, W, A, s);
+              else {
+                var o = p(D) || C.destroyed;
+                o || D.corked || D.bufferProcessing || !D.bufferedRequest || P(C, D), W ? _.nextTick(f, C, D, o, s) : f(C, D, o, s);
+              }
+            }
+            function f(C, A, D, W) {
+              D || T(C, A), A.pendingcb--, W(), B(C, A);
+            }
+            function T(C, A) {
+              A.length === 0 && A.needDrain && (A.needDrain = !1, C.emit("drain"));
+            }
+            function P(C, A) {
+              A.bufferProcessing = !0;
+              var D = A.bufferedRequest;
+              if (C._writev && D && D.next) {
+                var W = A.bufferedRequestCount, s = Array(W), o = A.corkedRequestsFree;
+                o.entry = D;
+                for (var e = 0, t = !0; D; ) s[e] = D, D.isBuf || (t = !1), D = D.next, e += 1;
+                s.allBuffers = t, n(C, A, !0, A.length, s, "", o.finish), A.pendingcb++, A.lastBufferedRequest = null, o.next ? (A.corkedRequestsFree = o.next, o.next = null) : A.corkedRequestsFree = new S(A), A.bufferedRequestCount = 0;
+              } else {
+                for (; D; ) {
+                  var r = D.chunk, u = D.encoding, E = D.callback;
+                  if (n(C, A, !1, A.objectMode ? 1 : r.length, r, u, E), D = D.next, A.bufferedRequestCount--, A.writing) break;
+                }
+                D === null && (A.lastBufferedRequest = null);
+              }
+              A.bufferedRequest = D, A.bufferProcessing = !1;
+            }
+            function p(C) {
+              return C.ending && C.length === 0 && C.bufferedRequest === null && !C.finished && !C.writing;
+            }
+            function v(C, A) {
+              C._final(function(D) {
+                A.pendingcb--, D && ce(C, D), A.prefinished = !0, C.emit("prefinish"), B(C, A);
+              });
+            }
+            function I(C, A) {
+              A.prefinished || A.finalCalled || (typeof C._final != "function" || A.destroyed ? (A.prefinished = !0, C.emit("prefinish")) : (A.pendingcb++, A.finalCalled = !0, _.nextTick(v, C, A)));
+            }
+            function B(C, A) {
+              var D = p(A);
+              if (D && (I(C, A), A.pendingcb === 0 && (A.finished = !0, C.emit("finish"), A.autoDestroy))) {
+                var W = C._readableState;
+                (!W || W.autoDestroy && W.endEmitted) && C.destroy();
+              }
+              return D;
+            }
+            function V(C, A, D) {
+              A.ending = !0, B(C, A), D && (A.finished ? _.nextTick(D) : C.once("finish", D)), A.ended = !0, C.writable = !1;
+            }
+            function z(C, A, D) {
+              var W = C.entry;
+              for (C.entry = null; W; ) {
+                var s = W.callback;
+                A.pendingcb--, s(D), W = W.next;
+              }
+              A.corkedRequestsFree.next = C;
+            }
+            M.exports = a;
+            var K;
+            a.WritableState = d;
+            var Z = { deprecate: R("util-deprecate") }, te = R("./internal/streams/stream"), H = R("buffer").Buffer, Ee = c.Uint8Array || function() {
+            }, oe = R("./internal/streams/destroy"), de = R("./internal/streams/state").getHighWaterMark, J = R("../errors").codes, Q = J.ERR_INVALID_ARG_TYPE, ae = J.ERR_METHOD_NOT_IMPLEMENTED, pe = J.ERR_MULTIPLE_CALLBACK, ge = J.ERR_STREAM_CANNOT_PIPE, Se = J.ERR_STREAM_DESTROYED, me = J.ERR_STREAM_NULL_VALUES, _e = J.ERR_STREAM_WRITE_AFTER_END, ye = J.ERR_UNKNOWN_ENCODING, ce = oe.errorOrDestroy;
+            R("inherits")(a, te), d.prototype.getBuffer = function() {
+              for (var C = this.bufferedRequest, A = []; C; ) A.push(C), C = C.next;
+              return A;
+            }, (function() {
+              try {
+                Object.defineProperty(d.prototype, "buffer", { get: Z.deprecate(function() {
+                  return this.getBuffer();
+                }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003") });
+              } catch {
+              }
+            })();
+            var le;
+            typeof Symbol == "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] == "function" ? (le = Function.prototype[Symbol.hasInstance], Object.defineProperty(a, Symbol.hasInstance, { value: function(C) {
+              return !!le.call(this, C) || this === a && C && C._writableState instanceof d;
+            } })) : le = function(C) {
+              return C instanceof this;
+            }, a.prototype.pipe = function() {
+              ce(this, new ge());
+            }, a.prototype.write = function(C, A, D) {
+              var W = this._writableState, s = !1, o = !W.objectMode && i(C);
+              return o && !H.isBuffer(C) && (C = O(C)), typeof A == "function" && (D = A, A = null), o ? A = "buffer" : !A && (A = W.defaultEncoding), typeof D != "function" && (D = l), W.ending ? g(this, D) : (o || L(this, W, C, D)) && (W.pendingcb++, s = b(this, W, o, C, A, D)), s;
+            }, a.prototype.cork = function() {
+              this._writableState.corked++;
+            }, a.prototype.uncork = function() {
+              var C = this._writableState;
+              C.corked && (C.corked--, !C.writing && !C.corked && !C.bufferProcessing && C.bufferedRequest && P(this, C));
+            }, a.prototype.setDefaultEncoding = function(C) {
+              if (typeof C == "string" && (C = C.toLowerCase()), !(-1 < [
+                "hex",
+                "utf8",
+                "utf-8",
+                "ascii",
+                "binary",
+                "base64",
+                "ucs2",
+                "ucs-2",
+                "utf16le",
+                "utf-16le",
+                "raw"
+              ].indexOf((C + "").toLowerCase()))) throw new ye(C);
+              return this._writableState.defaultEncoding = C, this;
+            }, Object.defineProperty(a.prototype, "writableBuffer", {
+              enumerable: !1,
+              get: function() {
+                return this._writableState && this._writableState.getBuffer();
+              }
+            }), Object.defineProperty(a.prototype, "writableHighWaterMark", {
+              enumerable: !1,
+              get: function() {
+                return this._writableState.highWaterMark;
+              }
+            }), a.prototype._write = function(C, A, D) {
+              D(new ae("_write()"));
+            }, a.prototype._writev = null, a.prototype.end = function(C, A, D) {
+              var W = this._writableState;
+              return typeof C == "function" ? (D = C, C = null, A = null) : typeof A == "function" && (D = A, A = null), C != null && this.write(C, A), W.corked && (W.corked = 1, this.uncork()), W.ending || V(this, W, D), this;
+            }, Object.defineProperty(a.prototype, "writableLength", {
+              enumerable: !1,
+              get: function() {
+                return this._writableState.length;
+              }
+            }), Object.defineProperty(a.prototype, "destroyed", {
+              enumerable: !1,
+              get: function() {
+                return this._writableState !== void 0 && this._writableState.destroyed;
+              },
+              set: function(C) {
+                this._writableState && (this._writableState.destroyed = C);
+              }
+            }), a.prototype.destroy = oe.destroy, a.prototype._undestroy = oe.undestroy, a.prototype._destroy = function(C, A) {
+              A(C);
+            };
+          }).call(this);
+        }).call(this, R("_process"), typeof global > "u" ? typeof self > "u" ? typeof window > "u" ? {} : window : self : global);
+      }, {
+        "../errors": 15,
+        "./_stream_duplex": 16,
+        "./internal/streams/destroy": 23,
+        "./internal/streams/state": 27,
+        "./internal/streams/stream": 28,
+        _process: 12,
+        buffer: 3,
+        inherits: 10,
+        "util-deprecate": 32
+      }],
+      21: [function(R, M) {
+        (function(_) {
+          (function() {
+            "use strict";
+            function c(T, P, p) {
+              return P in T ? Object.defineProperty(T, P, {
+                value: p,
+                enumerable: !0,
+                configurable: !0,
+                writable: !0
+              }) : T[P] = p, T;
+            }
+            function S(T, P) {
+              return {
+                value: T,
+                done: P
+              };
+            }
+            function O(T) {
+              var P = T[g];
+              if (P !== null) {
+                var p = T[y].read();
+                p !== null && (T[n] = null, T[g] = null, T[L] = null, P(S(p, !1)));
+              }
+            }
+            function i(T) {
+              _.nextTick(O, T);
+            }
+            function l(T, P) {
+              return function(p, v) {
+                T.then(function() {
+                  P[b] ? p(S(void 0, !0)) : P[h](p, v);
+                }, v);
+              };
+            }
+            var d, a = R("./end-of-stream"), g = /* @__PURE__ */ Symbol("lastResolve"), L = /* @__PURE__ */ Symbol("lastReject"), w = /* @__PURE__ */ Symbol("error"), b = /* @__PURE__ */ Symbol("ended"), n = /* @__PURE__ */ Symbol("lastPromise"), h = /* @__PURE__ */ Symbol("handlePromise"), y = /* @__PURE__ */ Symbol("stream"), k = Object.getPrototypeOf(function() {
+            }), f = Object.setPrototypeOf((d = {
+              get stream() {
+                return this[y];
+              },
+              next: function() {
+                var T = this, P = this[w];
+                if (P !== null) return Promise.reject(P);
+                if (this[b]) return Promise.resolve(S(void 0, !0));
+                if (this[y].destroyed) return new Promise(function(B, V) {
+                  _.nextTick(function() {
+                    T[w] ? V(T[w]) : B(S(void 0, !0));
+                  });
+                });
+                var p, v = this[n];
+                if (v) p = new Promise(l(v, this));
+                else {
+                  var I = this[y].read();
+                  if (I !== null) return Promise.resolve(S(I, !1));
+                  p = new Promise(this[h]);
+                }
+                return this[n] = p, p;
+              }
+            }, c(d, Symbol.asyncIterator, function() {
+              return this;
+            }), c(d, "return", function() {
+              var T = this;
+              return new Promise(function(P, p) {
+                T[y].destroy(null, function(v) {
+                  v ? p(v) : P(S(void 0, !0));
+                });
+              });
+            }), d), k);
+            M.exports = function(T) {
+              var P, p = Object.create(f, (P = {}, c(P, y, {
+                value: T,
+                writable: !0
+              }), c(P, g, {
+                value: null,
+                writable: !0
+              }), c(P, L, {
+                value: null,
+                writable: !0
+              }), c(P, w, {
+                value: null,
+                writable: !0
+              }), c(P, b, {
+                value: T._readableState.endEmitted,
+                writable: !0
+              }), c(P, h, {
+                value: function(v, I) {
+                  var B = p[y].read();
+                  B ? (p[n] = null, p[g] = null, p[L] = null, v(S(B, !1))) : (p[g] = v, p[L] = I);
+                },
+                writable: !0
+              }), P));
+              return p[n] = null, a(T, function(v) {
+                if (v && v.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+                  var I = p[L];
+                  I !== null && (p[n] = null, p[g] = null, p[L] = null, I(v)), p[w] = v;
+                  return;
+                }
+                var B = p[g];
+                B !== null && (p[n] = null, p[g] = null, p[L] = null, B(S(void 0, !0))), p[b] = !0;
+              }), T.on("readable", i.bind(null, p)), p;
+            };
+          }).call(this);
+        }).call(this, R("_process"));
+      }, {
+        "./end-of-stream": 24,
+        _process: 12
+      }],
+      22: [function(R, M) {
+        "use strict";
+        function _(w, b) {
+          var n = Object.keys(w);
+          if (Object.getOwnPropertySymbols) {
+            var h = Object.getOwnPropertySymbols(w);
+            b && (h = h.filter(function(y) {
+              return Object.getOwnPropertyDescriptor(w, y).enumerable;
+            })), n.push.apply(n, h);
+          }
+          return n;
+        }
+        function c(w) {
+          for (var b, n = 1; n < arguments.length; n++) b = arguments[n] == null ? {} : arguments[n], n % 2 ? _(Object(b), !0).forEach(function(h) {
+            S(w, h, b[h]);
+          }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(w, Object.getOwnPropertyDescriptors(b)) : _(Object(b)).forEach(function(h) {
+            Object.defineProperty(w, h, Object.getOwnPropertyDescriptor(b, h));
+          });
+          return w;
+        }
+        function S(w, b, n) {
+          return b in w ? Object.defineProperty(w, b, {
+            value: n,
+            enumerable: !0,
+            configurable: !0,
+            writable: !0
+          }) : w[b] = n, w;
+        }
+        function O(w, b) {
+          if (!(w instanceof b)) throw new TypeError("Cannot call a class as a function");
+        }
+        function i(w, b) {
+          for (var n, h = 0; h < b.length; h++) n = b[h], n.enumerable = n.enumerable || !1, n.configurable = !0, "value" in n && (n.writable = !0), Object.defineProperty(w, n.key, n);
+        }
+        function l(w, b, n) {
+          return b && i(w.prototype, b), n && i(w, n), w;
+        }
+        function d(w, b, n) {
+          a.prototype.copy.call(w, b, n);
+        }
+        var a = R("buffer").Buffer, g = R("util").inspect, L = g && g.custom || "inspect";
+        M.exports = (function() {
+          function w() {
+            O(this, w), this.head = null, this.tail = null, this.length = 0;
+          }
+          return l(w, [
+            {
+              key: "push",
+              value: function(b) {
+                var n = {
+                  data: b,
+                  next: null
+                };
+                0 < this.length ? this.tail.next = n : this.head = n, this.tail = n, ++this.length;
+              }
+            },
+            {
+              key: "unshift",
+              value: function(b) {
+                var n = {
+                  data: b,
+                  next: this.head
+                };
+                this.length === 0 && (this.tail = n), this.head = n, ++this.length;
+              }
+            },
+            {
+              key: "shift",
+              value: function() {
+                if (this.length !== 0) {
+                  var b = this.head.data;
+                  return this.head = this.length === 1 ? this.tail = null : this.head.next, --this.length, b;
+                }
+              }
+            },
+            {
+              key: "clear",
+              value: function() {
+                this.head = this.tail = null, this.length = 0;
+              }
+            },
+            {
+              key: "join",
+              value: function(b) {
+                if (this.length === 0) return "";
+                for (var n = this.head, h = "" + n.data; n = n.next; ) h += b + n.data;
+                return h;
+              }
+            },
+            {
+              key: "concat",
+              value: function(b) {
+                if (this.length === 0) return a.alloc(0);
+                for (var n = a.allocUnsafe(b >>> 0), h = this.head, y = 0; h; ) d(h.data, n, y), y += h.data.length, h = h.next;
+                return n;
+              }
+            },
+            {
+              key: "consume",
+              value: function(b, n) {
+                var h;
+                return b < this.head.data.length ? (h = this.head.data.slice(0, b), this.head.data = this.head.data.slice(b)) : b === this.head.data.length ? h = this.shift() : h = n ? this._getString(b) : this._getBuffer(b), h;
+              }
+            },
+            {
+              key: "first",
+              value: function() {
+                return this.head.data;
+              }
+            },
+            {
+              key: "_getString",
+              value: function(b) {
+                var n = this.head, h = 1, y = n.data;
+                for (b -= y.length; n = n.next; ) {
+                  var k = n.data, f = b > k.length ? k.length : b;
+                  if (y += f === k.length ? k : k.slice(0, b), b -= f, b === 0) {
+                    f === k.length ? (++h, this.head = n.next ? n.next : this.tail = null) : (this.head = n, n.data = k.slice(f));
+                    break;
+                  }
+                  ++h;
+                }
+                return this.length -= h, y;
+              }
+            },
+            {
+              key: "_getBuffer",
+              value: function(b) {
+                var n = a.allocUnsafe(b), h = this.head, y = 1;
+                for (h.data.copy(n), b -= h.data.length; h = h.next; ) {
+                  var k = h.data, f = b > k.length ? k.length : b;
+                  if (k.copy(n, n.length - b, 0, f), b -= f, b === 0) {
+                    f === k.length ? (++y, this.head = h.next ? h.next : this.tail = null) : (this.head = h, h.data = k.slice(f));
+                    break;
+                  }
+                  ++y;
+                }
+                return this.length -= y, n;
+              }
+            },
+            {
+              key: L,
+              value: function(b, n) {
+                return g(this, c({}, n, {
+                  depth: 0,
+                  customInspect: !1
+                }));
+              }
+            }
+          ]), w;
+        })();
+      }, {
+        buffer: 3,
+        util: 2
+      }],
+      23: [function(R, M) {
+        (function(_) {
+          (function() {
+            "use strict";
+            function c(i, l) {
+              O(i, l), S(i);
+            }
+            function S(i) {
+              i._writableState && !i._writableState.emitClose || i._readableState && !i._readableState.emitClose || i.emit("close");
+            }
+            function O(i, l) {
+              i.emit("error", l);
+            }
+            M.exports = {
+              destroy: function(i, l) {
+                var d = this, a = this._readableState && this._readableState.destroyed, g = this._writableState && this._writableState.destroyed;
+                return a || g ? (l ? l(i) : i && (this._writableState ? !this._writableState.errorEmitted && (this._writableState.errorEmitted = !0, _.nextTick(O, this, i)) : _.nextTick(O, this, i)), this) : (this._readableState && (this._readableState.destroyed = !0), this._writableState && (this._writableState.destroyed = !0), this._destroy(i || null, function(L) {
+                  !l && L ? d._writableState ? d._writableState.errorEmitted ? _.nextTick(S, d) : (d._writableState.errorEmitted = !0, _.nextTick(c, d, L)) : _.nextTick(c, d, L) : l ? (_.nextTick(S, d), l(L)) : _.nextTick(S, d);
+                }), this);
+              },
+              undestroy: function() {
+                this._readableState && (this._readableState.destroyed = !1, this._readableState.reading = !1, this._readableState.ended = !1, this._readableState.endEmitted = !1), this._writableState && (this._writableState.destroyed = !1, this._writableState.ended = !1, this._writableState.ending = !1, this._writableState.finalCalled = !1, this._writableState.prefinished = !1, this._writableState.finished = !1, this._writableState.errorEmitted = !1);
+              },
+              errorOrDestroy: function(i, l) {
+                var d = i._readableState, a = i._writableState;
+                d && d.autoDestroy || a && a.autoDestroy ? i.destroy(l) : i.emit("error", l);
+              }
+            };
+          }).call(this);
+        }).call(this, R("_process"));
+      }, { _process: 12 }],
+      24: [function(R, M) {
+        "use strict";
+        function _(l) {
+          var d = !1;
+          return function() {
+            if (!d) {
+              d = !0;
+              for (var a = arguments.length, g = Array(a), L = 0; L < a; L++) g[L] = arguments[L];
+              l.apply(this, g);
+            }
+          };
+        }
+        function c() {
+        }
+        function S(l) {
+          return l.setHeader && typeof l.abort == "function";
+        }
+        function O(l, d, a) {
+          if (typeof d == "function") return O(l, null, d);
+          d || (d = {}), a = _(a || c);
+          var g = d.readable || d.readable !== !1 && l.readable, L = d.writable || d.writable !== !1 && l.writable, w = function() {
+            l.writable || n();
+          }, b = l._writableState && l._writableState.finished, n = function() {
+            L = !1, b = !0, g || a.call(l);
+          }, h = l._readableState && l._readableState.endEmitted, y = function() {
+            g = !1, h = !0, L || a.call(l);
+          }, k = function(P) {
+            a.call(l, P);
+          }, f = function() {
+            var P;
+            return g && !h ? (l._readableState && l._readableState.ended || (P = new i()), a.call(l, P)) : L && !b ? (l._writableState && l._writableState.ended || (P = new i()), a.call(l, P)) : void 0;
+          }, T = function() {
+            l.req.on("finish", n);
+          };
+          return S(l) ? (l.on("complete", n), l.on("abort", f), l.req ? T() : l.on("request", T)) : L && !l._writableState && (l.on("end", w), l.on("close", w)), l.on("end", y), l.on("finish", n), d.error !== !1 && l.on("error", k), l.on("close", f), function() {
+            l.removeListener("complete", n), l.removeListener("abort", f), l.removeListener("request", T), l.req && l.req.removeListener("finish", n), l.removeListener("end", w), l.removeListener("close", w), l.removeListener("finish", n), l.removeListener("end", y), l.removeListener("error", k), l.removeListener("close", f);
+          };
+        }
+        var i = R("../../../errors").codes.ERR_STREAM_PREMATURE_CLOSE;
+        M.exports = O;
+      }, { "../../../errors": 15 }],
+      25: [function(R, M) {
+        M.exports = function() {
+          throw new Error("Readable.from is not available in the browser");
+        };
+      }, {}],
+      26: [function(R, M) {
+        "use strict";
+        function _(b) {
+          var n = !1;
+          return function() {
+            n || (n = !0, b.apply(void 0, arguments));
+          };
+        }
+        function c(b) {
+          if (b) throw b;
+        }
+        function S(b) {
+          return b.setHeader && typeof b.abort == "function";
+        }
+        function O(b, n, h, y) {
+          y = _(y);
+          var k = !1;
+          b.on("close", function() {
+            k = !0;
+          }), a === void 0 && (a = R("./end-of-stream")), a(b, {
+            readable: n,
+            writable: h
+          }, function(T) {
+            return T ? y(T) : (k = !0, void y());
+          });
+          var f = !1;
+          return function(T) {
+            if (!k) return f ? void 0 : (f = !0, S(b) ? b.abort() : typeof b.destroy == "function" ? b.destroy() : void y(T || new w("pipe")));
+          };
+        }
+        function i(b) {
+          b();
+        }
+        function l(b, n) {
+          return b.pipe(n);
+        }
+        function d(b) {
+          return b.length && typeof b[b.length - 1] == "function" ? b.pop() : c;
+        }
+        var a, g = R("../../../errors").codes, L = g.ERR_MISSING_ARGS, w = g.ERR_STREAM_DESTROYED;
+        M.exports = function() {
+          for (var b = arguments.length, n = Array(b), h = 0; h < b; h++) n[h] = arguments[h];
+          var y = d(n);
+          if (Array.isArray(n[0]) && (n = n[0]), 2 > n.length) throw new L("streams");
+          var k, f = n.map(function(T, P) {
+            var p = P < n.length - 1;
+            return O(T, p, 0 < P, function(v) {
+              k || (k = v), v && f.forEach(i), p || (f.forEach(i), y(k));
+            });
+          });
+          return n.reduce(l);
+        };
+      }, {
+        "../../../errors": 15,
+        "./end-of-stream": 24
+      }],
+      27: [function(R, M) {
+        "use strict";
+        function _(S, O, i) {
+          return S.highWaterMark == null ? O ? S[i] : null : S.highWaterMark;
+        }
+        var c = R("../../../errors").codes.ERR_INVALID_OPT_VALUE;
+        M.exports = { getHighWaterMark: function(S, O, i, l) {
+          var d = _(O, l, i);
+          if (d != null) {
+            if (!(isFinite(d) && j(d) === d) || 0 > d) throw new c(l ? i : "highWaterMark", d);
+            return j(d);
+          }
+          return S.objectMode ? 16 : 16384;
+        } };
+      }, { "../../../errors": 15 }],
+      28: [function(R, M) {
+        M.exports = R("events").EventEmitter;
+      }, { events: 7 }],
+      29: [function(R, M, _) {
+        _ = M.exports = R("./lib/_stream_readable.js"), _.Stream = _, _.Readable = _, _.Writable = R("./lib/_stream_writable.js"), _.Duplex = R("./lib/_stream_duplex.js"), _.Transform = R("./lib/_stream_transform.js"), _.PassThrough = R("./lib/_stream_passthrough.js"), _.finished = R("./lib/internal/streams/end-of-stream.js"), _.pipeline = R("./lib/internal/streams/pipeline.js");
+      }, {
+        "./lib/_stream_duplex.js": 16,
+        "./lib/_stream_passthrough.js": 17,
+        "./lib/_stream_readable.js": 18,
+        "./lib/_stream_transform.js": 19,
+        "./lib/_stream_writable.js": 20,
+        "./lib/internal/streams/end-of-stream.js": 24,
+        "./lib/internal/streams/pipeline.js": 26
+      }],
+      30: [function(R, M, _) {
+        function c(l, d) {
+          for (var a in l) d[a] = l[a];
+        }
+        function S(l, d, a) {
+          return i(l, d, a);
+        }
+        var O = R("buffer"), i = O.Buffer;
+        i.from && i.alloc && i.allocUnsafe && i.allocUnsafeSlow ? M.exports = O : (c(O, _), _.Buffer = S), S.prototype = Object.create(i.prototype), c(i, S), S.from = function(l, d, a) {
+          if (typeof l == "number") throw new TypeError("Argument must not be a number");
+          return i(l, d, a);
+        }, S.alloc = function(l, d, a) {
+          if (typeof l != "number") throw new TypeError("Argument must be a number");
+          var g = i(l);
+          return d === void 0 ? g.fill(0) : typeof a == "string" ? g.fill(d, a) : g.fill(d), g;
+        }, S.allocUnsafe = function(l) {
+          if (typeof l != "number") throw new TypeError("Argument must be a number");
+          return i(l);
+        }, S.allocUnsafeSlow = function(l) {
+          if (typeof l != "number") throw new TypeError("Argument must be a number");
+          return O.SlowBuffer(l);
+        };
+      }, { buffer: 3 }],
+      31: [function(R, M, _) {
+        "use strict";
+        function c(f) {
+          if (!f) return "utf8";
+          for (var T; ; ) switch (f) {
+            case "utf8":
+            case "utf-8":
+              return "utf8";
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return "utf16le";
+            case "latin1":
+            case "binary":
+              return "latin1";
+            case "base64":
+            case "ascii":
+            case "hex":
+              return f;
+            default:
+              if (T) return;
+              f = ("" + f).toLowerCase(), T = !0;
+          }
+        }
+        function S(f) {
+          var T = c(f);
+          if (typeof T != "string" && (y.isEncoding === k || !k(f))) throw new Error("Unknown encoding: " + f);
+          return T || f;
+        }
+        function O(f) {
+          this.encoding = S(f);
+          var T;
+          switch (this.encoding) {
+            case "utf16le":
+              this.text = g, this.end = L, T = 4;
+              break;
+            case "utf8":
+              this.fillLast = a, T = 4;
+              break;
+            case "base64":
+              this.text = w, this.end = b, T = 3;
+              break;
+            default:
+              this.write = n, this.end = h;
+              return;
+          }
+          this.lastNeed = 0, this.lastTotal = 0, this.lastChar = y.allocUnsafe(T);
+        }
+        function i(f) {
+          return 127 >= f ? 0 : f >> 5 == 6 ? 2 : f >> 4 == 14 ? 3 : f >> 3 == 30 ? 4 : f >> 6 == 2 ? -1 : -2;
+        }
+        function l(f, T, P) {
+          var p = T.length - 1;
+          if (p < P) return 0;
+          var v = i(T[p]);
+          return 0 <= v ? (0 < v && (f.lastNeed = v - 1), v) : --p < P || v === -2 ? 0 : (v = i(T[p]), 0 <= v ? (0 < v && (f.lastNeed = v - 2), v) : --p < P || v === -2 ? 0 : (v = i(T[p]), 0 <= v ? (0 < v && (v === 2 ? v = 0 : f.lastNeed = v - 3), v) : 0));
+        }
+        function d(f, T) {
+          if ((192 & T[0]) != 128) return f.lastNeed = 0, "�";
+          if (1 < f.lastNeed && 1 < T.length) {
+            if ((192 & T[1]) != 128) return f.lastNeed = 1, "�";
+            if (2 < f.lastNeed && 2 < T.length && (192 & T[2]) != 128) return f.lastNeed = 2, "�";
+          }
+        }
+        function a(f) {
+          var T = this.lastTotal - this.lastNeed, P = d(this, f, T);
+          return P === void 0 ? this.lastNeed <= f.length ? (f.copy(this.lastChar, T, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal)) : (f.copy(this.lastChar, T, 0, f.length), void (this.lastNeed -= f.length)) : P;
+        }
+        function g(f, T) {
+          if ((f.length - T) % 2 == 0) {
+            var P = f.toString("utf16le", T);
+            if (P) {
+              var p = P.charCodeAt(P.length - 1);
+              if (55296 <= p && 56319 >= p) return this.lastNeed = 2, this.lastTotal = 4, this.lastChar[0] = f[f.length - 2], this.lastChar[1] = f[f.length - 1], P.slice(0, -1);
+            }
+            return P;
+          }
+          return this.lastNeed = 1, this.lastTotal = 2, this.lastChar[0] = f[f.length - 1], f.toString("utf16le", T, f.length - 1);
+        }
+        function L(f) {
+          var T = f && f.length ? this.write(f) : "";
+          if (this.lastNeed) {
+            var P = this.lastTotal - this.lastNeed;
+            return T + this.lastChar.toString("utf16le", 0, P);
+          }
+          return T;
+        }
+        function w(f, T) {
+          var P = (f.length - T) % 3;
+          return P == 0 ? f.toString("base64", T) : (this.lastNeed = 3 - P, this.lastTotal = 3, P == 1 ? this.lastChar[0] = f[f.length - 1] : (this.lastChar[0] = f[f.length - 2], this.lastChar[1] = f[f.length - 1]), f.toString("base64", T, f.length - P));
+        }
+        function b(f) {
+          var T = f && f.length ? this.write(f) : "";
+          return this.lastNeed ? T + this.lastChar.toString("base64", 0, 3 - this.lastNeed) : T;
+        }
+        function n(f) {
+          return f.toString(this.encoding);
+        }
+        function h(f) {
+          return f && f.length ? this.write(f) : "";
+        }
+        var y = R("safe-buffer").Buffer, k = y.isEncoding || function(f) {
+          switch (f = "" + f, f && f.toLowerCase()) {
+            case "hex":
+            case "utf8":
+            case "utf-8":
+            case "ascii":
+            case "binary":
+            case "base64":
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+            case "raw":
+              return !0;
+            default:
+              return !1;
+          }
+        };
+        _.StringDecoder = O, O.prototype.write = function(f) {
+          if (f.length === 0) return "";
+          var T, P;
+          if (this.lastNeed) {
+            if (T = this.fillLast(f), T === void 0) return "";
+            P = this.lastNeed, this.lastNeed = 0;
+          } else P = 0;
+          return P < f.length ? T ? T + this.text(f, P) : this.text(f, P) : T || "";
+        }, O.prototype.end = function(f) {
+          var T = f && f.length ? this.write(f) : "";
+          return this.lastNeed ? T + "�" : T;
+        }, O.prototype.text = function(f, T) {
+          var P = l(this, f, T);
+          if (!this.lastNeed) return f.toString("utf8", T);
+          this.lastTotal = P;
+          var p = f.length - (P - this.lastNeed);
+          return f.copy(this.lastChar, 0, p), f.toString("utf8", T, p);
+        }, O.prototype.fillLast = function(f) {
+          return this.lastNeed <= f.length ? (f.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal)) : (f.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, f.length), void (this.lastNeed -= f.length));
+        };
+      }, { "safe-buffer": 30 }],
+      32: [function(R, M) {
+        (function(_) {
+          (function() {
+            function c(S) {
+              try {
+                if (!_.localStorage) return !1;
+              } catch {
+                return !1;
+              }
+              var O = _.localStorage[S];
+              return O != null && (O + "").toLowerCase() === "true";
+            }
+            M.exports = function(S, O) {
+              function i() {
+                if (!l) {
+                  if (c("throwDeprecation")) throw new Error(O);
+                  c("traceDeprecation") ? console.trace(O) : console.warn(O), l = !0;
+                }
+                return S.apply(this, arguments);
+              }
+              if (c("noDeprecation")) return S;
+              var l = !1;
+              return i;
+            };
+          }).call(this);
+        }).call(this, typeof global > "u" ? typeof self > "u" ? typeof window > "u" ? {} : window : self : global);
+      }, {}],
+      "/": [function(R, M) {
+        function _(b) {
+          return b.replace(/a=ice-options:trickle\s\n/g, "");
+        }
+        function c(b) {
+          console.warn(b);
+        }
+        const S = R("debug")("simple-peer"), O = R("get-browser-rtc"), i = R("randombytes"), l = R("readable-stream"), d = R("queue-microtask"), a = R("err-code"), { Buffer: g } = R("buffer"), L = 65536;
+        class w extends l.Duplex {
+          constructor(n) {
+            if (n = Object.assign({ allowHalfOpen: !1 }, n), super(n), this._id = i(4).toString("hex").slice(0, 7), this._debug("new peer %o", n), this.channelName = n.initiator ? n.channelName || i(20).toString("hex") : null, this.initiator = n.initiator || !1, this.channelConfig = n.channelConfig || w.channelConfig, this.channelNegotiated = this.channelConfig.negotiated, this.config = Object.assign({}, w.config, n.config), this.offerOptions = n.offerOptions || {}, this.answerOptions = n.answerOptions || {}, this.sdpTransform = n.sdpTransform || ((h) => h), this.streams = n.streams || (n.stream ? [n.stream] : []), this.trickle = n.trickle === void 0 || n.trickle, this.allowHalfTrickle = n.allowHalfTrickle !== void 0 && n.allowHalfTrickle, this.iceCompleteTimeout = n.iceCompleteTimeout || 5e3, this.destroyed = !1, this.destroying = !1, this._connected = !1, this.remoteAddress = void 0, this.remoteFamily = void 0, this.remotePort = void 0, this.localAddress = void 0, this.localFamily = void 0, this.localPort = void 0, this._wrtc = n.wrtc && typeof n.wrtc == "object" ? n.wrtc : O(), !this._wrtc) throw a(typeof window > "u" ? /* @__PURE__ */ new Error("No WebRTC support: Specify `opts.wrtc` option in this environment") : /* @__PURE__ */ new Error("No WebRTC support: Not a supported browser"), "ERR_WEBRTC_SUPPORT");
+            this._pcReady = !1, this._channelReady = !1, this._iceComplete = !1, this._iceCompleteTimer = null, this._channel = null, this._pendingCandidates = [], this._isNegotiating = !1, this._firstNegotiation = !0, this._batchedNegotiation = !1, this._queuedNegotiation = !1, this._sendersAwaitingStable = [], this._senderMap = /* @__PURE__ */ new Map(), this._closingInterval = null, this._remoteTracks = [], this._remoteStreams = [], this._chunk = null, this._cb = null, this._interval = null;
+            try {
+              this._pc = new this._wrtc.RTCPeerConnection(this.config);
+            } catch (h) {
+              this.destroy(a(h, "ERR_PC_CONSTRUCTOR"));
+              return;
+            }
+            this._isReactNativeWebrtc = typeof this._pc._peerConnectionId == "number", this._pc.oniceconnectionstatechange = () => {
+              this._onIceStateChange();
+            }, this._pc.onicegatheringstatechange = () => {
+              this._onIceStateChange();
+            }, this._pc.onconnectionstatechange = () => {
+              this._onConnectionStateChange();
+            }, this._pc.onsignalingstatechange = () => {
+              this._onSignalingStateChange();
+            }, this._pc.onicecandidate = (h) => {
+              this._onIceCandidate(h);
+            }, typeof this._pc.peerIdentity == "object" && this._pc.peerIdentity.catch((h) => {
+              this.destroy(a(h, "ERR_PC_PEER_IDENTITY"));
+            }), this.initiator || this.channelNegotiated ? this._setupData({ channel: this._pc.createDataChannel(this.channelName, this.channelConfig) }) : this._pc.ondatachannel = (h) => {
+              this._setupData(h);
+            }, this.streams && this.streams.forEach((h) => {
+              this.addStream(h);
+            }), this._pc.ontrack = (h) => {
+              this._onTrack(h);
+            }, this._debug("initial negotiation"), this._needsNegotiation(), this._onFinishBound = () => {
+              this._onFinish();
+            }, this.once("finish", this._onFinishBound);
+          }
+          get bufferSize() {
+            return this._channel && this._channel.bufferedAmount || 0;
+          }
+          get connected() {
+            return this._connected && this._channel.readyState === "open";
+          }
+          address() {
+            return {
+              port: this.localPort,
+              family: this.localFamily,
+              address: this.localAddress
+            };
+          }
+          signal(n) {
+            if (!this.destroying) {
+              if (this.destroyed) throw a(/* @__PURE__ */ new Error("cannot signal after peer is destroyed"), "ERR_DESTROYED");
+              if (typeof n == "string") try {
+                n = JSON.parse(n);
+              } catch {
+                n = {};
+              }
+              this._debug("signal()"), n.renegotiate && this.initiator && (this._debug("got request to renegotiate"), this._needsNegotiation()), n.transceiverRequest && this.initiator && (this._debug("got request for transceiver"), this.addTransceiver(n.transceiverRequest.kind, n.transceiverRequest.init)), n.candidate && (this._pc.remoteDescription && this._pc.remoteDescription.type ? this._addIceCandidate(n.candidate) : this._pendingCandidates.push(n.candidate)), n.sdp && this._pc.setRemoteDescription(new this._wrtc.RTCSessionDescription(n)).then(() => {
+                this.destroyed || (this._pendingCandidates.forEach((h) => {
+                  this._addIceCandidate(h);
+                }), this._pendingCandidates = [], this._pc.remoteDescription.type === "offer" && this._createAnswer());
+              }).catch((h) => {
+                this.destroy(a(h, "ERR_SET_REMOTE_DESCRIPTION"));
+              }), n.sdp || n.candidate || n.renegotiate || n.transceiverRequest || this.destroy(a(/* @__PURE__ */ new Error("signal() called with invalid signal data"), "ERR_SIGNALING"));
+            }
+          }
+          _addIceCandidate(n) {
+            const h = new this._wrtc.RTCIceCandidate(n);
+            this._pc.addIceCandidate(h).catch((y) => {
+              !h.address || h.address.endsWith(".local") ? c("Ignoring unsupported ICE candidate.") : this.destroy(a(y, "ERR_ADD_ICE_CANDIDATE"));
+            });
+          }
+          send(n) {
+            if (!this.destroying) {
+              if (this.destroyed) throw a(/* @__PURE__ */ new Error("cannot send after peer is destroyed"), "ERR_DESTROYED");
+              this._channel.send(n);
+            }
+          }
+          addTransceiver(n, h) {
+            if (!this.destroying) {
+              if (this.destroyed) throw a(/* @__PURE__ */ new Error("cannot addTransceiver after peer is destroyed"), "ERR_DESTROYED");
+              if (this._debug("addTransceiver()"), this.initiator) try {
+                this._pc.addTransceiver(n, h), this._needsNegotiation();
+              } catch (y) {
+                this.destroy(a(y, "ERR_ADD_TRANSCEIVER"));
+              }
+              else this.emit("signal", {
+                type: "transceiverRequest",
+                transceiverRequest: {
+                  kind: n,
+                  init: h
+                }
+              });
+            }
+          }
+          addStream(n) {
+            if (!this.destroying) {
+              if (this.destroyed) throw a(/* @__PURE__ */ new Error("cannot addStream after peer is destroyed"), "ERR_DESTROYED");
+              this._debug("addStream()"), n.getTracks().forEach((h) => {
+                this.addTrack(h, n);
+              });
+            }
+          }
+          addTrack(n, h) {
+            if (this.destroying) return;
+            if (this.destroyed) throw a(/* @__PURE__ */ new Error("cannot addTrack after peer is destroyed"), "ERR_DESTROYED");
+            this._debug("addTrack()");
+            const y = this._senderMap.get(n) || /* @__PURE__ */ new Map();
+            let k = y.get(h);
+            if (!k) k = this._pc.addTrack(n, h), y.set(h, k), this._senderMap.set(n, y), this._needsNegotiation();
+            else throw k.removed ? a(/* @__PURE__ */ new Error("Track has been removed. You should enable/disable tracks that you want to re-add."), "ERR_SENDER_REMOVED") : a(/* @__PURE__ */ new Error("Track has already been added to that stream."), "ERR_SENDER_ALREADY_ADDED");
+          }
+          replaceTrack(n, h, y) {
+            if (this.destroying) return;
+            if (this.destroyed) throw a(/* @__PURE__ */ new Error("cannot replaceTrack after peer is destroyed"), "ERR_DESTROYED");
+            this._debug("replaceTrack()");
+            const k = this._senderMap.get(n), f = k ? k.get(y) : null;
+            if (!f) throw a(/* @__PURE__ */ new Error("Cannot replace track that was never added."), "ERR_TRACK_NOT_ADDED");
+            h && this._senderMap.set(h, k), f.replaceTrack == null ? this.destroy(a(/* @__PURE__ */ new Error("replaceTrack is not supported in this browser"), "ERR_UNSUPPORTED_REPLACETRACK")) : f.replaceTrack(h);
+          }
+          removeTrack(n, h) {
+            if (this.destroying) return;
+            if (this.destroyed) throw a(/* @__PURE__ */ new Error("cannot removeTrack after peer is destroyed"), "ERR_DESTROYED");
+            this._debug("removeSender()");
+            const y = this._senderMap.get(n), k = y ? y.get(h) : null;
+            if (!k) throw a(/* @__PURE__ */ new Error("Cannot remove track that was never added."), "ERR_TRACK_NOT_ADDED");
+            try {
+              k.removed = !0, this._pc.removeTrack(k);
+            } catch (f) {
+              f.name === "NS_ERROR_UNEXPECTED" ? this._sendersAwaitingStable.push(k) : this.destroy(a(f, "ERR_REMOVE_TRACK"));
+            }
+            this._needsNegotiation();
+          }
+          removeStream(n) {
+            if (!this.destroying) {
+              if (this.destroyed) throw a(/* @__PURE__ */ new Error("cannot removeStream after peer is destroyed"), "ERR_DESTROYED");
+              this._debug("removeSenders()"), n.getTracks().forEach((h) => {
+                this.removeTrack(h, n);
+              });
+            }
+          }
+          _needsNegotiation() {
+            this._debug("_needsNegotiation"), this._batchedNegotiation || (this._batchedNegotiation = !0, d(() => {
+              this._batchedNegotiation = !1, this.initiator || !this._firstNegotiation ? (this._debug("starting batched negotiation"), this.negotiate()) : this._debug("non-initiator initial negotiation request discarded"), this._firstNegotiation = !1;
+            }));
+          }
+          negotiate() {
+            if (!this.destroying) {
+              if (this.destroyed) throw a(/* @__PURE__ */ new Error("cannot negotiate after peer is destroyed"), "ERR_DESTROYED");
+              this.initiator ? this._isNegotiating ? (this._queuedNegotiation = !0, this._debug("already negotiating, queueing")) : (this._debug("start negotiation"), setTimeout(() => {
+                this._createOffer();
+              }, 0)) : this._isNegotiating ? (this._queuedNegotiation = !0, this._debug("already negotiating, queueing")) : (this._debug("requesting negotiation from initiator"), this.emit("signal", {
+                type: "renegotiate",
+                renegotiate: !0
+              })), this._isNegotiating = !0;
+            }
+          }
+          destroy(n) {
+            this._destroy(n, () => {
+            });
+          }
+          _destroy(n, h) {
+            this.destroyed || this.destroying || (this.destroying = !0, this._debug("destroying (error: %s)", n && (n.message || n)), d(() => {
+              if (this.destroyed = !0, this.destroying = !1, this._debug("destroy (error: %s)", n && (n.message || n)), this.readable = this.writable = !1, this._readableState.ended || this.push(null), this._writableState.finished || this.end(), this._connected = !1, this._pcReady = !1, this._channelReady = !1, this._remoteTracks = null, this._remoteStreams = null, this._senderMap = null, clearInterval(this._closingInterval), this._closingInterval = null, clearInterval(this._interval), this._interval = null, this._chunk = null, this._cb = null, this._onFinishBound && this.removeListener("finish", this._onFinishBound), this._onFinishBound = null, this._channel) {
+                try {
+                  this._channel.close();
+                } catch {
+                }
+                this._channel.onmessage = null, this._channel.onopen = null, this._channel.onclose = null, this._channel.onerror = null;
+              }
+              if (this._pc) {
+                try {
+                  this._pc.close();
+                } catch {
+                }
+                this._pc.oniceconnectionstatechange = null, this._pc.onicegatheringstatechange = null, this._pc.onsignalingstatechange = null, this._pc.onicecandidate = null, this._pc.ontrack = null, this._pc.ondatachannel = null;
+              }
+              this._pc = null, this._channel = null, n && this.emit("error", n), this.emit("close"), h();
+            }));
+          }
+          _setupData(n) {
+            if (!n.channel) return this.destroy(a(/* @__PURE__ */ new Error("Data channel event is missing `channel` property"), "ERR_DATA_CHANNEL"));
+            this._channel = n.channel, this._channel.binaryType = "arraybuffer", typeof this._channel.bufferedAmountLowThreshold == "number" && (this._channel.bufferedAmountLowThreshold = L), this.channelName = this._channel.label, this._channel.onmessage = (y) => {
+              this._onChannelMessage(y);
+            }, this._channel.onbufferedamountlow = () => {
+              this._onChannelBufferedAmountLow();
+            }, this._channel.onopen = () => {
+              this._onChannelOpen();
+            }, this._channel.onclose = () => {
+              this._onChannelClose();
+            }, this._channel.onerror = (y) => {
+              const k = y.error instanceof Error ? y.error : /* @__PURE__ */ new Error(`Datachannel error: ${y.message} ${y.filename}:${y.lineno}:${y.colno}`);
+              this.destroy(a(k, "ERR_DATA_CHANNEL"));
+            };
+            let h = !1;
+            this._closingInterval = setInterval(() => {
+              this._channel && this._channel.readyState === "closing" ? (h && this._onChannelClose(), h = !0) : h = !1;
+            }, 5e3);
+          }
+          _read() {
+          }
+          _write(n, h, y) {
+            if (this.destroyed) return y(a(/* @__PURE__ */ new Error("cannot write after peer is destroyed"), "ERR_DATA_CHANNEL"));
+            if (this._connected) {
+              try {
+                this.send(n);
+              } catch (k) {
+                return this.destroy(a(k, "ERR_DATA_CHANNEL"));
+              }
+              this._channel.bufferedAmount > L ? (this._debug("start backpressure: bufferedAmount %d", this._channel.bufferedAmount), this._cb = y) : y(null);
+            } else this._debug("write before connect"), this._chunk = n, this._cb = y;
+          }
+          _onFinish() {
+            if (!this.destroyed) {
+              const n = () => {
+                setTimeout(() => this.destroy(), 1e3);
+              };
+              this._connected ? n() : this.once("connect", n);
+            }
+          }
+          _startIceCompleteTimeout() {
+            this.destroyed || this._iceCompleteTimer || (this._debug("started iceComplete timeout"), this._iceCompleteTimer = setTimeout(() => {
+              this._iceComplete || (this._iceComplete = !0, this._debug("iceComplete timeout completed"), this.emit("iceTimeout"), this.emit("_iceComplete"));
+            }, this.iceCompleteTimeout));
+          }
+          _createOffer() {
+            this.destroyed || this._pc.createOffer(this.offerOptions).then((n) => {
+              if (this.destroyed) return;
+              this.trickle || this.allowHalfTrickle || (n.sdp = _(n.sdp)), n.sdp = this.sdpTransform(n.sdp);
+              const h = () => {
+                if (!this.destroyed) {
+                  const y = this._pc.localDescription || n;
+                  this._debug("signal"), this.emit("signal", {
+                    type: y.type,
+                    sdp: y.sdp
+                  });
+                }
+              };
+              this._pc.setLocalDescription(n).then(() => {
+                this._debug("createOffer success"), this.destroyed || (this.trickle || this._iceComplete ? h() : this.once("_iceComplete", h));
+              }).catch((y) => {
+                this.destroy(a(y, "ERR_SET_LOCAL_DESCRIPTION"));
+              });
+            }).catch((n) => {
+              this.destroy(a(n, "ERR_CREATE_OFFER"));
+            });
+          }
+          _requestMissingTransceivers() {
+            this._pc.getTransceivers && this._pc.getTransceivers().forEach((n) => {
+              n.mid || !n.sender.track || n.requested || (n.requested = !0, this.addTransceiver(n.sender.track.kind));
+            });
+          }
+          _createAnswer() {
+            this.destroyed || this._pc.createAnswer(this.answerOptions).then((n) => {
+              if (this.destroyed) return;
+              this.trickle || this.allowHalfTrickle || (n.sdp = _(n.sdp)), n.sdp = this.sdpTransform(n.sdp);
+              const h = () => {
+                if (!this.destroyed) {
+                  const y = this._pc.localDescription || n;
+                  this._debug("signal"), this.emit("signal", {
+                    type: y.type,
+                    sdp: y.sdp
+                  }), this.initiator || this._requestMissingTransceivers();
+                }
+              };
+              this._pc.setLocalDescription(n).then(() => {
+                this.destroyed || (this.trickle || this._iceComplete ? h() : this.once("_iceComplete", h));
+              }).catch((y) => {
+                this.destroy(a(y, "ERR_SET_LOCAL_DESCRIPTION"));
+              });
+            }).catch((n) => {
+              this.destroy(a(n, "ERR_CREATE_ANSWER"));
+            });
+          }
+          _onConnectionStateChange() {
+            this.destroyed || this._pc.connectionState === "failed" && this.destroy(a(/* @__PURE__ */ new Error("Connection failed."), "ERR_CONNECTION_FAILURE"));
+          }
+          _onIceStateChange() {
+            if (this.destroyed) return;
+            const n = this._pc.iceConnectionState, h = this._pc.iceGatheringState;
+            this._debug("iceStateChange (connection: %s) (gathering: %s)", n, h), this.emit("iceStateChange", n, h), (n === "connected" || n === "completed") && (this._pcReady = !0, this._maybeReady()), n === "failed" && this.destroy(a(/* @__PURE__ */ new Error("Ice connection failed."), "ERR_ICE_CONNECTION_FAILURE")), n === "closed" && this.destroy(a(/* @__PURE__ */ new Error("Ice connection closed."), "ERR_ICE_CONNECTION_CLOSED"));
+          }
+          getStats(n) {
+            const h = (y) => (Object.prototype.toString.call(y.values) === "[object Array]" && y.values.forEach((k) => {
+              Object.assign(y, k);
+            }), y);
+            this._pc.getStats.length === 0 || this._isReactNativeWebrtc ? this._pc.getStats().then((y) => {
+              const k = [];
+              y.forEach((f) => {
+                k.push(h(f));
+              }), n(null, k);
+            }, (y) => n(y)) : 0 < this._pc.getStats.length ? this._pc.getStats((y) => {
+              if (this.destroyed) return;
+              const k = [];
+              y.result().forEach((f) => {
+                const T = {};
+                f.names().forEach((P) => {
+                  T[P] = f.stat(P);
+                }), T.id = f.id, T.type = f.type, T.timestamp = f.timestamp, k.push(h(T));
+              }), n(null, k);
+            }, (y) => n(y)) : n(null, []);
+          }
+          _maybeReady() {
+            if (this._debug("maybeReady pc %s channel %s", this._pcReady, this._channelReady), this._connected || this._connecting || !this._pcReady || !this._channelReady) return;
+            this._connecting = !0;
+            const n = () => {
+              this.destroyed || this.getStats((h, y) => {
+                if (this.destroyed) return;
+                h && (y = []);
+                const k = {}, f = {}, T = {};
+                let P = !1;
+                y.forEach((v) => {
+                  (v.type === "remotecandidate" || v.type === "remote-candidate") && (k[v.id] = v), (v.type === "localcandidate" || v.type === "local-candidate") && (f[v.id] = v), (v.type === "candidatepair" || v.type === "candidate-pair") && (T[v.id] = v);
+                });
+                const p = (v) => {
+                  P = !0;
+                  let I = f[v.localCandidateId];
+                  I && (I.ip || I.address) ? (this.localAddress = I.ip || I.address, this.localPort = +I.port) : I && I.ipAddress ? (this.localAddress = I.ipAddress, this.localPort = +I.portNumber) : typeof v.googLocalAddress == "string" && (I = v.googLocalAddress.split(":"), this.localAddress = I[0], this.localPort = +I[1]), this.localAddress && (this.localFamily = this.localAddress.includes(":") ? "IPv6" : "IPv4");
+                  let B = k[v.remoteCandidateId];
+                  B && (B.ip || B.address) ? (this.remoteAddress = B.ip || B.address, this.remotePort = +B.port) : B && B.ipAddress ? (this.remoteAddress = B.ipAddress, this.remotePort = +B.portNumber) : typeof v.googRemoteAddress == "string" && (B = v.googRemoteAddress.split(":"), this.remoteAddress = B[0], this.remotePort = +B[1]), this.remoteAddress && (this.remoteFamily = this.remoteAddress.includes(":") ? "IPv6" : "IPv4"), this._debug("connect local: %s:%s remote: %s:%s", this.localAddress, this.localPort, this.remoteAddress, this.remotePort);
+                };
+                if (y.forEach((v) => {
+                  v.type === "transport" && v.selectedCandidatePairId && p(T[v.selectedCandidatePairId]), (v.type === "googCandidatePair" && v.googActiveConnection === "true" || (v.type === "candidatepair" || v.type === "candidate-pair") && v.selected) && p(v);
+                }), !P && (!Object.keys(T).length || Object.keys(f).length)) return void setTimeout(n, 100);
+                if (this._connecting = !1, this._connected = !0, this._chunk) {
+                  try {
+                    this.send(this._chunk);
+                  } catch (I) {
+                    return this.destroy(a(I, "ERR_DATA_CHANNEL"));
+                  }
+                  this._chunk = null, this._debug('sent chunk from "write before connect"');
+                  const v = this._cb;
+                  this._cb = null, v(null);
+                }
+                typeof this._channel.bufferedAmountLowThreshold != "number" && (this._interval = setInterval(() => this._onInterval(), 150), this._interval.unref && this._interval.unref()), this._debug("connect"), this.emit("connect");
+              });
+            };
+            n();
+          }
+          _onInterval() {
+            this._cb && this._channel && !(this._channel.bufferedAmount > L) && this._onChannelBufferedAmountLow();
+          }
+          _onSignalingStateChange() {
+            this.destroyed || (this._pc.signalingState === "stable" && (this._isNegotiating = !1, this._debug("flushing sender queue", this._sendersAwaitingStable), this._sendersAwaitingStable.forEach((n) => {
+              this._pc.removeTrack(n), this._queuedNegotiation = !0;
+            }), this._sendersAwaitingStable = [], this._queuedNegotiation ? (this._debug("flushing negotiation queue"), this._queuedNegotiation = !1, this._needsNegotiation()) : (this._debug("negotiated"), this.emit("negotiated"))), this._debug("signalingStateChange %s", this._pc.signalingState), this.emit("signalingStateChange", this._pc.signalingState));
+          }
+          _onIceCandidate(n) {
+            this.destroyed || (n.candidate && this.trickle ? this.emit("signal", {
+              type: "candidate",
+              candidate: {
+                candidate: n.candidate.candidate,
+                sdpMLineIndex: n.candidate.sdpMLineIndex,
+                sdpMid: n.candidate.sdpMid
+              }
+            }) : !n.candidate && !this._iceComplete && (this._iceComplete = !0, this.emit("_iceComplete")), n.candidate && this._startIceCompleteTimeout());
+          }
+          _onChannelMessage(n) {
+            if (this.destroyed) return;
+            let h = n.data;
+            h instanceof ArrayBuffer && (h = g.from(h)), this.push(h);
+          }
+          _onChannelBufferedAmountLow() {
+            if (!this.destroyed && this._cb) {
+              this._debug("ending backpressure: bufferedAmount %d", this._channel.bufferedAmount);
+              const n = this._cb;
+              this._cb = null, n(null);
+            }
+          }
+          _onChannelOpen() {
+            this._connected || this.destroyed || (this._debug("on channel open"), this._channelReady = !0, this._maybeReady());
+          }
+          _onChannelClose() {
+            this.destroyed || (this._debug("on channel close"), this.destroy());
+          }
+          _onTrack(n) {
+            this.destroyed || n.streams.forEach((h) => {
+              this._debug("on track"), this.emit("track", n.track, h), this._remoteTracks.push({
+                track: n.track,
+                stream: h
+              }), this._remoteStreams.some((y) => y.id === h.id) || (this._remoteStreams.push(h), d(() => {
+                this._debug("on stream"), this.emit("stream", h);
+              }));
+            });
+          }
+          _debug() {
+            const n = [].slice.call(arguments);
+            n[0] = "[" + this._id + "] " + n[0], S.apply(null, n);
+          }
+        }
+        w.WEBRTC_SUPPORT = !!O(), w.config = {
+          iceServers: [{ urls: ["stun:stun.l.google.com:19302", "stun:global.stun.twilio.com:3478"] }],
+          sdpSemantics: "unified-plan"
+        }, w.channelConfig = {}, M.exports = w;
+      }, {
+        buffer: 3,
+        debug: 4,
+        "err-code": 6,
+        "get-browser-rtc": 8,
+        "queue-microtask": 13,
+        randombytes: 14,
+        "readable-stream": 29
+      }]
+    }, {}, [])("/");
+  });
+})), Ht = /* @__PURE__ */ jt(Wt(), 1), Vt = (m, x) => {
+  const j = ze(m).buffer, U = ze(x).buffer;
+  return crypto.subtle.importKey("raw", j, "PBKDF2", !1, ["deriveKey"]).then((F) => crypto.subtle.deriveKey({
+    name: "PBKDF2",
+    salt: U,
+    iterations: 1e5,
+    hash: "SHA-256"
+  }, F, {
+    name: "AES-GCM",
+    length: 256
+  }, !0, ["encrypt", "decrypt"]));
+}, tt = (m, x) => {
+  if (!x) return We(m);
+  const j = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(12));
+  return crypto.subtle.encrypt({
+    name: "AES-GCM",
+    iv: j
+  }, x, m).then((U) => {
+    const F = re();
+    return Fe(F, "AES-GCM"), Re(F, j), Re(F, new Uint8Array(U)), ie(F);
+  });
+}, Yt = (m, x) => {
+  const j = re();
+  return yt(j, m), tt(ie(j), x);
+}, rt = (m, x) => {
+  if (!x) return We(m);
+  const j = qe(m);
+  Ze(j) !== "AES-GCM" && St(Xe("Unknown encryption algorithm"));
+  const U = De(j), F = De(j);
+  return crypto.subtle.decrypt({
+    name: "AES-GCM",
+    iv: U
+  }, x, F).then((R) => new Uint8Array(R));
+}, zt = (m, x) => rt(m, x).then((j) => At(qe(new Uint8Array(j)))), ne = Rt("y-webrtc"), Ce = 0, nt = 3, Ae = 1, He = 4, Ne = /* @__PURE__ */ new Map(), we = /* @__PURE__ */ new Map(), it = (m) => {
+  let x = !0;
+  m.webrtcConns.forEach((j) => {
+    j.synced || (x = !1);
+  }), (!x && m.synced || x && !m.synced) && (m.synced = x, m.provider.emit("synced", [{ synced: x }]), ne("synced ", ue, m.name, Te, " with all peers"));
+}, st = (m, x, j) => {
+  const U = qe(x), F = re(), R = kt(U);
+  if (m === void 0) return null;
+  const M = m.awareness, _ = m.doc;
+  let c = !1;
+  switch (R) {
+    case Ce: {
+      se(F, Ce);
+      const S = at(U, F, _, m);
+      S === 1 && !m.synced && j(), S === 0 && (c = !0);
+      break;
+    }
+    case nt:
+      se(F, Ae), Re(F, Oe(M, Array.from(M.getStates().keys()))), c = !0;
+      break;
+    case Ae:
+      ht(M, De(U), m);
+      break;
+    case He: {
+      const S = Ot(U) === 1, O = Ze(U);
+      if (O !== m.peerId && (m.bcConns.has(O) && !S || !m.bcConns.has(O) && S)) {
+        const i = [], l = [];
+        S ? (m.bcConns.add(O), l.push(O)) : (m.bcConns.delete(O), i.push(O)), m.provider.emit("peers", [{
+          added: l,
+          removed: i,
+          webrtcPeers: Array.from(m.webrtcConns.keys()),
+          bcPeers: Array.from(m.bcConns)
+        }]), ot(m);
+      }
+      break;
+    }
+    default:
+      return console.error("Unable to compute message"), F;
+  }
+  return c ? F : null;
+}, Gt = (m, x) => {
+  const j = m.room;
+  return ne("received message from ", ue, m.remotePeerId, Qe, " (", j.name, ")", Te, et), st(j, x, () => {
+    m.synced = !0, ne("synced ", ue, j.name, Te, " with ", ue, m.remotePeerId), it(j);
+  });
+}, Ie = (m, x) => {
+  ne("send message to ", ue, m.remotePeerId, Te, Qe, " (", m.room.name, ")", et);
+  try {
+    m.peer.send(ie(x));
+  } catch {
+  }
+}, Kt = (m, x) => {
+  ne("broadcast message in ", ue, m.name, Te), m.webrtcConns.forEach((j) => {
+    try {
+      j.peer.send(x);
+    } catch {
+    }
+  });
+}, Ge = class {
+  constructor(m, x, j, U) {
+    ne("establishing connection to ", ue, j), this.room = U, this.remotePeerId = j, this.glareToken = void 0, this.closed = !1, this.connected = !1, this.synced = !1, this.peer = new Ht.default({
+      initiator: x,
+      ...U.provider.peerOpts
+    }), this.peer.on("signal", (F) => {
+      this.glareToken === void 0 && (this.glareToken = Date.now() + Math.random()), Ve(m, U, {
+        to: j,
+        from: U.peerId,
+        type: "signal",
+        token: this.glareToken,
+        signal: F
+      });
+    }), this.peer.on("connect", () => {
+      ne("connected to ", ue, j), this.connected = !0;
+      const F = U.provider.doc, R = U.awareness, M = re();
+      se(M, Ce), $e(M, F), Ie(this, M);
+      const _ = R.getStates();
+      if (_.size > 0) {
+        const c = re();
+        se(c, Ae), Re(c, Oe(R, Array.from(_.keys()))), Ie(this, c);
+      }
+    }), this.peer.on("close", () => {
+      this.connected = !1, this.closed = !0, U.webrtcConns.has(this.remotePeerId) && (U.webrtcConns.delete(this.remotePeerId), U.provider.emit("peers", [{
+        removed: [this.remotePeerId],
+        added: [],
+        webrtcPeers: Array.from(U.webrtcConns.keys()),
+        bcPeers: Array.from(U.bcConns)
+      }])), it(U), this.peer.destroy(), ne("closed connection to ", ue, j), Ue(U);
+    }), this.peer.on("error", (F) => {
+      ne("Error in connection to ", ue, j, ": ", F), Ue(U);
+    }), this.peer.on("data", (F) => {
+      const R = Gt(this, F);
+      R !== null && Ie(this, R);
+    });
+  }
+  destroy() {
+    this.peer.destroy();
+  }
+}, be = (m, x) => tt(x, m.key).then((j) => m.mux(() => lt(m.name, j))), Ke = (m, x) => {
+  m.bcconnected && be(m, x), Kt(m, x);
+}, Ue = (m) => {
+  Ne.forEach((x) => {
+    x.connected && (x.send({
+      type: "subscribe",
+      topics: [m.name]
+    }), m.webrtcConns.size < m.provider.maxConns && Ve(x, m, {
+      type: "announce",
+      from: m.peerId
+    }));
+  });
+}, ot = (m) => {
+  if (m.provider.filterBcConns) {
+    const x = re();
+    se(x, He), Je(x, 1), Fe(x, m.peerId), be(m, ie(x));
+  }
+}, $t = class {
+  constructor(m, x, j, U) {
+    this.peerId = vt(), this.doc = m, this.awareness = x.awareness, this.provider = x, this.synced = !1, this.name = j, this.key = U, this.webrtcConns = /* @__PURE__ */ new Map(), this.bcConns = /* @__PURE__ */ new Set(), this.mux = qt(), this.bcconnected = !1, this._bcSubscriber = (F) => rt(new Uint8Array(F), U).then((R) => this.mux(() => {
+      const M = st(this, R, () => {
+      });
+      M && be(this, ie(M));
+    })), this._docUpdateHandler = (F, R) => {
+      const M = re();
+      se(M, Ce), ct(M, F), Ke(this, ie(M));
+    }, this._awarenessUpdateHandler = ({ added: F, updated: R, removed: M }, _) => {
+      const c = F.concat(R).concat(M), S = re();
+      se(S, Ae), Re(S, Oe(this.awareness, c)), Ke(this, ie(S));
+    }, this._beforeUnloadHandler = () => {
+      Ye(this.awareness, [m.clientID], "window unload"), we.forEach((F) => {
+        F.disconnect();
+      });
+    }, typeof window < "u" ? window.addEventListener("beforeunload", this._beforeUnloadHandler) : typeof process < "u" && process.on("exit", this._beforeUnloadHandler);
+  }
+  connect() {
+    this.doc.on("update", this._docUpdateHandler), this.awareness.on("update", this._awarenessUpdateHandler), Ue(this);
+    const m = this.name;
+    pt(m, this._bcSubscriber), this.bcconnected = !0, ot(this);
+    const x = re();
+    se(x, Ce), $e(x, this.doc), be(this, ie(x));
+    const j = re();
+    se(j, Ce), ft(j, this.doc), be(this, ie(j));
+    const U = re();
+    se(U, nt), be(this, ie(U));
+    const F = re();
+    se(F, Ae), Re(F, Oe(this.awareness, [this.doc.clientID])), be(this, ie(F));
+  }
+  disconnect() {
+    Ne.forEach((x) => {
+      x.connected && x.send({
+        type: "unsubscribe",
+        topics: [this.name]
+      });
+    }), Ye(this.awareness, [this.doc.clientID], "disconnect");
+    const m = re();
+    se(m, He), Je(m, 0), Fe(m, this.peerId), be(this, ie(m)), ut(this.name, this._bcSubscriber), this.bcconnected = !1, this.doc.off("update", this._docUpdateHandler), this.awareness.off("update", this._awarenessUpdateHandler), this.webrtcConns.forEach((x) => x.destroy());
+  }
+  destroy() {
+    this.disconnect(), typeof window < "u" ? window.removeEventListener("beforeunload", this._beforeUnloadHandler) : typeof process < "u" && process.off("exit", this._beforeUnloadHandler);
+  }
+}, Jt = (m, x, j, U) => {
+  if (we.has(j)) throw Xe(`A Yjs Doc connected to room "${j}" already exists!`);
+  const F = new $t(m, x, j, U);
+  return we.set(j, F), F;
+}, Ve = (m, x, j) => {
+  x.key ? Yt(j, x.key).then((U) => {
+    m.send({
+      type: "publish",
+      topic: x.name,
+      data: Tt(U)
+    });
+  }) : m.send({
+    type: "publish",
+    topic: x.name,
+    data: j
+  });
+}, Xt = class extends Ft {
+  constructor(m) {
+    super(m), this.providers = /* @__PURE__ */ new Set(), this.on("connect", () => {
+      ne(`connected (${m})`);
+      const x = Array.from(we.keys());
+      this.send({
+        type: "subscribe",
+        topics: x
+      }), we.forEach((j) => Ve(this, j, {
+        type: "announce",
+        from: j.peerId
+      }));
+    }), this.on("message", (x) => {
+      switch (x.type) {
+        case "publish": {
+          const j = x.topic, U = we.get(j);
+          if (U == null || typeof j != "string") return;
+          const F = (R) => {
+            const M = U.webrtcConns, _ = U.peerId;
+            if (R == null || R.from === _ || R.to !== void 0 && R.to !== _ || U.bcConns.has(R.from)) return;
+            const c = M.has(R.from) ? () => {
+            } : () => U.provider.emit("peers", [{
+              removed: [],
+              added: [R.from],
+              webrtcPeers: Array.from(U.webrtcConns.keys()),
+              bcPeers: Array.from(U.bcConns)
+            }]);
+            switch (R.type) {
+              case "announce":
+                M.size < U.provider.maxConns && (je(M, R.from, () => new Ge(this, !0, R.from, U)), c());
+                break;
+              case "signal":
+                if (R.signal.type === "offer") {
+                  const S = M.get(R.from);
+                  if (S) {
+                    const O = R.token, i = S.glareToken;
+                    if (i && i > O) {
+                      ne("offer rejected: ", R.from);
+                      return;
+                    }
+                    S.glareToken = void 0;
+                  }
+                }
+                if (R.signal.type === "answer") {
+                  ne("offer answered by: ", R.from);
+                  const S = M.get(R.from);
+                  S.glareToken = void 0;
+                }
+                R.to === _ && (je(M, R.from, () => new Ge(this, !1, R.from, U)).peer.signal(R.signal), c());
+                break;
+            }
+          };
+          U.key ? typeof x.data == "string" && zt(Ct(x.data), U.key).then(F) : F(x.data);
+        }
+      }
+    }), this.on("disconnect", () => ne(`disconnect (${m})`));
+  }
+}, Me = (m) => {
+  m.emit("status", [{ connected: m.connected }]);
+}, tr = class extends Et {
+  constructor(m, x, { signaling: j = ["wss://y-webrtc-eu.fly.dev"], password: U = null, awareness: F = new dt(x), maxConns: R = 20 + bt(_t() * 15), filterBcConns: M = !0, peerOpts: _ = {} } = {}) {
+    super(), this.roomName = m, this.doc = x, this.filterBcConns = M, this.awareness = F, this.shouldConnect = !1, this.signalingUrls = j, this.signalingConns = [], this.maxConns = R, this.peerOpts = _, this.key = U ? Vt(U, m) : We(null), this.room = null, this.key.then((c) => {
+      this.room = Jt(x, this, m, c), this.shouldConnect ? this.room.connect() : this.room.disconnect(), Me(this);
+    }), this.connect(), this.destroy = this.destroy.bind(this), x.on("destroy", this.destroy);
+  }
+  get connected() {
+    return this.room !== null && this.shouldConnect;
+  }
+  connect() {
+    this.shouldConnect = !0, this.signalingUrls.forEach((m) => {
+      const x = je(Ne, m, () => new Xt(m));
+      this.signalingConns.push(x), x.providers.add(this);
+    }), this.room && (this.room.connect(), Me(this));
+  }
+  disconnect() {
+    this.shouldConnect = !1, this.signalingConns.forEach((m) => {
+      m.providers.delete(this), m.providers.size === 0 && (m.destroy(), Ne.delete(m.url));
+    }), this.room && (this.room.disconnect(), Me(this));
+  }
+  destroy() {
+    this.doc.off("destroy", this.destroy), this.key.then(() => {
+      this.room.destroy(), we.delete(this.roomName);
+    }), super.destroy();
+  }
+};
+export {
+  tr as WebrtcProvider,
+  er as t
+};