@rqmii_immersive/agent-react-sdk 5.6.5 → 5.6.6

package/dist/embed/chunks/RqmiiCloudAvatarPlayer-DpvI9bmI.js

@@ -0,0 +1,3357 @@
+import { r as G, j as O, C as W } from "./embed-core-B3d4u3wf.js";
+import { b as dt } from "./mermaid-HWGCJPDP-DD9SRoUR.js";
+var Y = { exports: {} }, le;
+function ct() {
+  return le || (le = 1, (function(a) {
+    const e = {};
+    e.generateIdentifier = function() {
+      return Math.random().toString(36).substring(2, 12);
+    }, e.localCName = e.generateIdentifier(), e.splitLines = function(t) {
+      return t.trim().split(`
+`).map((s) => s.trim());
+    }, e.splitSections = function(t) {
+      return t.split(`
+m=`).map((n, i) => (i > 0 ? "m=" + n : n).trim() + `\r
+`);
+    }, e.getDescription = function(t) {
+      const s = e.splitSections(t);
+      return s && s[0];
+    }, e.getMediaSections = function(t) {
+      const s = e.splitSections(t);
+      return s.shift(), s;
+    }, e.matchPrefix = function(t, s) {
+      return e.splitLines(t).filter((n) => n.indexOf(s) === 0);
+    }, e.parseCandidate = function(t) {
+      let s;
+      t.indexOf("a=candidate:") === 0 ? s = t.substring(12).split(" ") : s = t.substring(10).split(" ");
+      const n = {
+        foundation: s[0],
+        component: { 1: "rtp", 2: "rtcp" }[s[1]] || s[1],
+        protocol: s[2].toLowerCase(),
+        priority: parseInt(s[3], 10),
+        ip: s[4],
+        address: s[4],
+        // address is an alias for ip.
+        port: parseInt(s[5], 10),
+        // skip parts[6] == 'typ'
+        type: s[7]
+      };
+      for (let i = 8; i < s.length; i += 2)
+        switch (s[i]) {
+          case "raddr":
+            n.relatedAddress = s[i + 1];
+            break;
+          case "rport":
+            n.relatedPort = parseInt(s[i + 1], 10);
+            break;
+          case "tcptype":
+            n.tcpType = s[i + 1];
+            break;
+          case "ufrag":
+            n.ufrag = s[i + 1], n.usernameFragment = s[i + 1];
+            break;
+          default:
+            n[s[i]] === void 0 && (n[s[i]] = s[i + 1]);
+            break;
+        }
+      return n;
+    }, e.writeCandidate = function(t) {
+      const s = [];
+      s.push(t.foundation);
+      const n = t.component;
+      n === "rtp" ? s.push(1) : n === "rtcp" ? s.push(2) : s.push(n), s.push(t.protocol.toUpperCase()), s.push(t.priority), s.push(t.address || t.ip), s.push(t.port);
+      const i = t.type;
+      return s.push("typ"), s.push(i), i !== "host" && t.relatedAddress && t.relatedPort !== void 0 && (s.push("raddr"), s.push(t.relatedAddress), s.push("rport"), s.push(t.relatedPort)), t.tcpType && t.protocol.toLowerCase() === "tcp" && (s.push("tcptype"), s.push(t.tcpType)), (t.usernameFragment || t.ufrag) && (s.push("ufrag"), s.push(t.usernameFragment || t.ufrag)), "candidate:" + s.join(" ");
+    }, e.parseIceOptions = function(t) {
+      return t.substring(14).split(" ");
+    }, e.parseRtpMap = function(t) {
+      let s = t.substring(9).split(" ");
+      const n = {
+        payloadType: parseInt(s.shift(), 10)
+        // was: id
+      };
+      return s = s[0].split("/"), n.name = s[0], n.clockRate = parseInt(s[1], 10), n.channels = s.length === 3 ? parseInt(s[2], 10) : 1, n.numChannels = n.channels, n;
+    }, e.writeRtpMap = function(t) {
+      let s = t.payloadType;
+      t.preferredPayloadType !== void 0 && (s = t.preferredPayloadType);
+      const n = t.channels || t.numChannels || 1;
+      return "a=rtpmap:" + s + " " + t.name + "/" + t.clockRate + (n !== 1 ? "/" + n : "") + `\r
+`;
+    }, e.parseExtmap = function(t) {
+      const s = t.substring(9).split(" ");
+      return {
+        id: parseInt(s[0], 10),
+        direction: s[0].indexOf("/") > 0 ? s[0].split("/")[1] : "sendrecv",
+        uri: s[1],
+        attributes: s.slice(2).join(" ")
+      };
+    }, e.writeExtmap = function(t) {
+      return "a=extmap:" + (t.id || t.preferredId) + (t.direction && t.direction !== "sendrecv" ? "/" + t.direction : "") + " " + t.uri + (t.attributes ? " " + t.attributes : "") + `\r
+`;
+    }, e.parseFmtp = function(t) {
+      const s = {};
+      let n;
+      const i = t.substring(t.indexOf(" ") + 1).split(";");
+      for (let o = 0; o < i.length; o++)
+        n = i[o].trim().split("="), s[n[0].trim()] = n[1];
+      return s;
+    }, e.writeFmtp = function(t) {
+      let s = "", n = t.payloadType;
+      if (t.preferredPayloadType !== void 0 && (n = t.preferredPayloadType), t.parameters && Object.keys(t.parameters).length) {
+        const i = [];
+        Object.keys(t.parameters).forEach((o) => {
+          t.parameters[o] !== void 0 ? i.push(o + "=" + t.parameters[o]) : i.push(o);
+        }), s += "a=fmtp:" + n + " " + i.join(";") + `\r
+`;
+      }
+      return s;
+    }, e.parseRtcpFb = function(t) {
+      const s = t.substring(t.indexOf(" ") + 1).split(" ");
+      return {
+        type: s.shift(),
+        parameter: s.join(" ")
+      };
+    }, e.writeRtcpFb = function(t) {
+      let s = "", n = t.payloadType;
+      return t.preferredPayloadType !== void 0 && (n = t.preferredPayloadType), t.rtcpFeedback && t.rtcpFeedback.length && t.rtcpFeedback.forEach((i) => {
+        s += "a=rtcp-fb:" + n + " " + i.type + (i.parameter && i.parameter.length ? " " + i.parameter : "") + `\r
+`;
+      }), s;
+    }, e.parseSsrcMedia = function(t) {
+      const s = t.indexOf(" "), n = {
+        ssrc: parseInt(t.substring(7, s), 10)
+      }, i = t.indexOf(":", s);
+      return i > -1 ? (n.attribute = t.substring(s + 1, i), n.value = t.substring(i + 1)) : n.attribute = t.substring(s + 1), n;
+    }, e.parseSsrcGroup = function(t) {
+      const s = t.substring(13).split(" ");
+      return {
+        semantics: s.shift(),
+        ssrcs: s.map((n) => parseInt(n, 10))
+      };
+    }, e.getMid = function(t) {
+      const s = e.matchPrefix(t, "a=mid:")[0];
+      if (s)
+        return s.substring(6);
+    }, e.parseFingerprint = function(t) {
+      const s = t.substring(14).split(" ");
+      return {
+        algorithm: s[0].toLowerCase(),
+        // algorithm is case-sensitive in Edge.
+        value: s[1].toUpperCase()
+        // the definition is upper-case in RFC 4572.
+      };
+    }, e.getDtlsParameters = function(t, s) {
+      return {
+        role: "auto",
+        fingerprints: e.matchPrefix(
+          t + s,
+          "a=fingerprint:"
+        ).map(e.parseFingerprint)
+      };
+    }, e.writeDtlsParameters = function(t, s) {
+      let n = "a=setup:" + s + `\r
+`;
+      return t.fingerprints.forEach((i) => {
+        n += "a=fingerprint:" + i.algorithm + " " + i.value + `\r
+`;
+      }), n;
+    }, e.parseCryptoLine = function(t) {
+      const s = t.substring(9).split(" ");
+      return {
+        tag: parseInt(s[0], 10),
+        cryptoSuite: s[1],
+        keyParams: s[2],
+        sessionParams: s.slice(3)
+      };
+    }, e.writeCryptoLine = function(t) {
+      return "a=crypto:" + t.tag + " " + t.cryptoSuite + " " + (typeof t.keyParams == "object" ? e.writeCryptoKeyParams(t.keyParams) : t.keyParams) + (t.sessionParams ? " " + t.sessionParams.join(" ") : "") + `\r
+`;
+    }, e.parseCryptoKeyParams = function(t) {
+      if (t.indexOf("inline:") !== 0)
+        return null;
+      const s = t.substring(7).split("|");
+      return {
+        keyMethod: "inline",
+        keySalt: s[0],
+        lifeTime: s[1],
+        mkiValue: s[2] ? s[2].split(":")[0] : void 0,
+        mkiLength: s[2] ? s[2].split(":")[1] : void 0
+      };
+    }, e.writeCryptoKeyParams = function(t) {
+      return t.keyMethod + ":" + t.keySalt + (t.lifeTime ? "|" + t.lifeTime : "") + (t.mkiValue && t.mkiLength ? "|" + t.mkiValue + ":" + t.mkiLength : "");
+    }, e.getCryptoParameters = function(t, s) {
+      return e.matchPrefix(
+        t + s,
+        "a=crypto:"
+      ).map(e.parseCryptoLine);
+    }, e.getIceParameters = function(t, s) {
+      const n = e.matchPrefix(
+        t + s,
+        "a=ice-ufrag:"
+      )[0], i = e.matchPrefix(
+        t + s,
+        "a=ice-pwd:"
+      )[0];
+      return n && i ? {
+        usernameFragment: n.substring(12),
+        password: i.substring(10)
+      } : null;
+    }, e.writeIceParameters = function(t) {
+      let s = "a=ice-ufrag:" + t.usernameFragment + `\r
+a=ice-pwd:` + t.password + `\r
+`;
+      return t.iceLite && (s += `a=ice-lite\r
+`), s;
+    }, e.parseRtpParameters = function(t) {
+      const s = {
+        codecs: [],
+        headerExtensions: [],
+        fecMechanisms: [],
+        rtcp: []
+      }, i = e.splitLines(t)[0].split(" ");
+      s.profile = i[2];
+      for (let d = 3; d < i.length; d++) {
+        const c = i[d], m = e.matchPrefix(
+          t,
+          "a=rtpmap:" + c + " "
+        )[0];
+        if (m) {
+          const u = e.parseRtpMap(m), v = e.matchPrefix(
+            t,
+            "a=fmtp:" + c + " "
+          );
+          switch (u.parameters = v.length ? e.parseFmtp(v[0]) : {}, u.rtcpFeedback = e.matchPrefix(
+            t,
+            "a=rtcp-fb:" + c + " "
+          ).map(e.parseRtcpFb), s.codecs.push(u), u.name.toUpperCase()) {
+            case "RED":
+            case "ULPFEC":
+              s.fecMechanisms.push(u.name.toUpperCase());
+              break;
+          }
+        }
+      }
+      e.matchPrefix(t, "a=extmap:").forEach((d) => {
+        s.headerExtensions.push(e.parseExtmap(d));
+      });
+      const o = e.matchPrefix(t, "a=rtcp-fb:* ").map(e.parseRtcpFb);
+      return s.codecs.forEach((d) => {
+        o.forEach((c) => {
+          d.rtcpFeedback.find((u) => u.type === c.type && u.parameter === c.parameter) || d.rtcpFeedback.push(c);
+        });
+      }), s;
+    }, e.writeRtpDescription = function(t, s) {
+      let n = "";
+      n += "m=" + t + " ", n += s.codecs.length > 0 ? "9" : "0", n += " " + (s.profile || "UDP/TLS/RTP/SAVPF") + " ", n += s.codecs.map((o) => o.preferredPayloadType !== void 0 ? o.preferredPayloadType : o.payloadType).join(" ") + `\r
+`, n += `c=IN IP4 0.0.0.0\r
+`, n += `a=rtcp:9 IN IP4 0.0.0.0\r
+`, s.codecs.forEach((o) => {
+        n += e.writeRtpMap(o), n += e.writeFmtp(o), n += e.writeRtcpFb(o);
+      });
+      let i = 0;
+      return s.codecs.forEach((o) => {
+        o.maxptime > i && (i = o.maxptime);
+      }), i > 0 && (n += "a=maxptime:" + i + `\r
+`), s.headerExtensions && s.headerExtensions.forEach((o) => {
+        n += e.writeExtmap(o);
+      }), n;
+    }, e.parseRtpEncodingParameters = function(t) {
+      const s = [], n = e.parseRtpParameters(t), i = n.fecMechanisms.indexOf("RED") !== -1, o = n.fecMechanisms.indexOf("ULPFEC") !== -1, d = e.matchPrefix(t, "a=ssrc:").map((S) => e.parseSsrcMedia(S)).filter((S) => S.attribute === "cname"), c = d.length > 0 && d[0].ssrc;
+      let m;
+      const u = e.matchPrefix(t, "a=ssrc-group:FID").map((S) => S.substring(17).split(" ").map((P) => parseInt(P, 10)));
+      u.length > 0 && u[0].length > 1 && u[0][0] === c && (m = u[0][1]), n.codecs.forEach((S) => {
+        if (S.name.toUpperCase() === "RTX" && S.parameters.apt) {
+          let y = {
+            ssrc: c,
+            codecPayloadType: parseInt(S.parameters.apt, 10)
+          };
+          c && m && (y.rtx = { ssrc: m }), s.push(y), i && (y = JSON.parse(JSON.stringify(y)), y.fec = {
+            ssrc: c,
+            mechanism: o ? "red+ulpfec" : "red"
+          }, s.push(y));
+        }
+      }), s.length === 0 && c && s.push({
+        ssrc: c
+      });
+      let v = e.matchPrefix(t, "b=");
+      return v.length && (v[0].indexOf("b=TIAS:") === 0 ? v = parseInt(v[0].substring(7), 10) : v[0].indexOf("b=AS:") === 0 ? v = parseInt(v[0].substring(5), 10) * 1e3 * 0.95 - 2e3 * 8 : v = void 0, s.forEach((S) => {
+        S.maxBitrate = v;
+      })), s;
+    }, e.parseRtcpParameters = function(t) {
+      const s = {}, n = e.matchPrefix(t, "a=ssrc:").map((d) => e.parseSsrcMedia(d)).filter((d) => d.attribute === "cname")[0];
+      n && (s.cname = n.value, s.ssrc = n.ssrc);
+      const i = e.matchPrefix(t, "a=rtcp-rsize");
+      s.reducedSize = i.length > 0, s.compound = i.length === 0;
+      const o = e.matchPrefix(t, "a=rtcp-mux");
+      return s.mux = o.length > 0, s;
+    }, e.writeRtcpParameters = function(t) {
+      let s = "";
+      return t.reducedSize && (s += `a=rtcp-rsize\r
+`), t.mux && (s += `a=rtcp-mux\r
+`), t.ssrc !== void 0 && t.cname && (s += "a=ssrc:" + t.ssrc + " cname:" + t.cname + `\r
+`), s;
+    }, e.parseMsid = function(t) {
+      let s;
+      const n = e.matchPrefix(t, "a=msid:");
+      if (n.length === 1)
+        return s = n[0].substring(7).split(" "), { stream: s[0], track: s[1] };
+      const i = e.matchPrefix(t, "a=ssrc:").map((o) => e.parseSsrcMedia(o)).filter((o) => o.attribute === "msid");
+      if (i.length > 0)
+        return s = i[0].value.split(" "), { stream: s[0], track: s[1] };
+    }, e.parseSctpDescription = function(t) {
+      const s = e.parseMLine(t), n = e.matchPrefix(t, "a=max-message-size:");
+      let i;
+      n.length > 0 && (i = parseInt(n[0].substring(19), 10)), isNaN(i) && (i = 65536);
+      const o = e.matchPrefix(t, "a=sctp-port:");
+      if (o.length > 0)
+        return {
+          port: parseInt(o[0].substring(12), 10),
+          protocol: s.fmt,
+          maxMessageSize: i
+        };
+      const d = e.matchPrefix(t, "a=sctpmap:");
+      if (d.length > 0) {
+        const c = d[0].substring(10).split(" ");
+        return {
+          port: parseInt(c[0], 10),
+          protocol: c[1],
+          maxMessageSize: i
+        };
+      }
+    }, e.writeSctpDescription = function(t, s) {
+      let n = [];
+      return t.protocol !== "DTLS/SCTP" ? n = [
+        "m=" + t.kind + " 9 " + t.protocol + " " + s.protocol + `\r
+`,
+        `c=IN IP4 0.0.0.0\r
+`,
+        "a=sctp-port:" + s.port + `\r
+`
+      ] : n = [
+        "m=" + t.kind + " 9 " + t.protocol + " " + s.port + `\r
+`,
+        `c=IN IP4 0.0.0.0\r
+`,
+        "a=sctpmap:" + s.port + " " + s.protocol + ` 65535\r
+`
+      ], s.maxMessageSize !== void 0 && n.push("a=max-message-size:" + s.maxMessageSize + `\r
+`), n.join("");
+    }, e.generateSessionId = function() {
+      return Math.random().toString().substr(2, 22);
+    }, e.writeSessionBoilerplate = function(t, s, n) {
+      let i;
+      const o = s !== void 0 ? s : 2;
+      return t ? i = t : i = e.generateSessionId(), `v=0\r
+o=` + (n || "thisisadapterortc") + " " + i + " " + o + ` IN IP4 127.0.0.1\r
+s=-\r
+t=0 0\r
+`;
+    }, e.getDirection = function(t, s) {
+      const n = e.splitLines(t);
+      for (let i = 0; i < n.length; i++)
+        switch (n[i]) {
+          case "a=sendrecv":
+          case "a=sendonly":
+          case "a=recvonly":
+          case "a=inactive":
+            return n[i].substring(2);
+        }
+      return s ? e.getDirection(s) : "sendrecv";
+    }, e.getKind = function(t) {
+      return e.splitLines(t)[0].split(" ")[0].substring(2);
+    }, e.isRejected = function(t) {
+      return t.split(" ", 2)[1] === "0";
+    }, e.parseMLine = function(t) {
+      const n = e.splitLines(t)[0].substring(2).split(" ");
+      return {
+        kind: n[0],
+        port: parseInt(n[1], 10),
+        protocol: n[2],
+        fmt: n.slice(3).join(" ")
+      };
+    }, e.parseOLine = function(t) {
+      const n = e.matchPrefix(t, "o=")[0].substring(2).split(" ");
+      return {
+        username: n[0],
+        sessionId: n[1],
+        sessionVersion: parseInt(n[2], 10),
+        netType: n[3],
+        addressType: n[4],
+        address: n[5]
+      };
+    }, e.isValidSDP = function(t) {
+      if (typeof t != "string" || t.length === 0)
+        return !1;
+      const s = e.splitLines(t);
+      for (let n = 0; n < s.length; n++)
+        if (s[n].length < 2 || s[n].charAt(1) !== "=")
+          return !1;
+      return !0;
+    }, a.exports = e;
+  })(Y)), Y.exports;
+}
+var de = ct(), F, M, q = { d: (a, e) => {
+  for (var t in e) q.o(e, t) && !q.o(a, t) && Object.defineProperty(a, t, { enumerable: !0, get: e[t] });
+}, o: (a, e) => Object.prototype.hasOwnProperty.call(a, e) }, g = {};
+q.d(g, { Dz: () => Xe, g$: () => Ce, Lt: () => ve, Q9: () => fe, qf: () => re, hV: () => tt, z$: () => ns, J0: () => ae, De: () => xt, $C: () => B, al: () => ke, _W: () => Le, Gv: () => We, m: () => Ne, tz: () => Re, Nu: () => Ze, zg: () => rt, vp: () => je, vU: () => l, wF: () => Be, rv: () => Je, Nh: () => Ye, ss: () => nt, qW: () => Ke, QL: () => He, cf: () => at, eM: () => Ge, Yd: () => r, Tk: () => p, iM: () => me, qy: () => U, ce: () => Tt, sK: () => h, Ok: () => f, q5: () => et, g: () => ss, xl: () => Ie, I: () => Ue, bx: () => ie, dD: () => qe, Ib: () => K, Az: () => E, Iw: () => D, qY: () => ne, db: () => Se, mR: () => N, Tn: () => se, rV: () => ze, gh: () => Fe, Mi: () => Ae, j: () => De, YB: () => Oe, Yt: () => Ve, i5: () => _e, x_: () => I, Am: () => oe, eR: () => Te, r8: () => xe, u3: () => it, vd: () => Ee, iV: () => we, jZ: () => Me, SW: () => Pe, ZH: () => be, Ni: () => ot, lh: () => ye, ZP: () => $e, bq: () => pe, $f: () => lt, eu: () => Qe, Ax: () => bt, Mc: () => wt });
+class r {
+  static GetStackTrace() {
+    const e = new Error();
+    let t = "No Stack Available for this browser";
+    return e.stack && (t = e.stack.toString().replace(/Error/g, "")), t;
+  }
+  static SetLoggerVerbosity(e) {
+    this.verboseLogLevel != null && (this.verboseLogLevel = e);
+  }
+  static Log(e, t, s) {
+    if (s > this.verboseLogLevel) return;
+    const n = `Level: Log
+Msg: ${t}
+Caller: ${e}`;
+    console.log(n);
+  }
+  static Info(e, t, s) {
+    if (s > this.verboseLogLevel) return;
+    const n = `Level: Info
+Msg: ${t}`;
+    console.info(n);
+  }
+  static Error(e, t) {
+    const s = `Level: Error
+Msg: ${t}
+Caller: ${e}`;
+    console.error(s);
+  }
+  static Warning(e, t) {
+    const s = `Level: Warning
+Caller: ${e}
+Msg: ${t}`;
+    console.warn(s);
+  }
+}
+r.verboseLogLevel = 5, (function(a) {
+  a.LIST_STREAMERS = "listStreamers", a.SUBSCRIBE = "subscribe", a.UNSUBSCRIBE = "unsubscribe", a.ICE_CANDIDATE = "iceCandidate", a.OFFER = "offer", a.ANSWER = "answer", a.DATACHANNELREQUEST = "dataChannelRequest", a.SFURECVDATACHANNELREADY = "peerDataChannelsReady", a.PONG = "pong";
+})(F || (F = {}));
+class U {
+  sendFilter(e, t) {
+    return t;
+  }
+  payload() {
+    return r.Log(r.GetStackTrace(), `Sending => 
+` + JSON.stringify(this, this.sendFilter, 4), 6), JSON.stringify(this, this.sendFilter);
+  }
+}
+class ht extends U {
+  constructor() {
+    super(), this.type = F.LIST_STREAMERS;
+  }
+}
+class ut extends U {
+  constructor(e) {
+    super(), this.type = F.SUBSCRIBE, this.streamerId = e;
+  }
+}
+class gt extends U {
+  constructor() {
+    super(), this.type = F.UNSUBSCRIBE;
+  }
+}
+class mt extends U {
+  constructor(e) {
+    super(), this.type = F.PONG, this.time = e;
+  }
+}
+class pt extends U {
+  constructor(e, t) {
+    super(), this.type = F.OFFER, this.minBitrate = 0, this.maxBitrate = 0, e && (this.type = e.type, this.sdp = e.sdp, this.minBitrate = t.minBitrateBps, this.maxBitrate = t.maxBitrateBps);
+  }
+  sendFilter(e, t) {
+    if (e != "minBitrate" && e != "maxBitrate" || !(t <= 0)) return t;
+  }
+}
+class St extends U {
+  constructor(e, t) {
+    super(), this.type = F.ANSWER, this.minBitrate = 0, this.maxBitrate = 0, e && (this.type = e.type, this.sdp = e.sdp, this.minBitrate = t.minBitrateBps, this.maxBitrate = t.maxBitrateBps);
+  }
+  sendFilter(e, t) {
+    if (e != "minBitrate" && e != "maxBitrate" || !(t <= 0)) return t;
+  }
+}
+class vt extends U {
+  constructor() {
+    super(), this.type = F.DATACHANNELREQUEST;
+  }
+}
+class ft extends U {
+  constructor() {
+    super(), this.type = F.SFURECVDATACHANNELREADY;
+  }
+}
+class Ct {
+  constructor(e) {
+    this.type = F.ICE_CANDIDATE, this.candidate = e;
+  }
+  payload() {
+    return r.Log(r.GetStackTrace(), `Sending => 
+` + JSON.stringify(this, void 0, 4), 6), JSON.stringify(this);
+  }
+}
+(function(a) {
+  a.CONFIG = "config", a.STREAMER_LIST = "streamerList", a.STREAMER_ID_CHANGED = "streamerIDChanged", a.PLAYER_COUNT = "playerCount", a.OFFER = "offer", a.ANSWER = "answer", a.ICE_CANDIDATE = "iceCandidate", a.PEER_DATA_CHANNELS = "peerDataChannels", a.PING = "ping", a.WARNING = "warning";
+})(M || (M = {}));
+class me {
+}
+class Tt extends me {
+}
+class se {
+  constructor() {
+    this.FromUEMessageHandlers = /* @__PURE__ */ new Map();
+  }
+  addMessageHandler(e, t) {
+    this.FromUEMessageHandlers.set(e, t);
+  }
+  handleMessage(e, t) {
+    this.FromUEMessageHandlers.has(e) ? this.FromUEMessageHandlers.get(e)(t) : r.Error(r.GetStackTrace(), `Message type of ${e} does not have a message handler registered on the frontend - ignoring message.`);
+  }
+  static setupDefaultHandlers(e) {
+    e.signallingProtocol.addMessageHandler(M.PING, ((t) => {
+      const s = new mt((/* @__PURE__ */ new Date()).getTime()).payload();
+      r.Log(r.GetStackTrace(), M.PING + ": " + t, 6), e.webSocket.send(s);
+    })), e.signallingProtocol.addMessageHandler(M.CONFIG, ((t) => {
+      r.Log(r.GetStackTrace(), M.CONFIG, 6);
+      const s = JSON.parse(t);
+      e.onConfig(s);
+    })), e.signallingProtocol.addMessageHandler(M.STREAMER_LIST, ((t) => {
+      r.Log(r.GetStackTrace(), M.STREAMER_LIST, 6);
+      const s = JSON.parse(t);
+      e.onStreamerList(s);
+    })), e.signallingProtocol.addMessageHandler(M.STREAMER_ID_CHANGED, ((t) => {
+      r.Log(r.GetStackTrace(), M.STREAMER_ID_CHANGED, 6);
+      const s = JSON.parse(t);
+      e.onStreamerIDChanged(s);
+    })), e.signallingProtocol.addMessageHandler(M.PLAYER_COUNT, ((t) => {
+      r.Log(r.GetStackTrace(), M.PLAYER_COUNT, 6);
+      const s = JSON.parse(t);
+      r.Log(r.GetStackTrace(), "Player Count: " + s.count, 6), e.onPlayerCount(s);
+    })), e.signallingProtocol.addMessageHandler(M.ANSWER, ((t) => {
+      r.Log(r.GetStackTrace(), M.ANSWER, 6);
+      const s = JSON.parse(t);
+      e.onWebRtcAnswer(s);
+    })), e.signallingProtocol.addMessageHandler(M.OFFER, ((t) => {
+      r.Log(r.GetStackTrace(), M.OFFER, 6);
+      const s = JSON.parse(t);
+      e.onWebRtcOffer(s);
+    })), e.signallingProtocol.addMessageHandler(M.ICE_CANDIDATE, ((t) => {
+      r.Log(r.GetStackTrace(), M.ICE_CANDIDATE, 6);
+      const s = JSON.parse(t);
+      e.onIceCandidate(s.candidate);
+    })), e.signallingProtocol.addMessageHandler(M.WARNING, ((t) => {
+      r.Warning(r.GetStackTrace(), `Warning received: ${t}`);
+    })), e.signallingProtocol.addMessageHandler(M.PEER_DATA_CHANNELS, ((t) => {
+      r.Log(r.GetStackTrace(), M.PEER_DATA_CHANNELS, 6);
+      const s = JSON.parse(t);
+      e.onWebRtcPeerDataChannels(s);
+    }));
+  }
+}
+class pe {
+  constructor() {
+    this.WS_OPEN_STATE = 1, this.onOpen = new EventTarget(), this.onClose = new EventTarget(), this.signallingProtocol = new se(), se.setupDefaultHandlers(this);
+  }
+  connect(e) {
+    r.Log(r.GetStackTrace(), e, 6);
+    try {
+      return this.webSocket = new WebSocket(e), this.webSocket.onopen = (t) => this.handleOnOpen(t), this.webSocket.onerror = () => this.handleOnError(), this.webSocket.onclose = (t) => this.handleOnClose(t), this.webSocket.onmessage = (t) => this.handleOnMessage(t), this.webSocket.onmessagebinary = (t) => this.handleOnMessageBinary(t), !0;
+    } catch (t) {
+      return r.Error(t, t), !1;
+    }
+  }
+  handleOnMessageBinary(e) {
+    e && e.data && e.data.text().then(((t) => {
+      const s = new MessageEvent("messageFromBinary", { data: t });
+      this.handleOnMessage(s);
+    })).catch(((t) => {
+      r.Error(r.GetStackTrace(), `Failed to parse binary blob from websocket, reason: ${t}`);
+    }));
+  }
+  handleOnMessage(e) {
+    if (e.data && e.data instanceof Blob) return void this.handleOnMessageBinary(e);
+    const t = JSON.parse(e.data);
+    r.Log(r.GetStackTrace(), `received => 
+` + JSON.stringify(JSON.parse(e.data), void 0, 4), 6), this.signallingProtocol.handleMessage(t.type, e.data);
+  }
+  handleOnOpen(e) {
+    r.Log(r.GetStackTrace(), "Connected to the signalling server via WebSocket", 6), this.onOpen.dispatchEvent(new Event("open"));
+  }
+  handleOnError() {
+    r.Error(r.GetStackTrace(), "WebSocket error");
+  }
+  handleOnClose(e) {
+    r.Log(r.GetStackTrace(), "Disconnected to the signalling server via WebSocket: " + JSON.stringify(e.code) + " - " + e.reason), this.onClose.dispatchEvent(new CustomEvent("close", { detail: e }));
+  }
+  requestStreamerList() {
+    const e = new ht();
+    this.webSocket.send(e.payload());
+  }
+  sendSubscribe(e) {
+    const t = new ut(e);
+    this.webSocket.send(t.payload());
+  }
+  sendUnsubscribe() {
+    const e = new gt();
+    this.webSocket.send(e.payload());
+  }
+  sendWebRtcOffer(e, t) {
+    const s = new pt(e, t);
+    this.webSocket.send(s.payload());
+  }
+  sendWebRtcAnswer(e, t) {
+    const s = new St(e, t);
+    this.webSocket.send(s.payload());
+  }
+  sendWebRtcDatachannelRequest() {
+    const e = new vt();
+    this.webSocket.send(e.payload());
+  }
+  sendSFURecvDataChannelReady() {
+    const e = new ft();
+    this.webSocket.send(e.payload());
+  }
+  sendIceCandidate(e) {
+    if (r.Log(r.GetStackTrace(), "Sending Ice Candidate"), this.webSocket && this.webSocket.readyState === this.WS_OPEN_STATE) {
+      const t = new Ct(e);
+      this.webSocket.send(t.payload());
+    }
+  }
+  close() {
+    var e;
+    (e = this.webSocket) === null || e === void 0 || e.close();
+  }
+  onConfig(e) {
+  }
+  onStreamerList(e) {
+  }
+  onStreamerIDChanged(e) {
+  }
+  onIceCandidate(e) {
+  }
+  onWebRtcAnswer(e) {
+  }
+  onWebRtcOffer(e) {
+  }
+  onWebRtcPeerDataChannels(e) {
+  }
+  onPlayerCount(e) {
+  }
+}
+class yt {
+  constructor(e) {
+    this.videoElementProvider = e, this.audioElement = document.createElement("Audio"), this.videoElementProvider.setAudioElement(this.audioElement);
+  }
+  handleOnTrack(e) {
+    if (r.Log(r.GetStackTrace(), "handleOnTrack " + JSON.stringify(e.streams), 6), e.track.id == "probator") return;
+    const t = this.videoElementProvider.getVideoElement();
+    if (e.track && r.Log(r.GetStackTrace(), "Got track - " + e.track.kind + " id=" + e.track.id + " readyState=" + e.track.readyState, 6), e.track.kind != "audio") return e.track.kind == "video" && t.srcObject !== e.streams[0] ? (t.srcObject = e.streams[0], void r.Log(r.GetStackTrace(), "Set video source from video track ontrack.")) : void 0;
+    this.CreateAudioTrack(e.streams[0]);
+  }
+  CreateAudioTrack(e) {
+    const t = this.videoElementProvider.getVideoElement();
+    t.srcObject != e && t.srcObject && t.srcObject !== e && (this.audioElement.srcObject = e, r.Log(r.GetStackTrace(), "Created new audio element to play separate audio stream."));
+  }
+}
+class Et {
+  constructor(e) {
+    this.freezeFrameHeight = 0, this.freezeFrameWidth = 0, this.rootDiv = e, this.rootElement = document.createElement("div"), this.rootElement.id = "freezeFrame", this.rootElement.style.display = "none", this.rootElement.style.pointerEvents = "none", this.rootElement.style.position = "absolute", this.rootElement.style.zIndex = "20", this.imageElement = document.createElement("img"), this.imageElement.style.position = "absolute", this.rootElement.appendChild(this.imageElement), this.rootDiv.appendChild(this.rootElement);
+  }
+  setElementForShow() {
+    this.rootElement.style.display = "block";
+  }
+  setElementForHide() {
+    this.rootElement.style.display = "none";
+  }
+  updateImageElementSource(e) {
+    const t = btoa(e.reduce(((s, n) => s + String.fromCharCode(n)), ""));
+    this.imageElement.src = "data:image/jpeg;base64," + t;
+  }
+  setDimensionsFromElementAndResize() {
+    this.freezeFrameHeight = this.imageElement.naturalHeight, this.freezeFrameWidth = this.imageElement.naturalWidth, this.resize();
+  }
+  resize() {
+    if (this.freezeFrameWidth !== 0 && this.freezeFrameHeight !== 0) {
+      let e = 0, t = 0, s = 0, n = 0;
+      const i = this.rootDiv.clientWidth / this.rootDiv.clientHeight, o = this.freezeFrameWidth / this.freezeFrameHeight;
+      i < o ? (e = this.rootDiv.clientWidth, t = Math.floor(this.rootDiv.clientWidth / o), s = Math.floor(0.5 * (this.rootDiv.clientHeight - t)), n = 0) : (e = Math.floor(this.rootDiv.clientHeight * o), t = this.rootDiv.clientHeight, s = 0, n = Math.floor(0.5 * (this.rootDiv.clientWidth - e))), this.rootElement.style.width = this.rootDiv.offsetWidth + "px", this.rootElement.style.height = this.rootDiv.offsetHeight + "px", this.rootElement.style.left = "0px", this.rootElement.style.top = "0px", this.imageElement.style.width = e + "px", this.imageElement.style.height = t + "px", this.imageElement.style.left = n + "px", this.imageElement.style.top = s + "px";
+    }
+  }
+}
+class Mt {
+  constructor(e) {
+    this.receiving = !1, this.size = 0, this.jpeg = void 0, this.valid = !1, this.freezeFrameDelay = 50, this.freezeFrame = new Et(e);
+  }
+  showFreezeFrame() {
+    this.valid && this.freezeFrame.setElementForShow();
+  }
+  hideFreezeFrame() {
+    this.valid = !1, this.freezeFrame.setElementForHide();
+  }
+  updateFreezeFrameAndShow(e, t) {
+    this.freezeFrame.updateImageElementSource(e), this.freezeFrame.imageElement.onload = () => {
+      this.freezeFrame.setDimensionsFromElementAndResize(), t();
+    };
+  }
+  processFreezeFrameMessage(e, t) {
+    this.receiving || (this.receiving = !0, this.valid = !1, this.size = 0, this.jpeg = void 0), this.size = new DataView(e.slice(1, 5).buffer).getInt32(0, !0);
+    const s = e.slice(5);
+    if (this.jpeg) {
+      const n = new Uint8Array(this.jpeg.length + s.length);
+      n.set(this.jpeg, 0), n.set(s, this.jpeg.length), this.jpeg = n;
+    } else this.jpeg = s, this.receiving = !0, r.Log(r.GetStackTrace(), `received first chunk of freeze frame: ${this.jpeg.length}/${this.size}`, 6);
+    this.jpeg.length === this.size ? (this.receiving = !1, this.valid = !0, r.Log(r.GetStackTrace(), `received complete freeze frame ${this.size}`, 6), this.updateFreezeFrameAndShow(this.jpeg, t)) : this.jpeg.length > this.size && (r.Error(r.GetStackTrace(), `received bigger freeze frame than advertised: ${this.jpeg.length}/${this.size}`), this.jpeg = void 0, this.receiving = !1);
+  }
+}
+class K {
+  constructor(e, t, s, n, i = (() => {
+  })) {
+    this.onChange = i, this.onChangeEmit = () => {
+    }, this.id = e, this.description = s, this.label = t, this.value = n;
+  }
+  set label(e) {
+    this._label = e, this.onChangeEmit(this._value);
+  }
+  get label() {
+    return this._label;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(e) {
+    this._value = e, this.onChange(this._value, this), this.onChangeEmit(this._value);
+  }
+}
+class E extends K {
+  constructor(e, t, s, n, i, o = (() => {
+  })) {
+    super(e, t, s, n, o);
+    const d = new URLSearchParams(window.location.search);
+    if (i && d.has(this.id)) {
+      const c = this.getUrlParamFlag();
+      this.flag = c;
+    } else this.flag = n;
+    this.useUrlParams = i;
+  }
+  getUrlParamFlag() {
+    const e = new URLSearchParams(window.location.search);
+    return !!e.has(this.id) && e.get(this.id) !== "false" && e.get(this.id) !== "False";
+  }
+  updateURLParams() {
+    if (this.useUrlParams) {
+      const e = new URLSearchParams(window.location.search);
+      this.flag === !0 ? e.set(this.id, "true") : e.set(this.id, "false"), window.history.replaceState({}, "", e.toString() !== "" ? `${location.pathname}?${e}` : `${location.pathname}`);
+    }
+  }
+  enable() {
+    this.flag = !0;
+  }
+  get flag() {
+    return !!this.value;
+  }
+  set flag(e) {
+    this.value = e;
+  }
+}
+class D extends K {
+  constructor(e, t, s, n, i, o, d, c = (() => {
+  })) {
+    super(e, t, s, o, c), this._min = n, this._max = i;
+    const m = new URLSearchParams(window.location.search);
+    if (d && m.has(this.id)) {
+      const u = Number.parseFloat(m.get(this.id));
+      this.number = Number.isNaN(u) ? o : u;
+    } else this.number = o;
+    this.useUrlParams = d;
+  }
+  updateURLParams() {
+    if (this.useUrlParams) {
+      const e = new URLSearchParams(window.location.search);
+      e.set(this.id, this.number.toString()), window.history.replaceState({}, "", e.toString() !== "" ? `${location.pathname}?${e}` : `${location.pathname}`);
+    }
+  }
+  set number(e) {
+    this.value = this.clamp(e);
+  }
+  get number() {
+    return this.value;
+  }
+  clamp(e) {
+    return this._min == null && this._max == null ? e : this._min == null ? Math.min(this._max, e) : this._max == null ? Math.max(this._min, e) : Math.max(Math.min(this._max, e), this._min);
+  }
+  get min() {
+    return this._min;
+  }
+  get max() {
+    return this._max;
+  }
+  addOnChangedListener(e) {
+    this.onChange = e;
+  }
+}
+class Se extends K {
+  constructor(e, t, s, n, i, o = (() => {
+  })) {
+    super(e, t, s, n, o);
+    const d = new URLSearchParams(window.location.search);
+    if (i && d.has(this.id)) {
+      const c = this.getUrlParamText();
+      this.text = c;
+    } else this.text = n;
+    this.useUrlParams = i;
+  }
+  getUrlParamText() {
+    var e;
+    const t = new URLSearchParams(window.location.search);
+    return t.has(this.id) && (e = t.get(this.id)) !== null && e !== void 0 ? e : "";
+  }
+  updateURLParams() {
+    if (this.useUrlParams) {
+      const e = new URLSearchParams(window.location.search);
+      e.set(this.id, this.text), window.history.replaceState({}, "", e.toString() !== "" ? `${location.pathname}?${e}` : `${location.pathname}`);
+    }
+  }
+  get text() {
+    return this.value;
+  }
+  set text(e) {
+    this.value = e;
+  }
+}
+class ne extends K {
+  constructor(e, t, s, n, i, o, d = (() => {
+  })) {
+    super(e, t, s, n, d), this.options = i;
+    const c = new URLSearchParams(window.location.search), m = o && c.has(this.id) ? this.getUrlParamText() : n;
+    this.selected = m, this.useUrlParams = o;
+  }
+  getUrlParamText() {
+    var e;
+    const t = new URLSearchParams(window.location.search);
+    return t.has(this.id) && (e = t.get(this.id)) !== null && e !== void 0 ? e : "";
+  }
+  updateURLParams() {
+    if (this.useUrlParams) {
+      const e = new URLSearchParams(window.location.search);
+      e.set(this.id, this.selected), window.history.replaceState({}, "", e.toString() !== "" ? `${location.pathname}?${e}` : `${location.pathname}`);
+    }
+  }
+  addOnChangedListener(e) {
+    this.onChange = e;
+  }
+  get options() {
+    return this._options;
+  }
+  set options(e) {
+    this._options = e, this.onChangeEmit(this.selected);
+  }
+  get selected() {
+    return this.value;
+  }
+  set selected(e) {
+    let t = this.options.filter(((s) => s.indexOf(e) !== -1));
+    t.length ? this.value = t[0] : (t = this.options.filter(((s) => s.indexOf(e.split(" ")[0]) !== -1)), t.length && (this.value = t[0]));
+  }
+}
+class ve extends Event {
+  constructor(e) {
+    super("afkWarningActivate"), this.data = e;
+  }
+}
+class re extends Event {
+  constructor(e) {
+    super("afkWarningUpdate"), this.data = e;
+  }
+}
+class fe extends Event {
+  constructor() {
+    super("afkWarningDeactivate");
+  }
+}
+class Ce extends Event {
+  constructor() {
+    super("afkTimedOut");
+  }
+}
+class Te extends Event {
+  constructor(e) {
+    super("videoEncoderAvgQP"), this.data = e;
+  }
+}
+class ye extends Event {
+  constructor() {
+    super("webRtcSdp");
+  }
+}
+class Ee extends Event {
+  constructor() {
+    super("webRtcAutoConnect");
+  }
+}
+class Me extends Event {
+  constructor() {
+    super("webRtcConnecting");
+  }
+}
+class we extends Event {
+  constructor() {
+    super("webRtcConnected");
+  }
+}
+class be extends Event {
+  constructor() {
+    super("webRtcFailed");
+  }
+}
+class Pe extends Event {
+  constructor(e) {
+    super("webRtcDisconnected"), this.data = e;
+  }
+}
+class Re extends Event {
+  constructor(e) {
+    super("dataChannelOpen"), this.data = e;
+  }
+}
+class ke extends Event {
+  constructor(e) {
+    super("dataChannelClose"), this.data = e;
+  }
+}
+class Le extends Event {
+  constructor(e) {
+    super("dataChannelError"), this.data = e;
+  }
+}
+class xe extends Event {
+  constructor() {
+    super("videoInitialized");
+  }
+}
+class Fe extends Event {
+  constructor() {
+    super("streamLoading");
+  }
+}
+class Ae extends Event {
+  constructor() {
+    super("streamConnect");
+  }
+}
+class De extends Event {
+  constructor() {
+    super("streamDisconnect");
+  }
+}
+class Oe extends Event {
+  constructor() {
+    super("streamReconnect");
+  }
+}
+class Ie extends Event {
+  constructor(e) {
+    super("playStreamError"), this.data = e;
+  }
+}
+class Ue extends Event {
+  constructor() {
+    super("playStream");
+  }
+}
+class ie extends Event {
+  constructor(e) {
+    super("playStreamRejected"), this.data = e;
+  }
+}
+class Ge extends Event {
+  constructor(e) {
+    super("loadFreezeFrame"), this.data = e;
+  }
+}
+class Be extends Event {
+  constructor() {
+    super("hideFreezeFrame");
+  }
+}
+class ze extends Event {
+  constructor(e) {
+    super("statsReceived"), this.data = e;
+  }
+}
+class _e extends Event {
+  constructor(e) {
+    super("streamerListMessage"), this.data = e;
+  }
+}
+class Ve extends Event {
+  constructor(e) {
+    super("StreamerIDChangedMessage"), this.data = e;
+  }
+}
+class He extends Event {
+  constructor(e) {
+    super("latencyTestResult"), this.data = e;
+  }
+}
+class We extends Event {
+  constructor(e) {
+    super("dataChannelLatencyTestResponse"), this.data = e;
+  }
+}
+class Ne extends Event {
+  constructor(e) {
+    super("dataChannelLatencyTestResult"), this.data = e;
+  }
+}
+class Ke extends Event {
+  constructor(e) {
+    super("initialSettings"), this.data = e;
+  }
+}
+class N extends Event {
+  constructor(e) {
+    super("settingsChanged"), this.data = e;
+  }
+}
+class wt extends Event {
+  constructor() {
+    super("xrSessionStarted");
+  }
+}
+class bt extends Event {
+  constructor() {
+    super("xrSessionEnded");
+  }
+}
+class Qe extends Event {
+  constructor(e) {
+    super("xrFrame"), this.data = e;
+  }
+}
+class qe extends Event {
+  constructor(e) {
+    super("playerCount"), this.data = e;
+  }
+}
+class $e extends Event {
+  constructor() {
+    super("webRtcTCPRelayDetected");
+  }
+}
+class je extends EventTarget {
+  dispatchEvent(e) {
+    return super.dispatchEvent(e);
+  }
+  addEventListener(e, t) {
+    super.addEventListener(e, t);
+  }
+  removeEventListener(e, t) {
+    super.removeEventListener(e, t);
+  }
+}
+class l {
+}
+l.AutoConnect = "AutoConnect", l.AutoPlayVideo = "AutoPlayVideo", l.AFKDetection = "TimeoutIfIdle", l.BrowserSendOffer = "OfferToReceive", l.HoveringMouseMode = "HoveringMouse", l.ForceMonoAudio = "ForceMonoAudio", l.ForceTURN = "ForceTURN", l.FakeMouseWithTouches = "FakeMouseWithTouches", l.IsQualityController = "ControlsQuality", l.MatchViewportResolution = "MatchViewportRes", l.StartVideoMuted = "StartVideoMuted", l.SuppressBrowserKeys = "SuppressBrowserKeys", l.UseMic = "UseMic", l.KeyboardInput = "KeyboardInput", l.MouseInput = "MouseInput", l.TouchInput = "TouchInput", l.GamepadInput = "GamepadInput", l.XRControllerInput = "XRControllerInput", l.WaitForStreamer = "WaitForStreamer", l.HideUI = "HideUI";
+const Pt = (a) => Object.getOwnPropertyNames(l).some(((e) => l[e] === a));
+class h {
+}
+h.AFKTimeoutSecs = "AFKTimeout", h.AFKCountdownSecs = "AFKCountdown", h.MinQP = "MinQP", h.MaxQP = "MaxQP", h.WebRTCFPS = "WebRTCFPS", h.WebRTCMinBitrate = "WebRTCMinBitrate", h.WebRTCMaxBitrate = "WebRTCMaxBitrate", h.MaxReconnectAttempts = "MaxReconnectAttempts", h.StreamerAutoJoinInterval = "StreamerAutoJoinInterval";
+const Rt = (a) => Object.getOwnPropertyNames(h).some(((e) => h[e] === a));
+class I {
+}
+I.SignallingServerUrl = "ss";
+const kt = (a) => Object.getOwnPropertyNames(I).some(((e) => I[e] === a));
+class f {
+}
+f.PreferredCodec = "PreferredCodec", f.StreamerId = "StreamerId";
+const Lt = (a) => Object.getOwnPropertyNames(f).some(((e) => f[e] === a));
+class xt {
+  constructor(e = {}) {
+    this.flags = /* @__PURE__ */ new Map(), this.numericParameters = /* @__PURE__ */ new Map(), this.textParameters = /* @__PURE__ */ new Map(), this.optionParameters = /* @__PURE__ */ new Map();
+    const { initialSettings: t, useUrlParams: s } = e;
+    this._useUrlParams = !!s, this.populateDefaultSettings(this._useUrlParams, t);
+  }
+  get useUrlParams() {
+    return this._useUrlParams;
+  }
+  populateDefaultSettings(e, t) {
+    this.textParameters.set(I.SignallingServerUrl, new Se(I.SignallingServerUrl, "Signalling url", "Url of the signalling server", t && t.hasOwnProperty(I.SignallingServerUrl) ? t[I.SignallingServerUrl] : (location.protocol === "https:" ? "wss://" : "ws://") + window.location.hostname + (window.location.port === "80" || window.location.port === "" ? "" : `:${window.location.port}`), e)), this.optionParameters.set(f.StreamerId, new ne(f.StreamerId, "Streamer ID", "The ID of the streamer to stream.", t && t.hasOwnProperty(f.StreamerId) ? t[f.StreamerId] : "", [], e)), this.optionParameters.set(f.PreferredCodec, new ne(f.PreferredCodec, "Preferred Codec", "The preferred codec to be used during codec negotiation", "H264 level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f", t && t.hasOwnProperty(f.PreferredCodec) ? [t[f.PreferredCodec]] : (function() {
+      const s = [];
+      if (!RTCRtpReceiver.getCapabilities) return s.push("Only available on Chrome"), s;
+      const n = /(VP\d|H26\d|AV1).*/;
+      return RTCRtpReceiver.getCapabilities("video").codecs.forEach(((i) => {
+        const o = i.mimeType.split("/")[1] + " " + (i.sdpFmtpLine || "");
+        n.exec(o) !== null && s.push(o);
+      })), s;
+    })(), e)), this.flags.set(l.AutoConnect, new E(l.AutoConnect, "Auto connect to stream", "Whether we should attempt to auto connect to the signalling server or show a click to start prompt.", !(!t || !t.hasOwnProperty(l.AutoConnect)) && t[l.AutoConnect], e)), this.flags.set(l.AutoPlayVideo, new E(l.AutoPlayVideo, "Auto play video", "When video is ready automatically start playing it as opposed to showing a play button.", !t || !t.hasOwnProperty(l.AutoPlayVideo) || t[l.AutoPlayVideo], e)), this.flags.set(l.BrowserSendOffer, new E(l.BrowserSendOffer, "Browser send offer", "Browser will initiate the WebRTC handshake by sending the offer to the streamer", !(!t || !t.hasOwnProperty(l.BrowserSendOffer)) && t[l.BrowserSendOffer], e)), this.flags.set(l.UseMic, new E(l.UseMic, "Use microphone", "Make browser request microphone access and open an input audio track.", !(!t || !t.hasOwnProperty(l.UseMic)) && t[l.UseMic], e)), this.flags.set(l.StartVideoMuted, new E(l.StartVideoMuted, "Start video muted", "Video will start muted if true.", !(!t || !t.hasOwnProperty(l.StartVideoMuted)) && t[l.StartVideoMuted], e)), this.flags.set(l.SuppressBrowserKeys, new E(l.SuppressBrowserKeys, "Suppress browser keys", "Suppress certain browser keys that we use in UE, for example F5 to show shader complexity instead of refresh the page.", !t || !t.hasOwnProperty(l.SuppressBrowserKeys) || t[l.SuppressBrowserKeys], e)), this.flags.set(l.IsQualityController, new E(l.IsQualityController, "Is quality controller?", "True if this peer controls stream quality", !t || !t.hasOwnProperty(l.IsQualityController) || t[l.IsQualityController], e)), this.flags.set(l.ForceMonoAudio, new E(l.ForceMonoAudio, "Force mono audio", "Force browser to request mono audio in the SDP", !(!t || !t.hasOwnProperty(l.ForceMonoAudio)) && t[l.ForceMonoAudio], e)), this.flags.set(l.ForceTURN, new E(l.ForceTURN, "Force TURN", "Only generate TURN/Relayed ICE candidates.", !(!t || !t.hasOwnProperty(l.ForceTURN)) && t[l.ForceTURN], e)), this.flags.set(l.AFKDetection, new E(l.AFKDetection, "AFK if idle", "Timeout the experience if user is AFK for a period.", !(!t || !t.hasOwnProperty(l.AFKDetection)) && t[l.AFKDetection], e)), this.flags.set(l.MatchViewportResolution, new E(l.MatchViewportResolution, "Match viewport resolution", "Pixel Streaming will be instructed to dynamically resize the video stream to match the size of the video element.", !(!t || !t.hasOwnProperty(l.MatchViewportResolution)) && t[l.MatchViewportResolution], e)), this.flags.set(l.HoveringMouseMode, new E(l.HoveringMouseMode, "Control Scheme: Locked Mouse", "Either locked mouse, where the pointer is consumed by the video and locked to it, or hovering mouse, where the mouse is not consumed.", !(!t || !t.hasOwnProperty(l.HoveringMouseMode)) && t[l.HoveringMouseMode], e, ((s, n) => {
+      n.label = `Control Scheme: ${s ? "Hovering" : "Locked"} Mouse`;
+    }))), this.flags.set(l.FakeMouseWithTouches, new E(l.FakeMouseWithTouches, "Fake mouse with touches", "A single finger touch is converted into a mouse event. This allows a non-touch application to be controlled partially via a touch device.", !(!t || !t.hasOwnProperty(l.FakeMouseWithTouches)) && t[l.FakeMouseWithTouches], e)), this.flags.set(l.KeyboardInput, new E(l.KeyboardInput, "Keyboard input", "If enabled, send keyboard events to streamer", !t || !t.hasOwnProperty(l.KeyboardInput) || t[l.KeyboardInput], e)), this.flags.set(l.MouseInput, new E(l.MouseInput, "Mouse input", "If enabled, send mouse events to streamer", !t || !t.hasOwnProperty(l.MouseInput) || t[l.MouseInput], e)), this.flags.set(l.TouchInput, new E(l.TouchInput, "Touch input", "If enabled, send touch events to streamer", !t || !t.hasOwnProperty(l.TouchInput) || t[l.TouchInput], e)), this.flags.set(l.GamepadInput, new E(l.GamepadInput, "Gamepad input", "If enabled, send gamepad events to streamer", !t || !t.hasOwnProperty(l.GamepadInput) || t[l.GamepadInput], e)), this.flags.set(l.XRControllerInput, new E(l.XRControllerInput, "XR controller input", "If enabled, send XR controller events to streamer", !t || !t.hasOwnProperty(l.XRControllerInput) || t[l.XRControllerInput], e)), this.flags.set(l.WaitForStreamer, new E(l.WaitForStreamer, "Wait for streamer", "Will continue trying to connect to the first streamer available.", !t || !t.hasOwnProperty(l.WaitForStreamer) || t[l.WaitForStreamer], e)), this.flags.set(l.HideUI, new E(l.HideUI, "Hide the UI overlay", "Will hide all UI overlay details", !(!t || !t.hasOwnProperty(l.HideUI)) && t[l.HideUI], e)), this.numericParameters.set(h.AFKTimeoutSecs, new D(h.AFKTimeoutSecs, "AFK timeout", "The time (in seconds) it takes for the application to time out if AFK timeout is enabled.", 0, null, t && t.hasOwnProperty(h.AFKTimeoutSecs) ? t[h.AFKTimeoutSecs] : 120, e)), this.numericParameters.set(h.AFKCountdownSecs, new D(h.AFKCountdownSecs, "AFK countdown", "The time (in seconds) for a user to respond before the stream is ended after an AFK timeout.", 10, null, 10, e)), this.numericParameters.set(h.MaxReconnectAttempts, new D(h.MaxReconnectAttempts, "Max Reconnects", "Maximum number of reconnects the application will attempt when a streamer disconnects.", 0, 999, t && t.hasOwnProperty(h.MaxReconnectAttempts) ? t[h.MaxReconnectAttempts] : 3, e)), this.numericParameters.set(h.MinQP, new D(h.MinQP, "Min QP", "The lower bound for the quantization parameter (QP) of the encoder. 0 = Best quality, 51 = worst quality.", 0, 51, t && t.hasOwnProperty(h.MinQP) ? t[h.MinQP] : 0, e)), this.numericParameters.set(h.MaxQP, new D(h.MaxQP, "Max QP", "The upper bound for the quantization parameter (QP) of the encoder. 0 = Best quality, 51 = worst quality.", 0, 51, t && t.hasOwnProperty(h.MaxQP) ? t[h.MaxQP] : 51, e)), this.numericParameters.set(h.WebRTCFPS, new D(h.WebRTCFPS, "Max FPS", "The maximum FPS that WebRTC will try to transmit frames at.", 1, 999, t && t.hasOwnProperty(h.WebRTCFPS) ? t[h.WebRTCFPS] : 60, e)), this.numericParameters.set(h.WebRTCMinBitrate, new D(h.WebRTCMinBitrate, "Min Bitrate (kbps)", "The minimum bitrate that WebRTC should use.", 0, 5e5, t && t.hasOwnProperty(h.WebRTCMinBitrate) ? t[h.WebRTCMinBitrate] : 0, e)), this.numericParameters.set(h.WebRTCMaxBitrate, new D(h.WebRTCMaxBitrate, "Max Bitrate (kbps)", "The maximum bitrate that WebRTC should use.", 0, 5e5, t && t.hasOwnProperty(h.WebRTCMaxBitrate) ? t[h.WebRTCMaxBitrate] : 0, e)), this.numericParameters.set(h.StreamerAutoJoinInterval, new D(h.StreamerAutoJoinInterval, "Streamer Auto Join Interval (ms)", "Delay between retries when waiting for an available streamer.", 500, 9e5, t && t.hasOwnProperty(h.StreamerAutoJoinInterval) ? t[h.StreamerAutoJoinInterval] : 3e3, e));
+  }
+  _addOnNumericSettingChangedListener(e, t) {
+    this.numericParameters.has(e) && this.numericParameters.get(e).addOnChangedListener(t);
+  }
+  _addOnOptionSettingChangedListener(e, t) {
+    this.optionParameters.has(e) && this.optionParameters.get(e).addOnChangedListener(t);
+  }
+  getNumericSettingValue(e) {
+    if (this.numericParameters.has(e)) return this.numericParameters.get(e).number;
+    throw new Error(`There is no numeric setting with the id of ${e}`);
+  }
+  getTextSettingValue(e) {
+    if (this.textParameters.has(e)) return this.textParameters.get(e).value;
+    throw new Error(`There is no numeric setting with the id of ${e}`);
+  }
+  setNumericSetting(e, t) {
+    if (!this.numericParameters.has(e)) throw new Error(`There is no numeric setting with the id of ${e}`);
+    this.numericParameters.get(e).number = t;
+  }
+  _addOnSettingChangedListener(e, t) {
+    this.flags.has(e) && (this.flags.get(e).onChange = t);
+  }
+  _addOnTextSettingChangedListener(e, t) {
+    this.textParameters.has(e) && (this.textParameters.get(e).onChange = t);
+  }
+  getSettingOption(e) {
+    return this.optionParameters.get(e);
+  }
+  isFlagEnabled(e) {
+    return this.flags.get(e).flag;
+  }
+  setFlagEnabled(e, t) {
+    this.flags.has(e) ? this.flags.get(e).flag = t : r.Warning(r.GetStackTrace(), `Cannot toggle flag called ${e} - it does not exist in the Config.flags map.`);
+  }
+  setTextSetting(e, t) {
+    this.textParameters.has(e) ? this.textParameters.get(e).text = t : r.Warning(r.GetStackTrace(), `Cannot set text setting called ${e} - it does not exist in the Config.textParameters map.`);
+  }
+  setOptionSettingOptions(e, t) {
+    this.optionParameters.has(e) ? this.optionParameters.get(e).options = t : r.Warning(r.GetStackTrace(), `Cannot set text setting called ${e} - it does not exist in the Config.optionParameters map.`);
+  }
+  setOptionSettingValue(e, t) {
+    if (this.optionParameters.has(e)) {
+      const s = this.optionParameters.get(e), n = s.options;
+      n.includes(t) || (n.push(t), s.options = n), s.selected = t;
+    } else r.Warning(r.GetStackTrace(), `Cannot set text setting called ${e} - it does not exist in the Config.enumParameters map.`);
+  }
+  setFlagLabel(e, t) {
+    this.flags.has(e) ? this.flags.get(e).label = t : r.Warning(r.GetStackTrace(), `Cannot set label for flag called ${e} - it does not exist in the Config.flags map.`);
+  }
+  setSettings(e) {
+    for (const t of Object.keys(e)) Pt(t) ? this.setFlagEnabled(t, e[t]) : Rt(t) ? this.setNumericSetting(t, e[t]) : kt(t) ? this.setTextSetting(t, e[t]) : Lt(t) && this.setOptionSettingValue(t, e[t]);
+  }
+  getSettings() {
+    const e = {};
+    for (const [t, s] of this.flags.entries()) e[t] = s.flag;
+    for (const [t, s] of this.numericParameters.entries()) e[t] = s.number;
+    for (const [t, s] of this.textParameters.entries()) e[t] = s.text;
+    for (const [t, s] of this.optionParameters.entries()) e[t] = s.selected;
+    return e;
+  }
+  getFlags() {
+    return Array.from(this.flags.values());
+  }
+  getTextSettings() {
+    return Array.from(this.textParameters.values());
+  }
+  getNumericSettings() {
+    return Array.from(this.numericParameters.values());
+  }
+  getOptionSettings() {
+    return Array.from(this.optionParameters.values());
+  }
+  _registerOnChangeEvents(e) {
+    for (const t of this.flags.keys()) {
+      const s = this.flags.get(t);
+      s && (s.onChangeEmit = (n) => e.dispatchEvent(new N({ id: s.id, type: "flag", value: n, target: s })));
+    }
+    for (const t of this.numericParameters.keys()) {
+      const s = this.numericParameters.get(t);
+      s && (s.onChangeEmit = (n) => e.dispatchEvent(new N({ id: s.id, type: "number", value: n, target: s })));
+    }
+    for (const t of this.textParameters.keys()) {
+      const s = this.textParameters.get(t);
+      s && (s.onChangeEmit = (n) => e.dispatchEvent(new N({ id: s.id, type: "text", value: n, target: s })));
+    }
+    for (const t of this.optionParameters.keys()) {
+      const s = this.optionParameters.get(t);
+      s && (s.onChangeEmit = (n) => e.dispatchEvent(new N({ id: s.id, type: "option", value: n, target: s })));
+    }
+  }
+}
+var B;
+(function(a) {
+  a[a.LockedMouse = 0] = "LockedMouse", a[a.HoveringMouse = 1] = "HoveringMouse";
+})(B || (B = {}));
+class Xe {
+  constructor(e, t, s) {
+    this.active = !1, this.countdownActive = !1, this.warnTimer = void 0, this.countDown = 0, this.countDownTimer = void 0, this.config = e, this.pixelStreaming = t, this.onDismissAfk = s, this.onAFKTimedOutCallback = () => {
+      console.log("AFK timed out, did you want to override this callback?");
+    };
+  }
+  onAfkClick() {
+    clearInterval(this.countDownTimer), (this.active || this.countdownActive) && (this.startAfkWarningTimer(), this.pixelStreaming.dispatchEvent(new fe()));
+  }
+  startAfkWarningTimer() {
+    this.config.getNumericSettingValue(h.AFKTimeoutSecs) > 0 && this.config.isFlagEnabled(l.AFKDetection) ? this.active = !0 : this.active = !1, this.resetAfkWarningTimer();
+  }
+  stopAfkWarningTimer() {
+    this.active = !1, this.countdownActive = !1, clearTimeout(this.warnTimer), clearInterval(this.countDownTimer);
+  }
+  pauseAfkWarningTimer() {
+    this.active = !1;
+  }
+  resetAfkWarningTimer() {
+    this.active && this.config.isFlagEnabled(l.AFKDetection) && (clearTimeout(this.warnTimer), this.warnTimer = setTimeout((() => this.activateAfkEvent()), 1e3 * this.config.getNumericSettingValue(h.AFKTimeoutSecs)));
+  }
+  activateAfkEvent() {
+    this.pauseAfkWarningTimer(), this.pixelStreaming.dispatchEvent(new ve({ countDown: this.countDown, dismissAfk: this.onDismissAfk })), this.countDown = this.config.getNumericSettingValue(h.AFKCountdownSecs), this.countdownActive = !0, this.pixelStreaming.dispatchEvent(new re({ countDown: this.countDown })), this.config.isFlagEnabled(l.HoveringMouseMode) || document.exitPointerLock && document.exitPointerLock(), this.countDownTimer = setInterval((() => {
+      this.countDown--, this.countDown == 0 ? (this.pixelStreaming.dispatchEvent(new Ce()), this.onAFKTimedOutCallback(), r.Log(r.GetStackTrace(), "You have been disconnected due to inactivity"), this.stopAfkWarningTimer()) : this.pixelStreaming.dispatchEvent(new re({ countDown: this.countDown }));
+    }), 1e3);
+  }
+}
+class ce {
+  constructor() {
+    this.isReceivingFreezeFrame = !1;
+  }
+  getDataChannelInstance() {
+    return this;
+  }
+  createDataChannel(e, t, s) {
+    this.peerConnection = e, this.label = t, this.datachannelOptions = s, s == null && (this.datachannelOptions = {}, this.datachannelOptions.ordered = !0), this.dataChannel = this.peerConnection.createDataChannel(this.label, this.datachannelOptions), this.setupDataChannel();
+  }
+  setupDataChannel() {
+    this.dataChannel.binaryType = "arraybuffer", this.dataChannel.onopen = (e) => this.handleOnOpen(e), this.dataChannel.onclose = (e) => this.handleOnClose(e), this.dataChannel.onmessage = (e) => this.handleOnMessage(e), this.dataChannel.onerror = (e) => this.handleOnError(e);
+  }
+  handleOnOpen(e) {
+    var t;
+    r.Log(r.GetStackTrace(), `Data Channel (${this.label}) opened.`, 7), this.onOpen((t = this.dataChannel) === null || t === void 0 ? void 0 : t.label, e);
+  }
+  handleOnClose(e) {
+    var t;
+    r.Log(r.GetStackTrace(), `Data Channel (${this.label}) closed.`, 7), this.onClose((t = this.dataChannel) === null || t === void 0 ? void 0 : t.label, e);
+  }
+  handleOnMessage(e) {
+    r.Log(r.GetStackTrace(), `Data Channel (${this.label}) message: ${e}`, 8);
+  }
+  handleOnError(e) {
+    var t;
+    r.Log(r.GetStackTrace(), `Data Channel (${this.label}) error: ${e}`, 7), this.onError((t = this.dataChannel) === null || t === void 0 ? void 0 : t.label, e);
+  }
+  onOpen(e, t) {
+  }
+  onClose(e, t) {
+  }
+  onError(e, t) {
+  }
+}
+class Je {
+}
+class Ye {
+}
+class Ze {
+}
+class ae {
+}
+class et {
+}
+class Ft {
+}
+class At {
+}
+class tt {
+  constructor() {
+    this.inboundVideoStats = new Ye(), this.inboundAudioStats = new Je(), this.DataChannelStats = new Ze(), this.outBoundVideoStats = new et(), this.sessionStats = new Ft(), this.streamStats = new At(), this.codecs = /* @__PURE__ */ new Map();
+  }
+  processStats(e) {
+    this.localCandidates = new Array(), this.remoteCandidates = new Array(), this.candidatePairs = new Array(), e.forEach(((t) => {
+      switch (t.type) {
+        case "candidate-pair":
+          this.handleCandidatePair(t);
+          break;
+        case "certificate":
+        case "media-source":
+        case "media-playout":
+        case "outbound-rtp":
+        case "peer-connection":
+        case "remote-inbound-rtp":
+          break;
+        case "codec":
+          this.handleCodec(t);
+          break;
+        case "data-channel":
+          this.handleDataChannel(t);
+          break;
+        case "inbound-rtp":
+          this.handleInBoundRTP(t);
+          break;
+        case "local-candidate":
+          this.handleLocalCandidate(t);
+          break;
+        case "remote-candidate":
+          this.handleRemoteCandidate(t);
+          break;
+        case "remote-outbound-rtp":
+          this.handleRemoteOutBound(t);
+          break;
+        case "track":
+          this.handleTrack(t);
+          break;
+        case "transport":
+          this.handleTransport(t);
+          break;
+        case "stream":
+          this.handleStream(t);
+          break;
+        default:
+          r.Error(r.GetStackTrace(), "unhandled Stat Type"), r.Log(r.GetStackTrace(), t);
+      }
+    }));
+  }
+  handleStream(e) {
+    this.streamStats = e;
+  }
+  handleCandidatePair(e) {
+    this.candidatePairs.push(e);
+  }
+  handleDataChannel(e) {
+    this.DataChannelStats.bytesReceived = e.bytesReceived, this.DataChannelStats.bytesSent = e.bytesSent, this.DataChannelStats.dataChannelIdentifier = e.dataChannelIdentifier, this.DataChannelStats.id = e.id, this.DataChannelStats.label = e.label, this.DataChannelStats.messagesReceived = e.messagesReceived, this.DataChannelStats.messagesSent = e.messagesSent, this.DataChannelStats.protocol = e.protocol, this.DataChannelStats.state = e.state, this.DataChannelStats.timestamp = e.timestamp;
+  }
+  handleLocalCandidate(e) {
+    const t = new ae();
+    t.label = "local-candidate", t.address = e.address, t.port = e.port, t.protocol = e.protocol, t.candidateType = e.candidateType, t.id = e.id, t.relayProtocol = e.relayProtocol, t.transportId = e.transportId, this.localCandidates.push(t);
+  }
+  handleRemoteCandidate(e) {
+    const t = new ae();
+    t.label = "remote-candidate", t.address = e.address, t.port = e.port, t.protocol = e.protocol, t.id = e.id, t.candidateType = e.candidateType, t.relayProtocol = e.relayProtocol, t.transportId = e.transportId, this.remoteCandidates.push(t);
+  }
+  handleInBoundRTP(e) {
+    switch (e.kind) {
+      case "video":
+        this.inboundVideoStats = e, this.lastVideoStats != null && (this.inboundVideoStats.bitrate = 8 * (this.inboundVideoStats.bytesReceived - this.lastVideoStats.bytesReceived) / (this.inboundVideoStats.timestamp - this.lastVideoStats.timestamp), this.inboundVideoStats.bitrate = Math.floor(this.inboundVideoStats.bitrate)), this.lastVideoStats = Object.assign({}, this.inboundVideoStats);
+        break;
+      case "audio":
+        this.inboundAudioStats = e, this.lastAudioStats != null && (this.inboundAudioStats.bitrate = 8 * (this.inboundAudioStats.bytesReceived - this.lastAudioStats.bytesReceived) / (this.inboundAudioStats.timestamp - this.lastAudioStats.timestamp), this.inboundAudioStats.bitrate = Math.floor(this.inboundAudioStats.bitrate)), this.lastAudioStats = Object.assign({}, this.inboundAudioStats);
+        break;
+      default:
+        r.Log(r.GetStackTrace(), "Kind is not handled");
+    }
+  }
+  handleRemoteOutBound(e) {
+    e.kind === "video" && (this.outBoundVideoStats.bytesSent = e.bytesSent, this.outBoundVideoStats.id = e.id, this.outBoundVideoStats.localId = e.localId, this.outBoundVideoStats.packetsSent = e.packetsSent, this.outBoundVideoStats.remoteTimestamp = e.remoteTimestamp, this.outBoundVideoStats.timestamp = e.timestamp);
+  }
+  handleTrack(e) {
+    e.type !== "track" || e.trackIdentifier !== "video_label" && e.kind !== "video" || (this.inboundVideoStats.framesDropped = e.framesDropped, this.inboundVideoStats.framesReceived = e.framesReceived, this.inboundVideoStats.frameHeight = e.frameHeight, this.inboundVideoStats.frameWidth = e.frameWidth);
+  }
+  handleTransport(e) {
+    this.transportStats = e;
+  }
+  handleCodec(e) {
+    const t = e.id, s = `${e.mimeType.replace("video/", "").replace("audio/", "")}${e.sdpFmtpLine ? ` ${e.sdpFmtpLine}` : ""}`;
+    this.codecs.set(t, s);
+  }
+  handleSessionStatistics(e, t, s) {
+    const n = Date.now() - e;
+    this.sessionStats.runTime = new Date(n).toISOString().substr(11, 8).toString();
+    const i = t === null ? "Not sent yet" : t ? "true" : "false";
+    this.sessionStats.controlsStreamInput = i, this.sessionStats.videoEncoderAvgQP = s;
+  }
+  isNumber(e) {
+    return typeof e == "number" && isFinite(e);
+  }
+  getActiveCandidatePair() {
+    return this.transportStats ? this.candidatePairs.find(((e) => e.id === this.transportStats.selectedCandidatePairId), null) : this.candidatePairs.find(((e) => e.selected), null);
+  }
+}
+const he = (ue = { parseRtpParameters: () => de.parseRtpParameters, splitSections: () => de.splitSections }, Z = {}, q.d(Z, ue), Z);
+var ue, Z;
+class st {
+  static isVideoTransciever(e) {
+    return this.canTransceiverReceiveVideo(e) || this.canTransceiverSendVideo(e);
+  }
+  static canTransceiverReceiveVideo(e) {
+    return !!e && (e.direction === "sendrecv" || e.direction === "recvonly") && e.receiver && e.receiver.track && e.receiver.track.kind === "video";
+  }
+  static canTransceiverSendVideo(e) {
+    return !!e && (e.direction === "sendrecv" || e.direction === "sendonly") && e.sender && e.sender.track && e.sender.track.kind === "video";
+  }
+  static isAudioTransciever(e) {
+    return this.canTransceiverReceiveAudio(e) || this.canTransceiverSendAudio(e);
+  }
+  static canTransceiverReceiveAudio(e) {
+    return !!e && (e.direction === "sendrecv" || e.direction === "recvonly") && e.receiver && e.receiver.track && e.receiver.track.kind === "audio";
+  }
+  static canTransceiverSendAudio(e) {
+    return !!e && (e.direction === "sendrecv" || e.direction === "sendonly") && e.sender && e.sender.track && e.sender.track.kind === "audio";
+  }
+}
+var _, p, ee = function(a, e, t, s) {
+  return new (t || (t = Promise))((function(n, i) {
+    function o(m) {
+      try {
+        c(s.next(m));
+      } catch (u) {
+        i(u);
+      }
+    }
+    function d(m) {
+      try {
+        c(s.throw(m));
+      } catch (u) {
+        i(u);
+      }
+    }
+    function c(m) {
+      var u;
+      m.done ? n(m.value) : (u = m.value, u instanceof t ? u : new t((function(v) {
+        v(u);
+      }))).then(o, d);
+    }
+    c((s = s.apply(a, [])).next());
+  }));
+};
+class Dt {
+  constructor(e, t, s) {
+    this.config = t, this.createPeerConnection(e, s);
+  }
+  createPeerConnection(e, t) {
+    this.config.isFlagEnabled(l.ForceTURN) && (e.iceTransportPolicy = "relay", r.Log(r.GetStackTrace(), "Forcing TURN usage by setting ICE Transport Policy in peer connection config.")), this.peerConnection = new RTCPeerConnection(e), this.peerConnection.onsignalingstatechange = (s) => this.handleSignalStateChange(s), this.peerConnection.oniceconnectionstatechange = (s) => this.handleIceConnectionStateChange(s), this.peerConnection.onicegatheringstatechange = (s) => this.handleIceGatheringStateChange(s), this.peerConnection.ontrack = (s) => this.handleOnTrack(s), this.peerConnection.onicecandidate = (s) => this.handleIceCandidate(s), this.peerConnection.ondatachannel = (s) => this.handleDataChannel(s), this.aggregatedStats = new tt(), this.preferredCodec = t, this.updateCodecSelection = !0;
+  }
+  createOffer(e, t) {
+    return ee(this, void 0, void 0, (function* () {
+      r.Log(r.GetStackTrace(), "Create Offer", 6);
+      const s = location.hostname === "localhost" || location.hostname === "127.0.0.1", n = location.protocol === "https:";
+      let i = t.isFlagEnabled(l.UseMic);
+      !i || s || n || (i = !1, r.Error(r.GetStackTrace(), "Microphone access in the browser will not work if you are not on HTTPS or localhost. Disabling mic access."), r.Error(r.GetStackTrace(), "For testing you can enable HTTP microphone access Chrome by visiting chrome://flags/ and enabling 'unsafely-treat-insecure-origin-as-secure'")), this.setupTransceiversAsync(i).finally((() => {
+        var o;
+        (o = this.peerConnection) === null || o === void 0 || o.createOffer(e).then(((d) => {
+          var c;
+          this.showTextOverlayConnecting(), d.sdp = this.mungeSDP(d.sdp, i), (c = this.peerConnection) === null || c === void 0 || c.setLocalDescription(d), this.onSendWebRTCOffer(d);
+        })).catch((() => {
+          this.showTextOverlaySetupFailure();
+        }));
+      }));
+    }));
+  }
+  receiveOffer(e, t) {
+    var s;
+    return ee(this, void 0, void 0, (function* () {
+      r.Log(r.GetStackTrace(), "Receive Offer", 6), (s = this.peerConnection) === null || s === void 0 || s.setRemoteDescription(e).then((() => {
+        const n = location.hostname === "localhost" || location.hostname === "127.0.0.1", i = location.protocol === "https:";
+        let o = t.isFlagEnabled(l.UseMic);
+        !o || n || i || (o = !1, r.Error(r.GetStackTrace(), "Microphone access in the browser will not work if you are not on HTTPS or localhost. Disabling mic access."), r.Error(r.GetStackTrace(), "For testing you can enable HTTP microphone access Chrome by visiting chrome://flags/ and enabling 'unsafely-treat-insecure-origin-as-secure'")), this.config.setOptionSettingOptions(f.PreferredCodec, this.fuzzyIntersectUEAndBrowserCodecs(e)), this.setupTransceiversAsync(o).finally((() => {
+          var d;
+          (d = this.peerConnection) === null || d === void 0 || d.createAnswer().then(((c) => {
+            var m;
+            return c.sdp = this.mungeSDP(c.sdp, o), (m = this.peerConnection) === null || m === void 0 ? void 0 : m.setLocalDescription(c);
+          })).then((() => {
+            var c;
+            this.onSendWebRTCAnswer((c = this.peerConnection) === null || c === void 0 ? void 0 : c.currentLocalDescription);
+          })).catch((() => {
+            r.Error(r.GetStackTrace(), "createAnswer() failed");
+          }));
+        }));
+      }));
+    }));
+  }
+  receiveAnswer(e) {
+    var t;
+    (t = this.peerConnection) === null || t === void 0 || t.setRemoteDescription(e), this.config.setOptionSettingOptions(f.PreferredCodec, this.fuzzyIntersectUEAndBrowserCodecs(e));
+  }
+  generateStats() {
+    var e;
+    (e = this.peerConnection) === null || e === void 0 || e.getStats(null).then(((t) => {
+      this.aggregatedStats.processStats(t), this.onVideoStats(this.aggregatedStats), this.updateCodecSelection && this.aggregatedStats.inboundVideoStats.codecId && this.config.setOptionSettingValue(f.PreferredCodec, this.aggregatedStats.codecs.get(this.aggregatedStats.inboundVideoStats.codecId));
+    }));
+  }
+  close() {
+    this.peerConnection && (this.peerConnection.close(), this.peerConnection = null);
+  }
+  mungeSDP(e, t) {
+    let s = e.replace(/(a=fmtp:\d+ .*level-asymmetry-allowed=.*)\r\n/gm, `$1;x-google-start-bitrate=10000;x-google-max-bitrate=100000\r
+`), n = "maxaveragebitrate=510000;";
+    return t && (n += "sprop-maxcapturerate=48000;"), n += this.config.isFlagEnabled(l.ForceMonoAudio) ? "stereo=0;" : "stereo=1;", n += "useinbandfec=1", s = s.replace("useinbandfec=1", n), s;
+  }
+  handleOnIce(e) {
+    var t;
+    r.Log(r.GetStackTrace(), "peerconnection handleOnIce", 6), this.config.isFlagEnabled(l.ForceTURN) && e.candidate.indexOf("relay") < 0 ? r.Info(r.GetStackTrace(), `Dropping candidate because it was not TURN relay. | Type= ${e.type} | Protocol= ${e.protocol} | Address=${e.address} | Port=${e.port} |`, 6) : (t = this.peerConnection) === null || t === void 0 || t.addIceCandidate(e);
+  }
+  handleSignalStateChange(e) {
+    r.Log(r.GetStackTrace(), "signaling state change: " + e, 6);
+  }
+  handleIceConnectionStateChange(e) {
+    r.Log(r.GetStackTrace(), "ice connection state change: " + e, 6), this.onIceConnectionStateChange(e);
+  }
+  handleIceGatheringStateChange(e) {
+    r.Log(r.GetStackTrace(), "ice gathering state change: " + JSON.stringify(e), 6);
+  }
+  handleOnTrack(e) {
+    this.onTrack(e);
+  }
+  handleIceCandidate(e) {
+    this.onPeerIceCandidate(e);
+  }
+  handleDataChannel(e) {
+    this.onDataChannel(e);
+  }
+  onTrack(e) {
+  }
+  onIceConnectionStateChange(e) {
+  }
+  onPeerIceCandidate(e) {
+  }
+  onDataChannel(e) {
+  }
+  fuzzyIntersectUEAndBrowserCodecs(e) {
+    const t = new Array(), s = this.parseAvailableCodecs(e), n = this.config.getSettingOption(f.PreferredCodec).options;
+    for (const i of s) if (n.includes(i)) t.push(i);
+    else {
+      const o = i.split(" ")[0];
+      for (const d of n) if (d.includes(o)) {
+        t.push(d);
+        break;
+      }
+    }
+    return t;
+  }
+  setupTransceiversAsync(e) {
+    var t, s, n, i, o, d, c, m, u, v, S, y;
+    return ee(this, void 0, void 0, (function* () {
+      let P = !1;
+      for (const C of (s = (t = this.peerConnection) === null || t === void 0 ? void 0 : t.getTransceivers()) !== null && s !== void 0 ? s : []) if (C && C.receiver && C.receiver.track && C.receiver.track.kind === "video") {
+        P = !0;
+        break;
+      }
+      if (P || (n = this.peerConnection) === null || n === void 0 || n.addTransceiver("video", { direction: "recvonly" }), RTCRtpReceiver.getCapabilities && this.preferredCodec != "") {
+        for (const C of (o = (i = this.peerConnection) === null || i === void 0 ? void 0 : i.getTransceivers()) !== null && o !== void 0 ? o : []) if (C && C.receiver && C.receiver.track && C.receiver.track.kind === "video" && C.setCodecPreferences) {
+          const A = this.preferredCodec.split(" "), R = { mimeType: "video/" + A[0], clockRate: 9e4, sdpFmtpLine: A[1] ? A[1] : "" }, w = [R];
+          RTCRtpReceiver.getCapabilities("video").codecs.forEach(((T) => {
+            (T.mimeType != R.mimeType || T?.sdpFmtpLine != R?.sdpFmtpLine) && w.push(T);
+          }));
+          for (const T of w) T?.sdpFmtpLine !== void 0 && T.sdpFmtpLine !== "" || delete T.sdpFmtpLine;
+          C.setCodecPreferences(w);
+        }
+      }
+      let x = !1;
+      for (const C of (c = (d = this.peerConnection) === null || d === void 0 ? void 0 : d.getTransceivers()) !== null && c !== void 0 ? c : []) if (C && C.receiver && C.receiver.track && C.receiver.track.kind === "audio") {
+        x = !0;
+        break;
+      }
+      if (e) {
+        const C = { video: !1, audio: { autoGainControl: !1, channelCount: 1, echoCancellation: !1, latency: 0, noiseSuppression: !1, sampleRate: 48e3, sampleSize: 16, volume: 1 } }, A = yield navigator.mediaDevices.getUserMedia(C);
+        if (A) if (x) {
+          for (const R of (v = (u = this.peerConnection) === null || u === void 0 ? void 0 : u.getTransceivers()) !== null && v !== void 0 ? v : []) if (st.canTransceiverReceiveAudio(R)) for (const w of A.getTracks()) w.kind && w.kind == "audio" && (R.sender.replaceTrack(w), R.direction = "sendrecv");
+        } else for (const R of A.getTracks()) R.kind && R.kind == "audio" && ((S = this.peerConnection) === null || S === void 0 || S.addTransceiver(R, { direction: "sendrecv" }));
+        else x || (y = this.peerConnection) === null || y === void 0 || y.addTransceiver("audio", { direction: "recvonly" });
+      } else x || (m = this.peerConnection) === null || m === void 0 || m.addTransceiver("audio", { direction: "recvonly" });
+    }));
+  }
+  onVideoStats(e) {
+  }
+  onSendWebRTCOffer(e) {
+  }
+  onSendWebRTCAnswer(e) {
+  }
+  showTextOverlayConnecting() {
+  }
+  showTextOverlaySetupFailure() {
+  }
+  parseAvailableCodecs(e) {
+    if (!RTCRtpReceiver.getCapabilities) return ["Only available on Chrome"];
+    const t = [], s = (0, he.splitSections)(e.sdp);
+    return s.shift(), s.forEach(((n) => {
+      const { codecs: i } = (0, he.parseRtpParameters)(n), o = /(VP\d|H26\d|AV1).*/;
+      i.forEach(((d) => {
+        const c = d.name + " " + Object.keys(d.parameters || {}).map(((m) => m + "=" + d.parameters[m])).join(";");
+        if (o.exec(c) !== null) {
+          d.name == "VP9" && (d.parameters = { "profile-id": "0" });
+          const m = d.name + " " + Object.keys(d.parameters || {}).map(((u) => u + "=" + d.parameters[u])).join(";");
+          t.push(m);
+        }
+      }));
+    })), t;
+  }
+}
+class nt {
+  constructor() {
+    this.PixelStreamingSettings = new Ot(), this.EncoderSettings = new rt(), this.WebRTCSettings = new it();
+  }
+  ueCompatible() {
+    this.WebRTCSettings.MaxFPS != null && (this.WebRTCSettings.FPS = this.WebRTCSettings.MaxFPS);
+  }
+}
+class Ot {
+}
+class rt {
+}
+class it {
+}
+class at {
+  constructor() {
+    this.ReceiptTimeMs = null, this.TransmissionTimeMs = null, this.PreCaptureTimeMs = null, this.PostCaptureTimeMs = null, this.PreEncodeTimeMs = null, this.PostEncodeTimeMs = null, this.EncodeMs = null, this.CaptureToSendMs = null, this.testStartTimeMs = 0, this.browserReceiptTimeMs = 0, this.latencyExcludingDecode = 0, this.testDuration = 0, this.networkLatency = 0, this.browserSendLatency = 0, this.frameDisplayDeltaTimeMs = 0, this.endToEndLatency = 0, this.encodeLatency = 0;
+  }
+  setFrameDisplayDeltaTime(e) {
+    this.frameDisplayDeltaTimeMs == 0 && (this.frameDisplayDeltaTimeMs = Math.round(e));
+  }
+  processFields() {
+    this.EncodeMs != null || this.PreEncodeTimeMs == null && this.PostEncodeTimeMs == null || (r.Log(r.GetStackTrace(), `Setting Encode Ms 
+ ${this.PostEncodeTimeMs} 
+ ${this.PreEncodeTimeMs}`, 6), this.EncodeMs = this.PostEncodeTimeMs - this.PreEncodeTimeMs), this.CaptureToSendMs != null || this.PreCaptureTimeMs == null && this.PostCaptureTimeMs == null || (r.Log(r.GetStackTrace(), `Setting CaptureToSendMs Ms 
+ ${this.PostCaptureTimeMs} 
+ ${this.PreCaptureTimeMs}`, 6), this.CaptureToSendMs = this.PostCaptureTimeMs - this.PreCaptureTimeMs);
+  }
+}
+class te {
+  static setExtensionFromBytes(e, t) {
+    t.receiving || (t.mimetype = "", t.extension = "", t.receiving = !0, t.valid = !1, t.chunks = 0, t.data = [], t.timestampStart = (/* @__PURE__ */ new Date()).getTime(), r.Log(r.GetStackTrace(), "Received first chunk of file", 6));
+    const s = new TextDecoder("utf-16").decode(e.slice(1));
+    r.Log(r.GetStackTrace(), s, 6), t.extension = s;
+  }
+  static setMimeTypeFromBytes(e, t) {
+    t.receiving || (t.mimetype = "", t.extension = "", t.receiving = !0, t.valid = !1, t.chunks = 0, t.data = [], t.timestampStart = (/* @__PURE__ */ new Date()).getTime(), r.Log(r.GetStackTrace(), "Received first chunk of file", 6));
+    const s = new TextDecoder("utf-16").decode(e.slice(1));
+    r.Log(r.GetStackTrace(), s, 6), t.mimetype = s;
+  }
+  static setContentsFromBytes(e, t) {
+    if (!t.receiving) return;
+    t.chunks = Math.ceil(new DataView(e.slice(1, 5).buffer).getInt32(0, !0) / 16379);
+    const s = e.slice(5);
+    if (t.data.push(s), r.Log(r.GetStackTrace(), `Received file chunk: ${t.data.length}/${t.chunks}`, 6), t.data.length === t.chunks) {
+      t.receiving = !1, t.valid = !0, r.Log(r.GetStackTrace(), "Received complete file", 6);
+      const n = (/* @__PURE__ */ new Date()).getTime() - t.timestampStart, i = Math.round(16384 * t.chunks / n);
+      r.Log(r.GetStackTrace(), `Average transfer bitrate: ${i}kb/s over ${n / 1e3} seconds`, 6);
+      const o = new Blob(t.data, { type: t.mimetype }), d = document.createElement("a");
+      d.setAttribute("href", URL.createObjectURL(o)), d.setAttribute("download", `transfer.${t.extension}`), document.body.append(d), d.remove();
+    } else t.data.length > t.chunks && (t.receiving = !1, r.Error(r.GetStackTrace(), `Received bigger file than advertised: ${t.data.length}/${t.chunks}`));
+  }
+}
+class It {
+  constructor() {
+    this.mimetype = "", this.extension = "", this.receiving = !1, this.chunks = 0, this.data = [], this.valid = !1;
+  }
+}
+class b {
+}
+b.mainButton = 0, b.auxiliaryButton = 1, b.secondaryButton = 2, b.fourthButton = 3, b.fifthButton = 4;
+class k {
+}
+k.primaryButton = 1, k.secondaryButton = 2, k.auxiliaryButton = 4, k.fourthButton = 8, k.fifthButton = 16;
+class V {
+  constructor() {
+    this.unregisterCallbacks = [];
+  }
+  addUnregisterCallback(e) {
+    this.unregisterCallbacks.push(e);
+  }
+  unregisterAll() {
+    for (const e of this.unregisterCallbacks) e();
+    this.unregisterCallbacks = [];
+  }
+}
+class Ut {
+  constructor(e, t, s) {
+    this.touchEventListenerTracker = new V(), this.toStreamerMessagesProvider = e, this.videoElementProvider = t, this.coordinateConverter = s;
+    const n = (d) => this.onTouchStart(d), i = (d) => this.onTouchEnd(d), o = (d) => this.onTouchMove(d);
+    document.addEventListener("touchstart", n, { passive: !1 }), document.addEventListener("touchend", i, { passive: !1 }), document.addEventListener("touchmove", o, { passive: !1 }), this.touchEventListenerTracker.addUnregisterCallback((() => document.removeEventListener("touchstart", n))), this.touchEventListenerTracker.addUnregisterCallback((() => document.removeEventListener("touchend", i))), this.touchEventListenerTracker.addUnregisterCallback((() => document.removeEventListener("touchmove", o)));
+  }
+  unregisterTouchEvents() {
+    this.touchEventListenerTracker.unregisterAll();
+  }
+  setVideoElementParentClientRect(e) {
+    this.videoElementParentClientRect = e;
+  }
+  onTouchStart(e) {
+    if (this.videoElementProvider.isVideoReady() && e.target === this.videoElementProvider.getVideoElement()) {
+      if (this.fakeTouchFinger == null) {
+        const t = e.changedTouches[0];
+        this.fakeTouchFinger = new Gt(t.identifier, t.clientX - this.videoElementParentClientRect.left, t.clientY - this.videoElementParentClientRect.top);
+        const s = this.videoElementProvider.getVideoParentElement(), n = new MouseEvent("mouseenter", t);
+        s.dispatchEvent(n);
+        const i = this.coordinateConverter.normalizeAndQuantizeUnsigned(this.fakeTouchFinger.x, this.fakeTouchFinger.y);
+        this.toStreamerMessagesProvider.toStreamerHandlers.get("MouseDown")([b.mainButton, i.x, i.y]);
+      }
+      e.preventDefault();
+    }
+  }
+  onTouchEnd(e) {
+    if (!this.videoElementProvider.isVideoReady() || this.fakeTouchFinger == null) return;
+    const t = this.videoElementProvider.getVideoParentElement(), s = this.toStreamerMessagesProvider.toStreamerHandlers;
+    for (let n = 0; n < e.changedTouches.length; n++) {
+      const i = e.changedTouches[n];
+      if (i.identifier === this.fakeTouchFinger.id) {
+        const o = i.clientX - this.videoElementParentClientRect.left, d = i.clientY - this.videoElementParentClientRect.top, c = this.coordinateConverter.normalizeAndQuantizeUnsigned(o, d);
+        s.get("MouseUp")([b.mainButton, c.x, c.y]);
+        const m = new MouseEvent("mouseleave", i);
+        t.dispatchEvent(m), this.fakeTouchFinger = null;
+        break;
+      }
+    }
+    e.preventDefault();
+  }
+  onTouchMove(e) {
+    if (!this.videoElementProvider.isVideoReady() || this.fakeTouchFinger == null) return;
+    const t = this.toStreamerMessagesProvider.toStreamerHandlers;
+    for (let s = 0; s < e.touches.length; s++) {
+      const n = e.touches[s];
+      if (n.identifier === this.fakeTouchFinger.id) {
+        const i = n.clientX - this.videoElementParentClientRect.left, o = n.clientY - this.videoElementParentClientRect.top, d = this.coordinateConverter.normalizeAndQuantizeUnsigned(i, o), c = this.coordinateConverter.normalizeAndQuantizeSigned(i - this.fakeTouchFinger.x, o - this.fakeTouchFinger.y);
+        t.get("MouseMove")([d.x, d.y, c.x, c.y]), this.fakeTouchFinger.x = i, this.fakeTouchFinger.y = o;
+        break;
+      }
+    }
+    e.preventDefault();
+  }
+}
+class Gt {
+  constructor(e, t, s) {
+    this.id = e, this.x = t, this.y = s;
+  }
+}
+class L {
+}
+L.backSpace = 8, L.shift = 16, L.control = 17, L.alt = 18, L.rightShift = 253, L.rightControl = 254, L.rightAlt = 255;
+class Bt {
+  constructor(e, t, s) {
+    this.keyboardEventListenerTracker = new V(), this.CodeToKeyCode = { Escape: 27, Digit0: 48, Digit1: 49, Digit2: 50, Digit3: 51, Digit4: 52, Digit5: 53, Digit6: 54, Digit7: 55, Digit8: 56, Digit9: 57, Minus: 173, Equal: 187, Backspace: 8, Tab: 9, KeyQ: 81, KeyW: 87, KeyE: 69, KeyR: 82, KeyT: 84, KeyY: 89, KeyU: 85, KeyI: 73, KeyO: 79, KeyP: 80, BracketLeft: 219, BracketRight: 221, Enter: 13, ControlLeft: 17, KeyA: 65, KeyS: 83, KeyD: 68, KeyF: 70, KeyG: 71, KeyH: 72, KeyJ: 74, KeyK: 75, KeyL: 76, Semicolon: 186, Quote: 222, Backquote: 192, ShiftLeft: 16, Backslash: 220, KeyZ: 90, KeyX: 88, KeyC: 67, KeyV: 86, KeyB: 66, KeyN: 78, KeyM: 77, Comma: 188, Period: 190, Slash: 191, ShiftRight: 253, AltLeft: 18, Space: 32, CapsLock: 20, F1: 112, F2: 113, F3: 114, F4: 115, F5: 116, F6: 117, F7: 118, F8: 119, F9: 120, F10: 121, F11: 122, F12: 123, Pause: 19, ScrollLock: 145, NumpadDivide: 111, NumpadMultiply: 106, NumpadSubtract: 109, NumpadAdd: 107, NumpadDecimal: 110, Numpad9: 105, Numpad8: 104, Numpad7: 103, Numpad6: 102, Numpad5: 101, Numpad4: 100, Numpad3: 99, Numpad2: 98, Numpad1: 97, Numpad0: 96, NumLock: 144, ControlRight: 254, AltRight: 255, Home: 36, End: 35, ArrowUp: 38, ArrowLeft: 37, ArrowRight: 39, ArrowDown: 40, PageUp: 33, PageDown: 34, Insert: 45, Delete: 46, ContextMenu: 93 }, this.toStreamerMessagesProvider = e, this.config = t, this.activeKeysProvider = s;
+  }
+  registerKeyBoardEvents() {
+    const e = (i) => this.handleOnCompositionEnd(i), t = (i) => this.handleOnKeyDown(i), s = (i) => this.handleOnKeyUp(i), n = (i) => this.handleOnKeyPress(i);
+    document.addEventListener("compositionend", e), document.addEventListener("keydown", t), document.addEventListener("keyup", s), document.addEventListener("keypress", n), this.keyboardEventListenerTracker.addUnregisterCallback((() => document.removeEventListener("compositionend", e))), this.keyboardEventListenerTracker.addUnregisterCallback((() => document.removeEventListener("keydown", t))), this.keyboardEventListenerTracker.addUnregisterCallback((() => document.removeEventListener("keyup", s))), this.keyboardEventListenerTracker.addUnregisterCallback((() => document.removeEventListener("keypress", n)));
+  }
+  unregisterKeyBoardEvents() {
+    this.keyboardEventListenerTracker.unregisterAll();
+  }
+  handleOnKeyDown(e) {
+    const t = this.getKeycode(e);
+    t && t !== 229 && (r.Log(r.GetStackTrace(), `key down ${t}, repeat = ${e.repeat}`, 6), this.toStreamerMessagesProvider.toStreamerHandlers.get("KeyDown")([this.getKeycode(e), e.repeat ? 1 : 0]), this.activeKeysProvider.getActiveKeys().push(t), t === L.backSpace && document.dispatchEvent(new KeyboardEvent("keypress", { charCode: L.backSpace })), this.config.isFlagEnabled(l.SuppressBrowserKeys) && this.isKeyCodeBrowserKey(t) && e.preventDefault());
+  }
+  handleOnKeyUp(e) {
+    const t = this.getKeycode(e);
+    t && (r.Log(r.GetStackTrace(), `key up ${t}`, 6), this.toStreamerMessagesProvider.toStreamerHandlers.get("KeyUp")([t]), this.config.isFlagEnabled(l.SuppressBrowserKeys) && this.isKeyCodeBrowserKey(t) && e.preventDefault());
+  }
+  handleOnKeyPress(e) {
+    if (!("charCode" in e)) return void r.Warning(r.GetStackTrace(), "KeyboardEvent.charCode is deprecated in this browser, cannot send key press.");
+    const t = e.charCode;
+    r.Log(r.GetStackTrace(), `key press ${t}`, 6), this.toStreamerMessagesProvider.toStreamerHandlers.get("KeyPress")([t]);
+  }
+  handleOnCompositionEnd(e) {
+    e.data && e.data.length && e.data.split("").forEach(((t) => {
+      this.handleOnKeyDown(new KeyboardEvent("keydown", { keyCode: t.toUpperCase().charCodeAt(0), charCode: t.charCodeAt(0) })), this.handleOnKeyPress(new KeyboardEvent("keypress", { keyCode: t.toUpperCase().charCodeAt(0), charCode: t.charCodeAt(0) })), this.handleOnKeyUp(new KeyboardEvent("keyup", { keyCode: t.toUpperCase().charCodeAt(0), charCode: t.charCodeAt(0) }));
+    }));
+  }
+  getKeycode(e) {
+    if (!("keyCode" in e)) {
+      const t = e;
+      return t.code in this.CodeToKeyCode ? this.CodeToKeyCode[t.code] : (r.Warning(r.GetStackTrace(), `Keyboard code of ${t.code} is not supported in our mapping, ignoring this key.`), null);
+    }
+    return e.keyCode === L.shift && e.code === "ShiftRight" ? L.rightShift : e.keyCode === L.control && e.code === "ControlRight" ? L.rightControl : e.keyCode === L.alt && e.code === "AltRight" ? L.rightAlt : e.keyCode;
+  }
+  isKeyCodeBrowserKey(e) {
+    return e >= 112 && e <= 123 || e === 9;
+  }
+}
+class zt {
+  constructor(e, t, s) {
+    this.x = 0, this.y = 0, this.updateMouseMovePositionEvent = (i) => {
+      this.updateMouseMovePosition(i);
+    }, this.mouseEventListenerTracker = new V(), this.videoElementProvider = e, this.mouseController = t, this.activeKeysProvider = s;
+    const n = this.videoElementProvider.getVideoParentElement();
+    this.x = n.getBoundingClientRect().width / 2, this.y = n.getBoundingClientRect().height / 2, this.coord = this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(this.x, this.y);
+  }
+  unregisterMouseEvents() {
+    this.mouseEventListenerTracker.unregisterAll();
+  }
+  lockStateChange() {
+    const e = this.videoElementProvider.getVideoParentElement(), t = this.mouseController.toStreamerMessagesProvider.toStreamerHandlers;
+    if (document.pointerLockElement === e || document.mozPointerLockElement === e) r.Log(r.GetStackTrace(), "Pointer locked", 6), document.addEventListener("mousemove", this.updateMouseMovePositionEvent, !1), this.mouseEventListenerTracker.addUnregisterCallback((() => document.removeEventListener("mousemove", this.updateMouseMovePositionEvent, !1)));
+    else {
+      r.Log(r.GetStackTrace(), "The pointer lock status is now unlocked", 6), document.removeEventListener("mousemove", this.updateMouseMovePositionEvent, !1);
+      let s = this.activeKeysProvider.getActiveKeys();
+      const n = new Set(s), i = [];
+      n.forEach(((o) => {
+      })), i.forEach(((o) => {
+        t.get("KeyUp")([o]);
+      })), s = [];
+    }
+  }
+  updateMouseMovePosition(e) {
+    if (!this.videoElementProvider.isVideoReady()) return;
+    const t = this.mouseController.toStreamerMessagesProvider.toStreamerHandlers, s = this.videoElementProvider.getVideoParentElement().clientWidth, n = this.videoElementProvider.getVideoParentElement().clientHeight;
+    this.x += e.movementX, this.y += e.movementY, this.x > s && (this.x -= s), this.y > n && (this.y -= n), this.x < 0 && (this.x = s + this.x), this.y < 0 && (this.y = n - this.y), this.coord = this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(this.x, this.y);
+    const i = this.mouseController.coordinateConverter.normalizeAndQuantizeSigned(e.movementX, e.movementY);
+    t.get("MouseMove")([this.coord.x, this.coord.y, i.x, i.y]);
+  }
+  handleMouseDown(e) {
+    this.videoElementProvider.isVideoReady() && this.mouseController.toStreamerMessagesProvider.toStreamerHandlers.get("MouseDown")([e.button, this.coord.x, this.coord.y]);
+  }
+  handleMouseUp(e) {
+    this.videoElementProvider.isVideoReady() && this.mouseController.toStreamerMessagesProvider.toStreamerHandlers.get("MouseUp")([e.button, this.coord.x, this.coord.y]);
+  }
+  handleMouseWheel(e) {
+    this.videoElementProvider.isVideoReady() && this.mouseController.toStreamerMessagesProvider.toStreamerHandlers.get("MouseWheel")([e.wheelDelta, this.coord.x, this.coord.y]);
+  }
+  handleMouseDouble(e) {
+    this.videoElementProvider.isVideoReady() && this.mouseController.toStreamerMessagesProvider.toStreamerHandlers.get("MouseDouble")([e.button, this.coord.x, this.coord.y]);
+  }
+  handlePressMouseButtons(e) {
+    this.videoElementProvider.isVideoReady() && this.mouseController.pressMouseButtons(e.buttons, this.x, this.y);
+  }
+  handleReleaseMouseButtons(e) {
+    this.videoElementProvider.isVideoReady() && this.mouseController.releaseMouseButtons(e.buttons, this.x, this.y);
+  }
+}
+class _t {
+  constructor(e) {
+    this.mouseController = e;
+  }
+  unregisterMouseEvents() {
+  }
+  updateMouseMovePosition(e) {
+    if (!this.mouseController.videoElementProvider.isVideoReady()) return;
+    r.Log(r.GetStackTrace(), "MouseMove", 6);
+    const t = this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(e.offsetX, e.offsetY), s = this.mouseController.coordinateConverter.normalizeAndQuantizeSigned(e.movementX, e.movementY);
+    this.mouseController.toStreamerMessagesProvider.toStreamerHandlers.get("MouseMove")([t.x, t.y, s.x, s.y]), e.preventDefault();
+  }
+  handleMouseDown(e) {
+    if (!this.mouseController.videoElementProvider.isVideoReady()) return;
+    r.Log(r.GetStackTrace(), "onMouse Down", 6);
+    const t = this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(e.offsetX, e.offsetY);
+    this.mouseController.toStreamerMessagesProvider.toStreamerHandlers.get("MouseDown")([e.button, t.x, t.y]), e.preventDefault();
+  }
+  handleMouseUp(e) {
+    if (!this.mouseController.videoElementProvider.isVideoReady()) return;
+    r.Log(r.GetStackTrace(), "onMouse Up", 6);
+    const t = this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(e.offsetX, e.offsetY);
+    this.mouseController.toStreamerMessagesProvider.toStreamerHandlers.get("MouseUp")([e.button, t.x, t.y]), e.preventDefault();
+  }
+  handleContextMenu(e) {
+    this.mouseController.videoElementProvider.isVideoReady() && e.preventDefault();
+  }
+  handleMouseWheel(e) {
+    if (!this.mouseController.videoElementProvider.isVideoReady()) return;
+    const t = this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(e.offsetX, e.offsetY);
+    this.mouseController.toStreamerMessagesProvider.toStreamerHandlers.get("MouseWheel")([e.wheelDelta, t.x, t.y]), e.preventDefault();
+  }
+  handleMouseDouble(e) {
+    if (!this.mouseController.videoElementProvider.isVideoReady()) return;
+    const t = this.mouseController.coordinateConverter.normalizeAndQuantizeUnsigned(e.offsetX, e.offsetY);
+    this.mouseController.toStreamerMessagesProvider.toStreamerHandlers.get("MouseDouble")([e.button, t.x, t.y]);
+  }
+  handlePressMouseButtons(e) {
+    this.mouseController.videoElementProvider.isVideoReady() && (r.Log(r.GetStackTrace(), "onMouse press", 6), this.mouseController.pressMouseButtons(e.buttons, e.offsetX, e.offsetY));
+  }
+  handleReleaseMouseButtons(e) {
+    this.mouseController.videoElementProvider.isVideoReady() && (r.Log(r.GetStackTrace(), "onMouse release", 6), this.mouseController.releaseMouseButtons(e.buttons, e.offsetX, e.offsetY));
+  }
+}
+class Vt {
+  constructor(e, t, s, n) {
+    this.mouseEventListenerTracker = new V(), this.toStreamerMessagesProvider = e, this.coordinateConverter = s, this.videoElementProvider = t, this.activeKeysProvider = n, this.registerMouseEnterAndLeaveEvents();
+  }
+  unregisterMouseEvents() {
+    this.mouseEventListenerTracker.unregisterAll();
+  }
+  registerLockedMouseEvents(e) {
+    const t = this.videoElementProvider.getVideoParentElement(), s = new zt(this.videoElementProvider, e, this.activeKeysProvider);
+    if (t.requestPointerLock = t.requestPointerLock || t.mozRequestPointerLock, document.exitPointerLock = document.exitPointerLock || document.mozExitPointerLock, t.requestPointerLock) {
+      const m = () => {
+        t.requestPointerLock();
+      };
+      t.addEventListener("click", m), this.mouseEventListenerTracker.addUnregisterCallback((() => t.removeEventListener("click", m)));
+    }
+    const n = () => s.lockStateChange();
+    document.addEventListener("pointerlockchange", n, !1), document.addEventListener("mozpointerlockchange", n, !1), this.mouseEventListenerTracker.addUnregisterCallback((() => document.removeEventListener("pointerlockchange", n, !1))), this.mouseEventListenerTracker.addUnregisterCallback((() => document.removeEventListener("mozpointerlockchange", n, !1)));
+    const i = (m) => s.handleMouseDown(m), o = (m) => s.handleMouseUp(m), d = (m) => s.handleMouseWheel(m), c = (m) => s.handleMouseDouble(m);
+    t.addEventListener("mousedown", i), t.addEventListener("mouseup", o), t.addEventListener("wheel", d), t.addEventListener("dblclick", c), this.mouseEventListenerTracker.addUnregisterCallback((() => t.removeEventListener("mousedown", i))), this.mouseEventListenerTracker.addUnregisterCallback((() => t.removeEventListener("mouseup", o))), this.mouseEventListenerTracker.addUnregisterCallback((() => t.removeEventListener("wheel", d))), this.mouseEventListenerTracker.addUnregisterCallback((() => t.removeEventListener("dblclick", c))), this.mouseEventListenerTracker.addUnregisterCallback((() => s.unregisterMouseEvents())), this.mouseEventListenerTracker.addUnregisterCallback((() => {
+      !document.exitPointerLock || document.pointerLockElement !== t && document.mozPointerLockElement !== t || document.exitPointerLock();
+    }));
+  }
+  registerHoveringMouseEvents(e) {
+    const t = this.videoElementProvider.getVideoParentElement(), s = new _t(e), n = (u) => s.updateMouseMovePosition(u), i = (u) => s.handleMouseDown(u), o = (u) => s.handleMouseUp(u), d = (u) => s.handleContextMenu(u), c = (u) => s.handleMouseWheel(u), m = (u) => s.handleMouseDouble(u);
+    t.addEventListener("mousemove", n), t.addEventListener("mousedown", i), t.addEventListener("mouseup", o), t.addEventListener("contextmenu", d), t.addEventListener("wheel", c), t.addEventListener("dblclick", m), this.mouseEventListenerTracker.addUnregisterCallback((() => t.removeEventListener("mousemove", n))), this.mouseEventListenerTracker.addUnregisterCallback((() => t.removeEventListener("mousedown", i))), this.mouseEventListenerTracker.addUnregisterCallback((() => t.removeEventListener("mouseup", o))), this.mouseEventListenerTracker.addUnregisterCallback((() => t.removeEventListener("contextmenu", d))), this.mouseEventListenerTracker.addUnregisterCallback((() => t.removeEventListener("wheel", c))), this.mouseEventListenerTracker.addUnregisterCallback((() => t.removeEventListener("dblclick", m))), this.mouseEventListenerTracker.addUnregisterCallback((() => s.unregisterMouseEvents()));
+  }
+  registerMouseEnterAndLeaveEvents() {
+    const e = this.videoElementProvider.getVideoParentElement(), t = (n) => {
+      this.videoElementProvider.isVideoReady() && (r.Log(r.GetStackTrace(), "Mouse Entered", 6), this.sendMouseEnter(), this.pressMouseButtons(n.buttons, n.x, n.y));
+    }, s = (n) => {
+      this.videoElementProvider.isVideoReady() && (r.Log(r.GetStackTrace(), "Mouse Left", 6), this.sendMouseLeave(), this.releaseMouseButtons(n.buttons, n.x, n.y));
+    };
+    e.addEventListener("mouseenter", t), e.addEventListener("mouseleave", s), this.mouseEventListenerTracker.addUnregisterCallback((() => e.removeEventListener("mouseenter", t))), this.mouseEventListenerTracker.addUnregisterCallback((() => e.removeEventListener("mouseleave", s)));
+  }
+  releaseMouseButtons(e, t, s) {
+    const n = this.coordinateConverter.normalizeAndQuantizeUnsigned(t, s);
+    e & k.primaryButton && this.sendMouseUp(b.mainButton, n.x, n.y), e & k.secondaryButton && this.sendMouseUp(b.secondaryButton, n.x, n.y), e & k.auxiliaryButton && this.sendMouseUp(b.auxiliaryButton, n.x, n.y), e & k.fourthButton && this.sendMouseUp(b.fourthButton, n.x, n.y), e & k.fifthButton && this.sendMouseUp(b.fifthButton, n.x, n.y);
+  }
+  pressMouseButtons(e, t, s) {
+    if (!this.videoElementProvider.isVideoReady()) return;
+    const n = this.coordinateConverter.normalizeAndQuantizeUnsigned(t, s);
+    e & k.primaryButton && this.sendMouseDown(b.mainButton, n.x, n.y), e & k.secondaryButton && this.sendMouseDown(b.secondaryButton, n.x, n.y), e & k.auxiliaryButton && this.sendMouseDown(b.auxiliaryButton, n.x, n.y), e & k.fourthButton && this.sendMouseDown(b.fourthButton, n.x, n.y), e & k.fifthButton && this.sendMouseDown(b.fifthButton, n.x, n.y);
+  }
+  sendMouseEnter() {
+    this.videoElementProvider.isVideoReady() && this.toStreamerMessagesProvider.toStreamerHandlers.get("MouseEnter")();
+  }
+  sendMouseLeave() {
+    this.videoElementProvider.isVideoReady() && this.toStreamerMessagesProvider.toStreamerHandlers.get("MouseLeave")();
+  }
+  sendMouseDown(e, t, s) {
+    this.videoElementProvider.isVideoReady() && (r.Log(r.GetStackTrace(), `mouse button ${e} down at (${t}, ${s})`, 6), this.toStreamerMessagesProvider.toStreamerHandlers.get("MouseDown")([e, t, s]));
+  }
+  sendMouseUp(e, t, s) {
+    if (!this.videoElementProvider.isVideoReady()) return;
+    r.Log(r.GetStackTrace(), `mouse button ${e} up at (${t}, ${s})`, 6);
+    const n = this.coordinateConverter.normalizeAndQuantizeUnsigned(t, s);
+    this.toStreamerMessagesProvider.toStreamerHandlers.get("MouseUp")([e, n.x, n.y]);
+  }
+}
+class Ht {
+  constructor(e, t, s) {
+    this.fingers = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0], this.fingerIds = /* @__PURE__ */ new Map(), this.maxByteValue = 255, this.touchEventListenerTracker = new V(), this.toStreamerMessagesProvider = e, this.videoElementProvider = t, this.coordinateConverter = s, this.videoElementParent = t.getVideoElement();
+    const n = (c) => this.onTouchStart(c), i = (c) => this.onTouchEnd(c), o = (c) => this.onTouchMove(c);
+    this.videoElementParent.addEventListener("touchstart", n), this.videoElementParent.addEventListener("touchend", i), this.videoElementParent.addEventListener("touchmove", o), this.touchEventListenerTracker.addUnregisterCallback((() => this.videoElementParent.removeEventListener("touchstart", n))), this.touchEventListenerTracker.addUnregisterCallback((() => this.videoElementParent.removeEventListener("touchend", i))), this.touchEventListenerTracker.addUnregisterCallback((() => this.videoElementParent.removeEventListener("touchmove", o))), r.Log(r.GetStackTrace(), "Touch Events Registered", 6);
+    const d = (c) => {
+      c.preventDefault();
+    };
+    document.addEventListener("touchmove", d), this.touchEventListenerTracker.addUnregisterCallback((() => document.removeEventListener("touchmove", d)));
+  }
+  unregisterTouchEvents() {
+    this.touchEventListenerTracker.unregisterAll();
+  }
+  rememberTouch(e) {
+    const t = this.fingers.pop();
+    t === void 0 && r.Log(r.GetStackTrace(), "exhausted touch identifiers", 6), this.fingerIds.set(e.identifier, t);
+  }
+  forgetTouch(e) {
+    this.fingers.push(this.fingerIds.get(e.identifier)), this.fingers.sort((function(t, s) {
+      return s - t;
+    })), this.fingerIds.delete(e.identifier);
+  }
+  onTouchStart(e) {
+    if (this.videoElementProvider.isVideoReady()) {
+      for (let t = 0; t < e.changedTouches.length; t++) this.rememberTouch(e.changedTouches[t]);
+      r.Log(r.GetStackTrace(), "touch start", 6), this.emitTouchData("TouchStart", e.changedTouches), e.preventDefault();
+    }
+  }
+  onTouchEnd(e) {
+    if (this.videoElementProvider.isVideoReady()) {
+      r.Log(r.GetStackTrace(), "touch end", 6), this.emitTouchData("TouchEnd", e.changedTouches);
+      for (let t = 0; t < e.changedTouches.length; t++) this.forgetTouch(e.changedTouches[t]);
+      e.preventDefault();
+    }
+  }
+  onTouchMove(e) {
+    this.videoElementProvider.isVideoReady() && (r.Log(r.GetStackTrace(), "touch move", 6), this.emitTouchData("TouchMove", e.touches), e.preventDefault());
+  }
+  emitTouchData(e, t) {
+    if (!this.videoElementProvider.isVideoReady()) return;
+    const s = this.videoElementProvider.getVideoParentElement().getBoundingClientRect(), n = this.toStreamerMessagesProvider.toStreamerHandlers;
+    for (let i = 0; i < t.length; i++) {
+      const d = t[i], c = d.clientX - s.left, m = d.clientY - s.top;
+      r.Log(r.GetStackTrace(), `F${this.fingerIds.get(d.identifier)}=(${c}, ${m})`, 6);
+      const u = this.coordinateConverter.normalizeAndQuantizeUnsigned(c, m);
+      switch (e) {
+        case "TouchStart":
+          n.get("TouchStart")([1, u.x, u.y, this.fingerIds.get(d.identifier), this.maxByteValue * (d.force > 0 ? d.force : 1), u.inRange ? 1 : 0]);
+          break;
+        case "TouchEnd":
+          n.get("TouchEnd")([1, u.x, u.y, this.fingerIds.get(d.identifier), this.maxByteValue * d.force, u.inRange ? 1 : 0]);
+          break;
+        case "TouchMove":
+          n.get("TouchMove")([1, u.x, u.y, this.fingerIds.get(d.identifier), this.maxByteValue * (d.force > 0 ? d.force : 1), u.inRange ? 1 : 0]);
+      }
+    }
+  }
+}
+class Wt {
+  constructor(e) {
+    this.gamePadEventListenerTracker = new V(), this.toStreamerMessagesProvider = e, this.requestAnimationFrame = (window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame || window.requestAnimationFrame).bind(window);
+    const t = window;
+    if (window.addEventListener("beforeunload", ((s) => this.onBeforeUnload(s))), "GamepadEvent" in t) {
+      const s = (i) => this.gamePadConnectHandler(i), n = (i) => this.gamePadDisconnectHandler(i);
+      window.addEventListener("gamepadconnected", s), window.addEventListener("gamepaddisconnected", n), this.gamePadEventListenerTracker.addUnregisterCallback((() => window.removeEventListener("gamepadconnected", s))), this.gamePadEventListenerTracker.addUnregisterCallback((() => window.removeEventListener("gamepaddisconnected", n)));
+    } else if ("WebKitGamepadEvent" in t) {
+      const s = (i) => this.gamePadConnectHandler(i), n = (i) => this.gamePadDisconnectHandler(i);
+      window.addEventListener("webkitgamepadconnected", s), window.addEventListener("webkitgamepaddisconnected", n), this.gamePadEventListenerTracker.addUnregisterCallback((() => window.removeEventListener("webkitgamepadconnected", s))), this.gamePadEventListenerTracker.addUnregisterCallback((() => window.removeEventListener("webkitgamepaddisconnected", n)));
+    }
+    if (this.controllers = [], navigator.getGamepads) for (const s of navigator.getGamepads()) s && this.gamePadConnectHandler(new GamepadEvent("gamepadconnected", { gamepad: s }));
+  }
+  unregisterGamePadEvents() {
+    this.gamePadEventListenerTracker.unregisterAll();
+    for (const e of this.controllers) e.id !== void 0 && this.onGamepadDisconnected(e.id);
+    this.controllers = [], this.onGamepadConnected = () => {
+    }, this.onGamepadDisconnected = () => {
+    };
+  }
+  gamePadConnectHandler(e) {
+    r.Log(r.GetStackTrace(), "Gamepad connect handler", 6);
+    const t = e.gamepad, s = { currentState: t, prevState: t, id: void 0 };
+    this.controllers.push(s), this.controllers[t.index].currentState = t, this.controllers[t.index].prevState = t, r.Log(r.GetStackTrace(), "gamepad: " + t.id + " connected", 6), window.requestAnimationFrame((() => this.updateStatus())), this.onGamepadConnected();
+  }
+  gamePadDisconnectHandler(e) {
+    r.Log(r.GetStackTrace(), "Gamepad disconnect handler", 6), r.Log(r.GetStackTrace(), "gamepad: " + e.gamepad.id + " disconnected", 6);
+    const t = this.controllers[e.gamepad.index];
+    delete this.controllers[e.gamepad.index], this.controllers = this.controllers.filter(((s) => s !== void 0)), this.onGamepadDisconnected(t.id);
+  }
+  scanGamePads() {
+    const e = navigator.getGamepads ? navigator.getGamepads() : navigator.webkitGetGamepads ? navigator.webkitGetGamepads() : [];
+    for (let t = 0; t < e.length; t++) e[t] && e[t].index in this.controllers && (this.controllers[e[t].index].currentState = e[t]);
+  }
+  updateStatus() {
+    this.scanGamePads();
+    const e = this.toStreamerMessagesProvider.toStreamerHandlers;
+    for (const t of this.controllers) {
+      const s = t.id === void 0 ? this.controllers.indexOf(t) : t.id, n = t.currentState;
+      for (let i = 0; i < t.currentState.buttons.length; i++) {
+        const o = t.currentState.buttons[i], d = t.prevState.buttons[i];
+        o.pressed ? i == _.LeftTrigger ? e.get("GamepadAnalog")([s, 5, o.value]) : i == _.RightTrigger ? e.get("GamepadAnalog")([s, 6, o.value]) : e.get("GamepadButtonPressed")([s, i, d.pressed ? 1 : 0]) : !o.pressed && d.pressed && (i == _.LeftTrigger ? e.get("GamepadAnalog")([s, 5, 0]) : i == _.RightTrigger ? e.get("GamepadAnalog")([s, 6, 0]) : e.get("GamepadButtonReleased")([s, i, 0]));
+      }
+      for (let i = 0; i < n.axes.length; i += 2) {
+        const o = parseFloat(n.axes[i].toFixed(4)), d = -parseFloat(n.axes[i + 1].toFixed(4));
+        e.get("GamepadAnalog")([s, i + 1, o]), e.get("GamepadAnalog")([s, i + 2, d]);
+      }
+      this.controllers[s].prevState = n;
+    }
+    this.controllers.length > 0 && this.requestAnimationFrame((() => this.updateStatus()));
+  }
+  onGamepadResponseReceived(e) {
+    for (const t of this.controllers) if (t.id === void 0) {
+      t.id = e;
+      break;
+    }
+  }
+  onGamepadConnected() {
+  }
+  onGamepadDisconnected(e) {
+  }
+  onBeforeUnload(e) {
+    for (const t of this.controllers) this.onGamepadDisconnected(t.id);
+  }
+}
+(function(a) {
+  a[a.RightClusterBottomButton = 0] = "RightClusterBottomButton", a[a.RightClusterRightButton = 1] = "RightClusterRightButton", a[a.RightClusterLeftButton = 2] = "RightClusterLeftButton", a[a.RightClusterTopButton = 3] = "RightClusterTopButton", a[a.LeftShoulder = 4] = "LeftShoulder", a[a.RightShoulder = 5] = "RightShoulder", a[a.LeftTrigger = 6] = "LeftTrigger", a[a.RightTrigger = 7] = "RightTrigger", a[a.SelectOrBack = 8] = "SelectOrBack", a[a.StartOrForward = 9] = "StartOrForward", a[a.LeftAnalogPress = 10] = "LeftAnalogPress", a[a.RightAnalogPress = 11] = "RightAnalogPress", a[a.LeftClusterTopButton = 12] = "LeftClusterTopButton", a[a.LeftClusterBottomButton = 13] = "LeftClusterBottomButton", a[a.LeftClusterLeftButton = 14] = "LeftClusterLeftButton", a[a.LeftClusterRightButton = 15] = "LeftClusterRightButton", a[a.CentreButton = 16] = "CentreButton", a[a.LeftStickHorizontal = 0] = "LeftStickHorizontal", a[a.LeftStickVertical = 1] = "LeftStickVertical", a[a.RightStickHorizontal = 2] = "RightStickHorizontal", a[a.RightStickVertical = 3] = "RightStickVertical";
+})(_ || (_ = {}));
+class Nt {
+  constructor(e, t, s) {
+    this.activeKeys = new Kt(), this.toStreamerMessagesProvider = e, this.videoElementProvider = t, this.coordinateConverter = s;
+  }
+  registerKeyBoard(e) {
+    r.Log(r.GetStackTrace(), "Register Keyboard Events", 7);
+    const t = new Bt(this.toStreamerMessagesProvider, e, this.activeKeys);
+    return t.registerKeyBoardEvents(), t;
+  }
+  registerMouse(e) {
+    r.Log(r.GetStackTrace(), "Register Mouse Events", 7);
+    const t = new Vt(this.toStreamerMessagesProvider, this.videoElementProvider, this.coordinateConverter, this.activeKeys);
+    switch (e) {
+      case B.LockedMouse:
+        t.registerLockedMouseEvents(t);
+        break;
+      case B.HoveringMouse:
+        t.registerHoveringMouseEvents(t);
+        break;
+      default:
+        r.Info(r.GetStackTrace(), "unknown Control Scheme Type Defaulting to Locked Mouse Events"), t.registerLockedMouseEvents(t);
+    }
+    return t;
+  }
+  registerTouch(e, t) {
+    if (r.Log(r.GetStackTrace(), "Registering Touch", 6), e) {
+      const s = new Ut(this.toStreamerMessagesProvider, this.videoElementProvider, this.coordinateConverter);
+      return s.setVideoElementParentClientRect(t), s;
+    }
+    return new Ht(this.toStreamerMessagesProvider, this.videoElementProvider, this.coordinateConverter);
+  }
+  registerGamePad() {
+    return r.Log(r.GetStackTrace(), "Register Game Pad", 7), new Wt(this.toStreamerMessagesProvider);
+  }
+}
+class Kt {
+  constructor() {
+    this.activeKeys = [], this.activeKeys = [];
+  }
+  getActiveKeys() {
+    return this.activeKeys;
+  }
+}
+class Qt {
+  constructor(e, t) {
+    this.lastTimeResized = (/* @__PURE__ */ new Date()).getTime(), this.videoElement = document.createElement("video"), this.config = t, this.videoElement.id = "streamingVideo", this.videoElement.disablePictureInPicture = !0, this.videoElement.playsInline = !0, this.videoElement.style.width = "100%", this.videoElement.style.height = "100%", this.videoElement.style.position = "absolute", this.videoElement.style.pointerEvents = "all", e.appendChild(this.videoElement), this.onResizePlayerCallback = () => {
+      console.log("Resolution changed, restyling player, did you forget to override this function?");
+    }, this.onMatchViewportResolutionCallback = () => {
+      console.log("Resolution changed and match viewport resolution is turned on, did you forget to override this function?");
+    }, this.videoElement.onclick = () => {
+      this.audioElement != null && this.audioElement.paused && this.audioElement.play(), this.videoElement.paused && this.videoElement.play();
+    }, this.videoElement.onloadedmetadata = () => {
+      this.onVideoInitialized();
+    }, window.addEventListener("resize", (() => this.resizePlayerStyle()), !0), window.addEventListener("orientationchange", (() => this.onOrientationChange()));
+  }
+  setAudioElement(e) {
+    this.audioElement = e;
+  }
+  play() {
+    return this.videoElement.muted = this.config.isFlagEnabled(l.StartVideoMuted), this.videoElement.autoplay = this.config.isFlagEnabled(l.AutoPlayVideo), this.videoElement.play();
+  }
+  isPaused() {
+    return this.videoElement.paused;
+  }
+  isVideoReady() {
+    return this.videoElement.readyState !== void 0 && this.videoElement.readyState > 0;
+  }
+  hasVideoSource() {
+    return this.videoElement.srcObject !== void 0 && this.videoElement.srcObject !== null;
+  }
+  getVideoElement() {
+    return this.videoElement;
+  }
+  getVideoParentElement() {
+    return this.videoElement.parentElement;
+  }
+  setVideoEnabled(e) {
+    this.videoElement.srcObject.getTracks().forEach(((t) => t.enabled = e));
+  }
+  onVideoInitialized() {
+  }
+  onOrientationChange() {
+    clearTimeout(this.orientationChangeTimeout), this.orientationChangeTimeout = window.setTimeout((() => {
+      this.resizePlayerStyle();
+    }), 500);
+  }
+  resizePlayerStyle() {
+    const e = this.getVideoParentElement();
+    e && (this.updateVideoStreamSize(), e.classList.contains("fixed-size") || this.resizePlayerStyleToFillParentElement(), this.onResizePlayerCallback());
+  }
+  resizePlayerStyleToFillParentElement() {
+    this.getVideoParentElement().setAttribute("style", "top: 0px; left: 0px; width: 100%; height: 100%; cursor: default;");
+  }
+  updateVideoStreamSize() {
+    if (this.config.isFlagEnabled(l.MatchViewportResolution)) if ((/* @__PURE__ */ new Date()).getTime() - this.lastTimeResized > 300) {
+      const e = this.getVideoParentElement();
+      if (!e) return;
+      this.onMatchViewportResolutionCallback(e.clientWidth, e.clientHeight), this.lastTimeResized = (/* @__PURE__ */ new Date()).getTime();
+    } else r.Log(r.GetStackTrace(), "Resizing too often - skipping", 6), clearTimeout(this.resizeTimeoutHandle), this.resizeTimeoutHandle = window.setTimeout((() => this.updateVideoStreamSize()), 100);
+  }
+}
+class qt {
+  constructor() {
+    this.toStreamerHandlers = /* @__PURE__ */ new Map(), this.fromStreamerHandlers = /* @__PURE__ */ new Map(), this.toStreamerMessages = /* @__PURE__ */ new Map(), this.fromStreamerMessages = /* @__PURE__ */ new Map();
+  }
+  populateDefaultProtocol() {
+    this.toStreamerMessages.set("IFrameRequest", { id: 0, structure: [] }), this.toStreamerMessages.set("RequestQualityControl", { id: 1, structure: [] }), this.toStreamerMessages.set("FpsRequest", { id: 2, structure: [] }), this.toStreamerMessages.set("AverageBitrateRequest", { id: 3, structure: [] }), this.toStreamerMessages.set("StartStreaming", { id: 4, structure: [] }), this.toStreamerMessages.set("StopStreaming", { id: 5, structure: [] }), this.toStreamerMessages.set("LatencyTest", { id: 6, structure: ["string"] }), this.toStreamerMessages.set("RequestInitialSettings", { id: 7, structure: [] }), this.toStreamerMessages.set("TestEcho", { id: 8, structure: [] }), this.toStreamerMessages.set("DataChannelLatencyTest", { id: 9, structure: [] }), this.toStreamerMessages.set("UIInteraction", { id: 50, structure: ["string"] }), this.toStreamerMessages.set("Command", { id: 51, structure: ["string"] }), this.toStreamerMessages.set("KeyDown", { id: 60, structure: ["uint8", "uint8"] }), this.toStreamerMessages.set("KeyUp", { id: 61, structure: ["uint8"] }), this.toStreamerMessages.set("KeyPress", { id: 62, structure: ["uint16"] }), this.toStreamerMessages.set("MouseEnter", { id: 70, structure: [] }), this.toStreamerMessages.set("MouseLeave", { id: 71, structure: [] }), this.toStreamerMessages.set("MouseDown", { id: 72, structure: ["uint8", "uint16", "uint16"] }), this.toStreamerMessages.set("MouseUp", { id: 73, structure: ["uint8", "uint16", "uint16"] }), this.toStreamerMessages.set("MouseMove", { id: 74, structure: ["uint16", "uint16", "int16", "int16"] }), this.toStreamerMessages.set("MouseWheel", { id: 75, structure: ["int16", "uint16", "uint16"] }), this.toStreamerMessages.set("MouseDouble", { id: 76, structure: ["uint8", "uint16", "uint16"] }), this.toStreamerMessages.set("TouchStart", { id: 80, structure: ["uint8", "uint16", "uint16", "uint8", "uint8", "uint8"] }), this.toStreamerMessages.set("TouchEnd", { id: 81, structure: ["uint8", "uint16", "uint16", "uint8", "uint8", "uint8"] }), this.toStreamerMessages.set("TouchMove", { id: 82, structure: ["uint8", "uint16", "uint16", "uint8", "uint8", "uint8"] }), this.toStreamerMessages.set("GamepadConnected", { id: 93, structure: [] }), this.toStreamerMessages.set("GamepadButtonPressed", { id: 90, structure: ["uint8", "uint8", "uint8"] }), this.toStreamerMessages.set("GamepadButtonReleased", { id: 91, structure: ["uint8", "uint8", "uint8"] }), this.toStreamerMessages.set("GamepadAnalog", { id: 92, structure: ["uint8", "uint8", "double"] }), this.toStreamerMessages.set("GamepadDisconnected", { id: 94, structure: ["uint8"] }), this.fromStreamerMessages.set(0, "QualityControlOwnership"), this.fromStreamerMessages.set(1, "Response"), this.fromStreamerMessages.set(2, "Command"), this.fromStreamerMessages.set(3, "FreezeFrame"), this.fromStreamerMessages.set(4, "UnfreezeFrame"), this.fromStreamerMessages.set(5, "VideoEncoderAvgQP"), this.fromStreamerMessages.set(6, "LatencyTest"), this.fromStreamerMessages.set(7, "InitialSettings"), this.fromStreamerMessages.set(8, "FileExtension"), this.fromStreamerMessages.set(9, "FileMimeType"), this.fromStreamerMessages.set(10, "FileContents"), this.fromStreamerMessages.set(11, "TestEcho"), this.fromStreamerMessages.set(12, "InputControlOwnership"), this.fromStreamerMessages.set(13, "GamepadResponse"), this.fromStreamerMessages.set(14, "DataChannelLatencyTest"), this.fromStreamerMessages.set(255, "Protocol");
+  }
+  registerMessageHandler(e, t, s) {
+    switch (e) {
+      case p.ToStreamer:
+        this.toStreamerHandlers.set(t, s);
+        break;
+      case p.FromStreamer:
+        this.fromStreamerHandlers.set(t, s);
+        break;
+      default:
+        r.Log(r.GetStackTrace(), `Unknown message direction ${e}`);
+    }
+  }
+}
+(function(a) {
+  a[a.ToStreamer = 0] = "ToStreamer", a[a.FromStreamer = 1] = "FromStreamer";
+})(p || (p = {}));
+class $t {
+  constructor() {
+    this.responseEventListeners = /* @__PURE__ */ new Map();
+  }
+  addResponseEventListener(e, t) {
+    this.responseEventListeners.set(e, t);
+  }
+  removeResponseEventListener(e) {
+    this.responseEventListeners.delete(e);
+  }
+  onResponse(e) {
+    r.Log(r.GetStackTrace(), "DataChannelReceiveMessageType.Response", 6);
+    const t = new TextDecoder("utf-16").decode(e.slice(1));
+    r.Log(r.GetStackTrace(), t, 6), this.responseEventListeners.forEach(((s) => {
+      s(t);
+    }));
+  }
+}
+class jt {
+  constructor(e, t) {
+    this.dataChannelSender = e, this.toStreamerMessagesMapProvider = t;
+  }
+  sendMessageToStreamer(e, t) {
+    t === void 0 && (t = []);
+    const s = this.toStreamerMessagesMapProvider.toStreamerMessages.get(e);
+    if (s === void 0) return void r.Error(r.GetStackTrace(), `Attempted to send a message to the streamer with message type: ${e}, but the frontend hasn't been configured to send such a message. Check you've added the message type in your cpp`);
+    if (s.structure && t && s.structure.length !== t.length) return void r.Error(r.GetStackTrace(), `Provided message data doesn't match expected layout. Expected [ ${s.structure.map(((c) => {
+      switch (c) {
+        case "uint8":
+        case "uint16":
+        case "int16":
+        case "float":
+        case "double":
+          return "number";
+        case "string":
+          return "string";
+      }
+    })).toString()} ] but received [ ${t.map(((c) => typeof c)).toString()} ]`);
+    let n = 0;
+    const i = new TextEncoder();
+    t.forEach(((c, m) => {
+      switch (s.structure[m]) {
+        case "uint8":
+          n += 1;
+          break;
+        case "uint16":
+        case "int16":
+          n += 2;
+          break;
+        case "float":
+          n += 4;
+          break;
+        case "double":
+          n += 8;
+          break;
+        case "string":
+          n += 2, n += 2 * i.encode(c).length;
+      }
+    }));
+    const o = new DataView(new ArrayBuffer(n + 1));
+    o.setUint8(0, s.id);
+    let d = 1;
+    t.forEach(((c, m) => {
+      switch (s.structure[m]) {
+        case "uint8":
+          o.setUint8(d, c), d += 1;
+          break;
+        case "uint16":
+          o.setUint16(d, c, !0), d += 2;
+          break;
+        case "int16":
+          o.setInt16(d, c, !0), d += 2;
+          break;
+        case "float":
+          o.setFloat32(d, c, !0), d += 4;
+          break;
+        case "double":
+          o.setFloat64(d, c, !0), d += 8;
+          break;
+        case "string":
+          o.setUint16(d, c.length, !0), d += 2;
+          for (let u = 0; u < c.length; u++) o.setUint16(d, c.charCodeAt(u), !0), d += 2;
+      }
+    })), this.dataChannelSender.canSend() ? this.dataChannelSender.sendData(o.buffer) : r.Info(r.GetStackTrace(), `Data channel cannot send yet, skipping sending message: ${e} - ${new Uint8Array(o.buffer)}`);
+  }
+}
+class Xt {
+  constructor(e) {
+    this.sendMessageController = e;
+  }
+  SendRequestQualityControl() {
+    this.sendMessageController.sendMessageToStreamer("RequestQualityControl");
+  }
+  SendMaxFpsRequest() {
+    this.sendMessageController.sendMessageToStreamer("FpsRequest");
+  }
+  SendAverageBitrateRequest() {
+    this.sendMessageController.sendMessageToStreamer("AverageBitrateRequest");
+  }
+  SendStartStreaming() {
+    this.sendMessageController.sendMessageToStreamer("StartStreaming");
+  }
+  SendStopStreaming() {
+    this.sendMessageController.sendMessageToStreamer("StopStreaming");
+  }
+  SendRequestInitialSettings() {
+    this.sendMessageController.sendMessageToStreamer("RequestInitialSettings");
+  }
+}
+class Jt {
+  constructor(e) {
+    this.dataChannelProvider = e;
+  }
+  canSend() {
+    return this.dataChannelProvider.getDataChannelInstance().dataChannel !== void 0 && this.dataChannelProvider.getDataChannelInstance().dataChannel.readyState == "open";
+  }
+  sendData(e) {
+    const t = this.dataChannelProvider.getDataChannelInstance();
+    t.dataChannel.readyState == "open" ? (t.dataChannel.send(e), r.Log(r.GetStackTrace(), `Message Sent: ${new Uint8Array(e)}`, 6), this.resetAfkWarningTimerOnDataSend()) : r.Error(r.GetStackTrace(), `Message Failed: ${new Uint8Array(e)}`);
+  }
+  resetAfkWarningTimerOnDataSend() {
+  }
+}
+class Yt {
+  constructor(e) {
+    this.videoElementProvider = e, this.normalizeAndQuantizeUnsignedFunc = () => {
+      throw new Error("Normalize and quantize unsigned, method not implemented.");
+    }, this.normalizeAndQuantizeSignedFunc = () => {
+      throw new Error("Normalize and unquantize signed, method not implemented.");
+    }, this.denormalizeAndUnquantizeUnsignedFunc = () => {
+      throw new Error("Denormalize and unquantize unsigned, method not implemented.");
+    };
+  }
+  normalizeAndQuantizeUnsigned(e, t) {
+    return this.normalizeAndQuantizeUnsignedFunc(e, t);
+  }
+  unquantizeAndDenormalizeUnsigned(e, t) {
+    return this.denormalizeAndUnquantizeUnsignedFunc(e, t);
+  }
+  normalizeAndQuantizeSigned(e, t) {
+    return this.normalizeAndQuantizeSignedFunc(e, t);
+  }
+  setupNormalizeAndQuantize() {
+    if (this.videoElementParent = this.videoElementProvider.getVideoParentElement(), this.videoElement = this.videoElementProvider.getVideoElement(), this.videoElementParent && this.videoElement) {
+      const e = this.videoElementParent.clientWidth || 1, t = this.videoElementParent.clientHeight || 1, s = this.videoElement.videoWidth || 1, n = t / e, i = (this.videoElement.videoHeight || 1) / s;
+      n > i ? (r.Log(r.GetStackTrace(), "Setup Normalize and Quantize for playerAspectRatio > videoAspectRatio", 6), this.ratio = n / i, this.normalizeAndQuantizeUnsignedFunc = (o, d) => this.normalizeAndQuantizeUnsignedPlayerBigger(o, d), this.normalizeAndQuantizeSignedFunc = (o, d) => this.normalizeAndQuantizeSignedPlayerBigger(o, d), this.denormalizeAndUnquantizeUnsignedFunc = (o, d) => this.denormalizeAndUnquantizeUnsignedPlayerBigger(o, d)) : (r.Log(r.GetStackTrace(), "Setup Normalize and Quantize for playerAspectRatio <= videoAspectRatio", 6), this.ratio = i / n, this.normalizeAndQuantizeUnsignedFunc = (o, d) => this.normalizeAndQuantizeUnsignedPlayerSmaller(o, d), this.normalizeAndQuantizeSignedFunc = (o, d) => this.normalizeAndQuantizeSignedPlayerSmaller(o, d), this.denormalizeAndUnquantizeUnsignedFunc = (o, d) => this.denormalizeAndUnquantizeUnsignedPlayerSmaller(o, d));
+    }
+  }
+  normalizeAndQuantizeUnsignedPlayerBigger(e, t) {
+    const s = e / this.videoElementParent.clientWidth, n = this.ratio * (t / this.videoElementParent.clientHeight - 0.5) + 0.5;
+    return s < 0 || s > 1 || n < 0 || n > 1 ? new Q(!1, 65535, 65535) : new Q(!0, 65536 * s, 65536 * n);
+  }
+  denormalizeAndUnquantizeUnsignedPlayerBigger(e, t) {
+    const s = e / 65536, n = (t / 65536 - 0.5) / this.ratio + 0.5;
+    return new oe(s * this.videoElementParent.clientWidth, n * this.videoElementParent.clientHeight);
+  }
+  normalizeAndQuantizeSignedPlayerBigger(e, t) {
+    const s = e / (0.5 * this.videoElementParent.clientWidth), n = this.ratio * t / (0.5 * this.videoElementParent.clientHeight);
+    return new ge(32767 * s, 32767 * n);
+  }
+  normalizeAndQuantizeUnsignedPlayerSmaller(e, t) {
+    const s = this.ratio * (e / this.videoElementParent.clientWidth - 0.5) + 0.5, n = t / this.videoElementParent.clientHeight;
+    return s < 0 || s > 1 || n < 0 || n > 1 ? new Q(!1, 65535, 65535) : new Q(!0, 65536 * s, 65536 * n);
+  }
+  denormalizeAndUnquantizeUnsignedPlayerSmaller(e, t) {
+    const s = (e / 65536 - 0.5) / this.ratio + 0.5, n = t / 65536;
+    return new oe(s * this.videoElementParent.clientWidth, n * this.videoElementParent.clientHeight);
+  }
+  normalizeAndQuantizeSignedPlayerSmaller(e, t) {
+    const s = this.ratio * e / (0.5 * this.videoElementParent.clientWidth), n = t / (0.5 * this.videoElementParent.clientHeight);
+    return new ge(32767 * s, 32767 * n);
+  }
+}
+class Q {
+  constructor(e, t, s) {
+    this.inRange = e, this.x = t, this.y = s;
+  }
+}
+class oe {
+  constructor(e, t) {
+    this.x = e, this.y = t;
+  }
+}
+class ge {
+  constructor(e, t) {
+    this.x = e, this.y = t;
+  }
+}
+class ot {
+  constructor(e, t) {
+    this.shouldShowPlayOverlay = !0, this.autoJoinTimer = void 0, this.config = e, this.pixelStreaming = t, this.responseController = new $t(), this.file = new It(), this.sdpConstraints = { offerToReceiveAudio: !0, offerToReceiveVideo: !0 }, this.afkController = new Xe(this.config, this.pixelStreaming, this.onAfkTriggered.bind(this)), this.afkController.onAFKTimedOutCallback = () => {
+      this.closeSignalingServer("You have been disconnected due to inactivity");
+    }, this.freezeFrameController = new Mt(this.pixelStreaming.videoElementParent), this.videoPlayer = new Qt(this.pixelStreaming.videoElementParent, this.config), this.videoPlayer.onVideoInitialized = () => this.handleVideoInitialized(), this.videoPlayer.onMatchViewportResolutionCallback = (s, n) => {
+      const i = { "Resolution.Width": s, "Resolution.Height": n };
+      this.streamMessageController.toStreamerHandlers.get("Command")([JSON.stringify(i)]);
+    }, this.videoPlayer.onResizePlayerCallback = () => {
+      this.setUpMouseAndFreezeFrame();
+    }, this.streamController = new yt(this.videoPlayer), this.coordinateConverter = new Yt(this.videoPlayer), this.sendrecvDataChannelController = new ce(), this.recvDataChannelController = new ce(), this.registerDataChannelEventEmitters(this.sendrecvDataChannelController), this.registerDataChannelEventEmitters(this.recvDataChannelController), this.dataChannelSender = new Jt(this.sendrecvDataChannelController), this.dataChannelSender.resetAfkWarningTimerOnDataSend = () => this.afkController.resetAfkWarningTimer(), this.streamMessageController = new qt(), this.webSocketController = new pe(), this.webSocketController.onConfig = (s) => this.handleOnConfigMessage(s), this.webSocketController.onStreamerList = (s) => this.handleStreamerListMessage(s), this.webSocketController.onStreamerIDChanged = (s) => this.handleStreamerIDChangedMessage(s), this.webSocketController.onPlayerCount = (s) => {
+      this.pixelStreaming._onPlayerCount(s.count);
+    }, this.webSocketController.onOpen.addEventListener("open", (() => {
+      this.config.isFlagEnabled(l.BrowserSendOffer) || this.webSocketController.requestStreamerList();
+    })), this.webSocketController.onClose.addEventListener("close", ((s) => {
+      const n = this.shouldReconnect && s.detail.code != 1001 && this.config.getNumericSettingValue(h.MaxReconnectAttempts) > 0, i = this.disconnectMessage ? this.disconnectMessage : s.detail.reason;
+      this.pixelStreaming._onDisconnect(i, !n && !this.isReconnecting), this.afkController.stopAfkWarningTimer(), this.statsTimerHandle && this.statsTimerHandle !== void 0 && window.clearInterval(this.statsTimerHandle), this.setVideoEncoderAvgQP(0), this.setTouchInputEnabled(!1), this.setMouseInputEnabled(!1), this.setKeyboardInputEnabled(!1), this.setGamePadInputEnabled(!1), n && setTimeout((() => {
+        this.isReconnecting = !0, this.reconnectAttempt++, this.tryReconnect(s.detail.reason);
+      }), 2e3);
+    })), this.sendMessageController = new jt(this.dataChannelSender, this.streamMessageController), this.toStreamerMessagesController = new Xt(this.sendMessageController), this.registerMessageHandlers(), this.streamMessageController.populateDefaultProtocol(), this.inputClassesFactory = new Nt(this.streamMessageController, this.videoPlayer, this.coordinateConverter), this.isUsingSFU = !1, this.isQualityController = !1, this.preferredCodec = "", this.shouldReconnect = !0, this.isReconnecting = !1, this.reconnectAttempt = 0, this.config._addOnOptionSettingChangedListener(f.StreamerId, ((s) => {
+      s !== "" && (this.peerConnectionController.peerConnection.close(), this.peerConnectionController.createPeerConnection(this.peerConfig, this.preferredCodec), this.subscribedStream = s, this.webSocketController.sendSubscribe(s));
+    })), this.setVideoEncoderAvgQP(-1), this.signallingUrlBuilder = () => {
+      let s = this.config.getTextSettingValue(I.SignallingServerUrl);
+      return this.config.isFlagEnabled(l.BrowserSendOffer) && (s += "?" + l.BrowserSendOffer + "=true"), s;
+    };
+  }
+  requestUnquantizedAndDenormalizeUnsigned(e, t) {
+    return this.coordinateConverter.unquantizeAndDenormalizeUnsigned(e, t);
+  }
+  handleOnMessage(e) {
+    const t = new Uint8Array(e.data);
+    r.Log(r.GetStackTrace(), "Message incoming:" + t, 6);
+    const s = this.streamMessageController.fromStreamerMessages.get(t[0]);
+    this.streamMessageController.fromStreamerHandlers.get(s)(e.data);
+  }
+  registerMessageHandlers() {
+    this.streamMessageController.registerMessageHandler(p.FromStreamer, "QualityControlOwnership", ((e) => this.onQualityControlOwnership(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "Response", ((e) => this.responseController.onResponse(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "Command", ((e) => {
+      this.onCommand(e);
+    })), this.streamMessageController.registerMessageHandler(p.FromStreamer, "FreezeFrame", ((e) => this.onFreezeFrameMessage(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "UnfreezeFrame", (() => this.invalidateFreezeFrameAndEnableVideo())), this.streamMessageController.registerMessageHandler(p.FromStreamer, "VideoEncoderAvgQP", ((e) => this.handleVideoEncoderAvgQP(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "LatencyTest", ((e) => this.handleLatencyTestResult(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "DataChannelLatencyTest", ((e) => this.handleDataChannelLatencyTestResponse(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "InitialSettings", ((e) => this.handleInitialSettings(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "FileExtension", ((e) => this.onFileExtension(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "FileMimeType", ((e) => this.onFileMimeType(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "FileContents", ((e) => this.onFileContents(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "TestEcho", (() => {
+    })), this.streamMessageController.registerMessageHandler(p.FromStreamer, "InputControlOwnership", ((e) => this.onInputControlOwnership(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "GamepadResponse", ((e) => this.onGamepadResponse(e))), this.streamMessageController.registerMessageHandler(p.FromStreamer, "Protocol", ((e) => this.onProtocolMessage(e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "IFrameRequest", (() => this.sendMessageController.sendMessageToStreamer("IFrameRequest"))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "RequestQualityControl", (() => this.sendMessageController.sendMessageToStreamer("RequestQualityControl"))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "FpsRequest", (() => this.sendMessageController.sendMessageToStreamer("FpsRequest"))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "AverageBitrateRequest", (() => this.sendMessageController.sendMessageToStreamer("AverageBitrateRequest"))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "StartStreaming", (() => this.sendMessageController.sendMessageToStreamer("StartStreaming"))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "StopStreaming", (() => this.sendMessageController.sendMessageToStreamer("StopStreaming"))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "LatencyTest", ((e) => this.sendMessageController.sendMessageToStreamer("LatencyTest", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "RequestInitialSettings", (() => this.sendMessageController.sendMessageToStreamer("RequestInitialSettings"))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "TestEcho", (() => {
+    })), this.streamMessageController.registerMessageHandler(p.ToStreamer, "UIInteraction", ((e) => this.sendMessageController.sendMessageToStreamer("UIInteraction", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "Command", ((e) => this.sendMessageController.sendMessageToStreamer("Command", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "TextboxEntry", ((e) => this.sendMessageController.sendMessageToStreamer("TextboxEntry", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "KeyDown", ((e) => this.sendMessageController.sendMessageToStreamer("KeyDown", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "KeyUp", ((e) => this.sendMessageController.sendMessageToStreamer("KeyUp", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "KeyPress", ((e) => this.sendMessageController.sendMessageToStreamer("KeyPress", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "MouseEnter", ((e) => this.sendMessageController.sendMessageToStreamer("MouseEnter", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "MouseLeave", ((e) => this.sendMessageController.sendMessageToStreamer("MouseLeave", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "MouseDown", ((e) => this.sendMessageController.sendMessageToStreamer("MouseDown", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "MouseUp", ((e) => this.sendMessageController.sendMessageToStreamer("MouseUp", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "MouseMove", ((e) => this.sendMessageController.sendMessageToStreamer("MouseMove", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "MouseWheel", ((e) => this.sendMessageController.sendMessageToStreamer("MouseWheel", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "MouseDouble", ((e) => this.sendMessageController.sendMessageToStreamer("MouseDouble", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "TouchStart", ((e) => this.sendMessageController.sendMessageToStreamer("TouchStart", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "TouchEnd", ((e) => this.sendMessageController.sendMessageToStreamer("TouchEnd", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "TouchMove", ((e) => this.sendMessageController.sendMessageToStreamer("TouchMove", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "GamepadConnected", (() => this.sendMessageController.sendMessageToStreamer("GamepadConnected"))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "GamepadButtonPressed", ((e) => this.sendMessageController.sendMessageToStreamer("GamepadButtonPressed", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "GamepadButtonReleased", ((e) => this.sendMessageController.sendMessageToStreamer("GamepadButtonReleased", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "GamepadAnalog", ((e) => this.sendMessageController.sendMessageToStreamer("GamepadAnalog", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "GamepadDisconnected", ((e) => this.sendMessageController.sendMessageToStreamer("GamepadDisconnected", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "XREyeViews", ((e) => this.sendMessageController.sendMessageToStreamer("XREyeViews", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "XRHMDTransform", ((e) => this.sendMessageController.sendMessageToStreamer("XRHMDTransform", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "XRControllerTransform", ((e) => this.sendMessageController.sendMessageToStreamer("XRControllerTransform", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "XRSystem", ((e) => this.sendMessageController.sendMessageToStreamer("XRSystem", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "XRButtonTouched", ((e) => this.sendMessageController.sendMessageToStreamer("XRButtonTouched", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "XRButtonTouchReleased", ((e) => this.sendMessageController.sendMessageToStreamer("XRButtonTouchReleased", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "XRButtonPressed", ((e) => this.sendMessageController.sendMessageToStreamer("XRButtonPressed", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "XRButtonReleased", ((e) => this.sendMessageController.sendMessageToStreamer("XRButtonReleased", e))), this.streamMessageController.registerMessageHandler(p.ToStreamer, "XRAnalog", ((e) => this.sendMessageController.sendMessageToStreamer("XRAnalog", e)));
+  }
+  onCommand(e) {
+    r.Log(r.GetStackTrace(), "DataChannelReceiveMessageType.Command", 6);
+    const t = new TextDecoder("utf-16").decode(e.slice(1));
+    r.Log(r.GetStackTrace(), "Data Channel Command: " + t, 6);
+    const s = JSON.parse(t);
+    s.command === "onScreenKeyboard" && this.pixelStreaming._activateOnScreenKeyboard(s);
+  }
+  onProtocolMessage(e) {
+    try {
+      const t = new TextDecoder("utf-16").decode(e.slice(1)), s = JSON.parse(t);
+      Object.prototype.hasOwnProperty.call(s, "Direction") || r.Error(r.GetStackTrace(), "Malformed protocol received. Ensure the protocol message contains a direction");
+      const n = s.Direction;
+      delete s.Direction, r.Log(r.GetStackTrace(), `Received new ${n == p.FromStreamer ? "FromStreamer" : "ToStreamer"} protocol. Updating existing protocol...`), Object.keys(s).forEach(((i) => {
+        const o = s[i];
+        switch (n) {
+          case p.ToStreamer:
+            if (!Object.prototype.hasOwnProperty.call(o, "id")) return void r.Error(r.GetStackTrace(), `ToStreamer->${i} protocol definition was malformed as it didn't contain at least an id
+
+                                           Definition was: ${JSON.stringify(o, null, 2)}`);
+            if (i === "UIInteraction" || i === "Command" || i === "LatencyTest") return;
+            this.streamMessageController.toStreamerHandlers.get(i) ? this.streamMessageController.toStreamerMessages.set(i, o) : r.Error(r.GetStackTrace(), `There was no registered handler for "${i}" - try adding one using registerMessageHandler(MessageDirection.ToStreamer, "${i}", myHandler)`);
+            break;
+          case p.FromStreamer:
+            if (!Object.prototype.hasOwnProperty.call(o, "id")) return void r.Error(r.GetStackTrace(), `FromStreamer->${i} protocol definition was malformed as it didn't contain at least an id
+
+                            Definition was: ${JSON.stringify(o, null, 2)}`);
+            this.streamMessageController.fromStreamerHandlers.get(i) ? this.streamMessageController.fromStreamerMessages.set(o.id, i) : r.Error(r.GetStackTrace(), `There was no registered handler for "${o}" - try adding one using registerMessageHandler(MessageDirection.FromStreamer, "${i}", myHandler)`);
+            break;
+          default:
+            r.Error(r.GetStackTrace(), `Unknown direction: ${n}`);
+        }
+      })), this.toStreamerMessagesController.SendRequestInitialSettings(), this.toStreamerMessagesController.SendRequestQualityControl();
+    } catch (t) {
+      r.Log(r.GetStackTrace(), t);
+    }
+  }
+  onInputControlOwnership(e) {
+    const t = new Uint8Array(e);
+    r.Log(r.GetStackTrace(), "DataChannelReceiveMessageType.InputControlOwnership", 6);
+    const s = new Boolean(t[1]).valueOf();
+    r.Log(r.GetStackTrace(), `Received input controller message - will your input control the stream: ${s}`), this.pixelStreaming._onInputControlOwnership(s);
+  }
+  onGamepadResponse(e) {
+    const t = new TextDecoder("utf-16").decode(e.slice(1)), s = JSON.parse(t);
+    this.gamePadController.onGamepadResponseReceived(s.controllerId);
+  }
+  onAfkTriggered() {
+    this.afkController.onAfkClick(), this.videoPlayer.isPaused() && this.videoPlayer.hasVideoSource() && this.playStream();
+  }
+  setAfkEnabled(e) {
+    e ? this.onAfkTriggered() : this.afkController.stopAfkWarningTimer();
+  }
+  tryReconnect(e) {
+    this.webSocketController ? (this.isReconnecting = !0, this.webSocketController.webSocket && this.webSocketController.webSocket.readyState != WebSocket.CLOSED ? (this.closeSignalingServer(`${e} Restarting stream...`), setTimeout((() => {
+      this.tryReconnect(e);
+    }), 3e3)) : (this.pixelStreaming._onWebRtcAutoConnect(), this.connectToSignallingServer())) : r.Log(r.GetStackTrace(), "The Web Socket Controller does not exist so this will not work right now.");
+  }
+  loadFreezeFrameOrShowPlayOverlay() {
+    this.pixelStreaming.dispatchEvent(new Ge({ shouldShowPlayOverlay: this.shouldShowPlayOverlay, isValid: this.freezeFrameController.valid, jpegData: this.freezeFrameController.jpeg })), this.shouldShowPlayOverlay === !0 ? (r.Log(r.GetStackTrace(), "showing play overlay"), this.resizePlayerStyle()) : (r.Log(r.GetStackTrace(), "showing freeze frame"), this.freezeFrameController.showFreezeFrame()), setTimeout((() => {
+      this.videoPlayer.setVideoEnabled(!1);
+    }), this.freezeFrameController.freezeFrameDelay);
+  }
+  onFreezeFrameMessage(e) {
+    r.Log(r.GetStackTrace(), "DataChannelReceiveMessageType.FreezeFrame", 6);
+    const t = new Uint8Array(e);
+    this.freezeFrameController.processFreezeFrameMessage(t, (() => this.loadFreezeFrameOrShowPlayOverlay()));
+  }
+  invalidateFreezeFrameAndEnableVideo() {
+    r.Log(r.GetStackTrace(), "DataChannelReceiveMessageType.FreezeFrame", 6), setTimeout((() => {
+      this.pixelStreaming.dispatchEvent(new Be()), this.freezeFrameController.hideFreezeFrame();
+    }), this.freezeFrameController.freezeFrameDelay), this.videoPlayer.getVideoElement() && this.videoPlayer.setVideoEnabled(!0);
+  }
+  onFileExtension(e) {
+    const t = new Uint8Array(e);
+    te.setExtensionFromBytes(t, this.file);
+  }
+  onFileMimeType(e) {
+    const t = new Uint8Array(e);
+    te.setMimeTypeFromBytes(t, this.file);
+  }
+  onFileContents(e) {
+    const t = new Uint8Array(e);
+    te.setContentsFromBytes(t, this.file);
+  }
+  playStream() {
+    if (!this.videoPlayer.getVideoElement()) {
+      const e = "Could not play video stream because the video player was not initialized correctly.";
+      return this.pixelStreaming.dispatchEvent(new Ie({ message: e })), r.Error(r.GetStackTrace(), e), void this.closeSignalingServer("Stream not initialized correctly");
+    }
+    if (this.videoPlayer.hasVideoSource()) {
+      if (this.setTouchInputEnabled(this.config.isFlagEnabled(l.TouchInput)), this.pixelStreaming.dispatchEvent(new Ue()), this.streamController.audioElement.srcObject) {
+        const e = this.config.isFlagEnabled(l.StartVideoMuted);
+        this.streamController.audioElement.muted = e, e ? this.playVideo() : this.streamController.audioElement.play().then((() => {
+          this.playVideo();
+        })).catch(((t) => {
+          r.Log(r.GetStackTrace(), t), r.Log(r.GetStackTrace(), "Browser does not support autoplaying video without interaction - to resolve this we are going to show the play button overlay."), this.pixelStreaming.dispatchEvent(new ie({ reason: t }));
+        }));
+      } else this.playVideo();
+      this.shouldShowPlayOverlay = !1, this.freezeFrameController.showFreezeFrame();
+    } else r.Warning(r.GetStackTrace(), "Cannot play stream, the video element has no srcObject to play.");
+  }
+  playVideo() {
+    this.videoPlayer.play().catch(((e) => {
+      this.streamController.audioElement.srcObject && this.streamController.audioElement.pause(), r.Log(r.GetStackTrace(), e), r.Log(r.GetStackTrace(), "Browser does not support autoplaying video without interaction - to resolve this we are going to show the play button overlay."), this.pixelStreaming.dispatchEvent(new ie({ reason: e }));
+    }));
+  }
+  autoPlayVideoOrSetUpPlayOverlay() {
+    this.config.isFlagEnabled(l.AutoPlayVideo) && this.playStream(), this.resizePlayerStyle();
+  }
+  connectToSignallingServer() {
+    this.locallyClosed = !1, this.shouldReconnect = !0, this.disconnectMessage = null;
+    const e = this.signallingUrlBuilder();
+    this.webSocketController.connect(e);
+  }
+  startSession(e) {
+    if (this.peerConfig = e, this.config.isFlagEnabled(l.ForceTURN) && !this.checkTurnServerAvailability(e)) return r.Info(r.GetStackTrace(), "No turn server was found in the Peer Connection Options. TURN cannot be forced, closing connection. Please use STUN instead"), void this.closeSignalingServer("TURN cannot be forced, closing connection. Please use STUN instead.");
+    this.peerConnectionController = new Dt(this.peerConfig, this.config, this.preferredCodec), this.peerConnectionController.onVideoStats = (s) => this.handleVideoStats(s), this.peerConnectionController.onSendWebRTCOffer = (s) => this.handleSendWebRTCOffer(s), this.peerConnectionController.onSendWebRTCAnswer = (s) => this.handleSendWebRTCAnswer(s), this.peerConnectionController.onPeerIceCandidate = (s) => this.handleSendIceCandidate(s), this.peerConnectionController.onDataChannel = (s) => this.handleDataChannel(s), this.peerConnectionController.showTextOverlayConnecting = () => this.pixelStreaming._onWebRtcConnecting(), this.peerConnectionController.showTextOverlaySetupFailure = () => this.pixelStreaming._onWebRtcFailed();
+    let t = !1;
+    this.peerConnectionController.onIceConnectionStateChange = () => {
+      !t && ["connected", "completed"].includes(this.peerConnectionController.peerConnection.iceConnectionState) && (this.pixelStreaming._onWebRtcConnected(), t = !0);
+    }, this.peerConnectionController.onTrack = (s) => this.streamController.handleOnTrack(s), this.config.isFlagEnabled(l.BrowserSendOffer) && (this.sendrecvDataChannelController.createDataChannel(this.peerConnectionController.peerConnection, "cirrus", this.datachannelOptions), this.sendrecvDataChannelController.handleOnMessage = (s) => this.handleOnMessage(s), this.peerConnectionController.createOffer(this.sdpConstraints, this.config));
+  }
+  checkTurnServerAvailability(e) {
+    if (!e.iceServers) return r.Info(r.GetStackTrace(), "A turn sever was not found"), !1;
+    for (const t of e.iceServers) for (const s of t.urls) if (s.includes("turn")) return r.Log(r.GetStackTrace(), `A turn sever was found at ${s}`), !0;
+    return r.Info(r.GetStackTrace(), "A turn sever was not found"), !1;
+  }
+  handleOnConfigMessage(e) {
+    this.resizePlayerStyle(), this.startSession(e.peerConnectionOptions), this.webSocketController.onWebRtcAnswer = (t) => this.handleWebRtcAnswer(t), this.webSocketController.onWebRtcOffer = (t) => this.handleWebRtcOffer(t), this.webSocketController.onWebRtcPeerDataChannels = (t) => this.handleWebRtcSFUPeerDatachannels(t), this.webSocketController.onIceCandidate = (t) => this.handleIceCandidate(t);
+  }
+  handleStreamerListMessage(e) {
+    r.Log(r.GetStackTrace(), `Got streamer list ${e.ids}`, 6);
+    let t = null;
+    var s = this.config.getSettingOption(f.StreamerId);
+    s.selected.toString().trim() && (t = s.selected);
+    const n = [...e.ids];
+    n.unshift(""), this.config.setOptionSettingOptions(f.StreamerId, n);
+    let i = null;
+    const o = this.config.isFlagEnabled(l.WaitForStreamer), d = this.config.getNumericSettingValue(h.MaxReconnectAttempts), c = this.config.getNumericSettingValue(h.StreamerAutoJoinInterval), m = this.config.useUrlParams, u = new URLSearchParams(window.location.search);
+    m && u.has(f.StreamerId) ? t = u.get(f.StreamerId) : this.subscribedStream && (t = this.subscribedStream), t && e.ids.includes(t) ? i = t : t && o || e.ids.length != 1 || (i = e.ids[0]), i ? (this.isReconnecting = !1, this.reconnectAttempt = 0, this.config.setOptionSettingValue(f.StreamerId, i)) : o && (this.reconnectAttempt < d ? (this.isReconnecting = !0, this.reconnectAttempt++, setTimeout((() => {
+      this.webSocketController.requestStreamerList();
+    }), c)) : (this.reconnectAttempt = 0, this.isReconnecting = !1, this.shouldReconnect = !1)), this.pixelStreaming.dispatchEvent(new _e({ messageStreamerList: e, autoSelectedStreamerId: i, wantedStreamerId: t }));
+  }
+  handleStreamerIDChangedMessage(e) {
+    const t = e.newID;
+    var s = this.config.getSettingOption(f.StreamerId), n = s.onChange;
+    s.onChange = () => {
+    };
+    for (var i = s.options, o = 0; o < i.length; ++o) if (i[o] == this.subscribedStream) {
+      i[o] = t;
+      break;
+    }
+    s.options = i, s.selected = t, s.onChange = n, this.subscribedStream = e.newID, this.pixelStreaming.dispatchEvent(new Ve({ newID: t }));
+  }
+  handleWebRtcAnswer(e) {
+    r.Log(r.GetStackTrace(), `Got answer sdp ${e.sdp}`, 6);
+    const t = { sdp: e.sdp, type: "answer" };
+    this.peerConnectionController.receiveAnswer(t), this.handlePostWebrtcNegotiation();
+  }
+  handleWebRtcOffer(e) {
+    r.Log(r.GetStackTrace(), `Got offer sdp ${e.sdp}`, 6), this.isUsingSFU = !!e.sfu && e.sfu, this.isUsingSFU && (this.peerConnectionController.preferredCodec = "");
+    const t = { sdp: e.sdp, type: "offer" };
+    this.peerConnectionController.receiveOffer(t, this.config), this.handlePostWebrtcNegotiation();
+  }
+  handleWebRtcSFUPeerDatachannels(e) {
+    const t = { ordered: !0, negotiated: !0, id: e.sendStreamId }, s = e.sendStreamId != e.recvStreamId;
+    if (this.sendrecvDataChannelController.createDataChannel(this.peerConnectionController.peerConnection, s ? "send-datachannel" : "datachannel", t), s) {
+      const n = { ordered: !0, negotiated: !0, id: e.recvStreamId };
+      this.recvDataChannelController.createDataChannel(this.peerConnectionController.peerConnection, "recv-datachannel", n), this.recvDataChannelController.handleOnOpen = () => this.webSocketController.sendSFURecvDataChannelReady(), this.recvDataChannelController.handleOnMessage = (i) => this.handleOnMessage(i);
+    } else this.sendrecvDataChannelController.handleOnMessage = (n) => this.handleOnMessage(n);
+  }
+  handlePostWebrtcNegotiation() {
+    this.afkController.startAfkWarningTimer(), this.pixelStreaming._onWebRtcSdp(), this.statsTimerHandle && this.statsTimerHandle !== void 0 && window.clearInterval(this.statsTimerHandle), this.statsTimerHandle = window.setInterval((() => this.getStats()), 1e3), this.setMouseInputEnabled(this.config.isFlagEnabled(l.MouseInput)), this.setKeyboardInputEnabled(this.config.isFlagEnabled(l.KeyboardInput)), this.setGamePadInputEnabled(this.config.isFlagEnabled(l.GamepadInput));
+  }
+  handleIceCandidate(e) {
+    r.Log(r.GetStackTrace(), "Web RTC Controller: onWebRtcIce", 6);
+    const t = new RTCIceCandidate(e);
+    this.peerConnectionController.handleOnIce(t);
+  }
+  handleSendIceCandidate(e) {
+    r.Log(r.GetStackTrace(), "OnIceCandidate", 6), e.candidate && e.candidate.candidate && this.webSocketController.sendIceCandidate(e.candidate);
+  }
+  handleDataChannel(e) {
+    r.Log(r.GetStackTrace(), "Data channel created for us by browser as we are a receiving peer.", 6), this.sendrecvDataChannelController.dataChannel = e.channel, this.sendrecvDataChannelController.setupDataChannel(), this.sendrecvDataChannelController.handleOnMessage = (t) => this.handleOnMessage(t);
+  }
+  handleSendWebRTCOffer(e) {
+    r.Log(r.GetStackTrace(), "Sending the offer to the Server", 6);
+    const t = { minBitrateBps: 1e3 * this.config.getNumericSettingValue(h.WebRTCMinBitrate), maxBitrateBps: 1e3 * this.config.getNumericSettingValue(h.WebRTCMaxBitrate) };
+    this.webSocketController.sendWebRtcOffer(e, t);
+  }
+  handleSendWebRTCAnswer(e) {
+    r.Log(r.GetStackTrace(), "Sending the answer to the Server", 6);
+    const t = { minBitrateBps: 1e3 * this.config.getNumericSettingValue(h.WebRTCMinBitrate), maxBitrateBps: 1e3 * this.config.getNumericSettingValue(h.WebRTCMaxBitrate) };
+    this.webSocketController.sendWebRtcAnswer(e, t), this.isUsingSFU && this.webSocketController.sendWebRtcDatachannelRequest();
+  }
+  setUpMouseAndFreezeFrame() {
+    this.videoElementParentClientRect = this.videoPlayer.getVideoParentElement().getBoundingClientRect(), this.coordinateConverter.setupNormalizeAndQuantize(), this.freezeFrameController.freezeFrame.resize();
+  }
+  closeSignalingServer(e) {
+    var t;
+    this.locallyClosed = !0, this.shouldReconnect = !1, this.disconnectMessage = e, (t = this.webSocketController) === null || t === void 0 || t.close();
+  }
+  closePeerConnection() {
+    var e;
+    (e = this.peerConnectionController) === null || e === void 0 || e.close();
+  }
+  close() {
+    this.closeSignalingServer(""), this.closePeerConnection();
+  }
+  getStats() {
+    this.peerConnectionController.generateStats();
+  }
+  sendLatencyTest() {
+    this.latencyStartTime = Date.now(), this.streamMessageController.toStreamerHandlers.get("LatencyTest")([JSON.stringify({ StartTime: this.latencyStartTime })]);
+  }
+  sendDataChannelLatencyTest(e) {
+    this.streamMessageController.toStreamerHandlers.get("DataChannelLatencyTest")([JSON.stringify(e)]);
+  }
+  sendEncoderMinQP(e) {
+    r.Log(r.GetStackTrace(), `MinQP=${e}
+`, 6), e != null && this.streamMessageController.toStreamerHandlers.get("Command")([JSON.stringify({ "Encoder.MinQP": e })]);
+  }
+  sendEncoderMaxQP(e) {
+    r.Log(r.GetStackTrace(), `MaxQP=${e}
+`, 6), e != null && this.streamMessageController.toStreamerHandlers.get("Command")([JSON.stringify({ "Encoder.MaxQP": e })]);
+  }
+  sendWebRTCMinBitrate(e) {
+    r.Log(r.GetStackTrace(), `WebRTC Min Bitrate=${e}`, 6), e != null && this.streamMessageController.toStreamerHandlers.get("Command")([JSON.stringify({ "WebRTC.MinBitrate": e })]);
+  }
+  sendWebRTCMaxBitrate(e) {
+    r.Log(r.GetStackTrace(), `WebRTC Max Bitrate=${e}`, 6), e != null && this.streamMessageController.toStreamerHandlers.get("Command")([JSON.stringify({ "WebRTC.MaxBitrate": e })]);
+  }
+  sendWebRTCFps(e) {
+    r.Log(r.GetStackTrace(), `WebRTC FPS=${e}`, 6), e != null && (this.streamMessageController.toStreamerHandlers.get("Command")([JSON.stringify({ "WebRTC.Fps": e })]), this.streamMessageController.toStreamerHandlers.get("Command")([JSON.stringify({ "WebRTC.MaxFps": e })]));
+  }
+  sendShowFps() {
+    r.Log(r.GetStackTrace(), "----   Sending show stat to UE   ----", 6), this.streamMessageController.toStreamerHandlers.get("Command")([JSON.stringify({ "stat.fps": "" })]);
+  }
+  sendIframeRequest() {
+    r.Log(r.GetStackTrace(), "----   Sending Request for an IFrame  ----", 6), this.streamMessageController.toStreamerHandlers.get("IFrameRequest")();
+  }
+  emitUIInteraction(e) {
+    r.Log(r.GetStackTrace(), "----   Sending custom UIInteraction message   ----", 6), this.streamMessageController.toStreamerHandlers.get("UIInteraction")([JSON.stringify(e)]);
+  }
+  emitCommand(e) {
+    r.Log(r.GetStackTrace(), "----   Sending custom Command message   ----", 6), this.streamMessageController.toStreamerHandlers.get("Command")([JSON.stringify(e)]);
+  }
+  emitConsoleCommand(e) {
+    r.Log(r.GetStackTrace(), "----   Sending custom Command:ConsoleCommand message   ----", 6), this.streamMessageController.toStreamerHandlers.get("Command")([JSON.stringify({ ConsoleCommand: e })]);
+  }
+  sendRequestQualityControlOwnership() {
+    r.Log(r.GetStackTrace(), "----   Sending Request to Control Quality  ----", 6), this.toStreamerMessagesController.SendRequestQualityControl();
+  }
+  handleLatencyTestResult(e) {
+    r.Log(r.GetStackTrace(), "DataChannelReceiveMessageType.latencyTest", 6);
+    const t = new TextDecoder("utf-16").decode(e.slice(1)), s = new at();
+    Object.assign(s, JSON.parse(t)), s.processFields(), s.testStartTimeMs = this.latencyStartTime, s.browserReceiptTimeMs = Date.now(), s.latencyExcludingDecode = ~~(s.browserReceiptTimeMs - s.testStartTimeMs), s.testDuration = ~~(s.TransmissionTimeMs - s.ReceiptTimeMs), s.networkLatency = ~~(s.latencyExcludingDecode - s.testDuration), s.frameDisplayDeltaTimeMs && s.browserReceiptTimeMs && (s.endToEndLatency = (s.frameDisplayDeltaTimeMs, s.networkLatency, ~~+s.CaptureToSendMs)), this.pixelStreaming._onLatencyTestResult(s);
+  }
+  handleDataChannelLatencyTestResponse(e) {
+    r.Log(r.GetStackTrace(), "DataChannelReceiveMessageType.dataChannelLatencyResponse", 6);
+    const t = new TextDecoder("utf-16").decode(e.slice(1)), s = JSON.parse(t);
+    this.pixelStreaming._onDataChannelLatencyTestResponse(s);
+  }
+  handleInitialSettings(e) {
+    r.Log(r.GetStackTrace(), "DataChannelReceiveMessageType.InitialSettings", 6);
+    const t = new TextDecoder("utf-16").decode(e.slice(1)), s = JSON.parse(t), n = new nt();
+    s.Encoder && (n.EncoderSettings = s.Encoder), s.WebRTC && (n.WebRTCSettings = s.WebRTC), s.PixelStreaming && (n.PixelStreamingSettings = s.PixelStreaming), s.ConfigOptions && s.ConfigOptions.DefaultToHover !== void 0 && this.config.setFlagEnabled(l.HoveringMouseMode, !!s.ConfigOptions.DefaultToHover), n.ueCompatible(), r.Log(r.GetStackTrace(), t, 6), this.pixelStreaming._onInitialSettings(n);
+  }
+  handleVideoEncoderAvgQP(e) {
+    r.Log(r.GetStackTrace(), "DataChannelReceiveMessageType.VideoEncoderAvgQP", 6);
+    const t = Number(new TextDecoder("utf-16").decode(e.slice(1)));
+    this.setVideoEncoderAvgQP(t);
+  }
+  handleVideoInitialized() {
+    this.pixelStreaming._onVideoInitialized(), this.autoPlayVideoOrSetUpPlayOverlay(), this.resizePlayerStyle(), this.videoPlayer.updateVideoStreamSize();
+  }
+  onQualityControlOwnership(e) {
+    const t = new Uint8Array(e);
+    r.Log(r.GetStackTrace(), "DataChannelReceiveMessageType.QualityControlOwnership", 6), this.isQualityController = new Boolean(t[1]).valueOf(), r.Log(r.GetStackTrace(), `Received quality controller message, will control quality: ${this.isQualityController}`), this.pixelStreaming._onQualityControlOwnership(this.isQualityController);
+  }
+  handleVideoStats(e) {
+    this.pixelStreaming._onVideoStats(e);
+  }
+  resizePlayerStyle() {
+    this.videoPlayer.resizePlayerStyle();
+  }
+  setPreferredCodec(e) {
+    this.preferredCodec = e, this.peerConnectionController && (this.peerConnectionController.preferredCodec = e, this.peerConnectionController.updateCodecSelection = !1);
+  }
+  setVideoEncoderAvgQP(e) {
+    this.videoAvgQp = e, this.pixelStreaming._onVideoEncoderAvgQP(this.videoAvgQp);
+  }
+  setKeyboardInputEnabled(e) {
+    var t;
+    (t = this.keyboardController) === null || t === void 0 || t.unregisterKeyBoardEvents(), e && (this.keyboardController = this.inputClassesFactory.registerKeyBoard(this.config));
+  }
+  setMouseInputEnabled(e) {
+    var t;
+    if ((t = this.mouseController) === null || t === void 0 || t.unregisterMouseEvents(), e) {
+      const s = this.config.isFlagEnabled(l.HoveringMouseMode) ? B.HoveringMouse : B.LockedMouse;
+      this.mouseController = this.inputClassesFactory.registerMouse(s);
+    }
+  }
+  setTouchInputEnabled(e) {
+    var t;
+    (t = this.touchController) === null || t === void 0 || t.unregisterTouchEvents(), e && (this.touchController = this.inputClassesFactory.registerTouch(this.config.isFlagEnabled(l.FakeMouseWithTouches), this.videoElementParentClientRect));
+  }
+  setGamePadInputEnabled(e) {
+    var t;
+    (t = this.gamePadController) === null || t === void 0 || t.unregisterGamePadEvents(), e && (this.gamePadController = this.inputClassesFactory.registerGamePad(), this.gamePadController.onGamepadConnected = () => {
+      this.streamMessageController.toStreamerHandlers.get("GamepadConnected")();
+    }, this.gamePadController.onGamepadDisconnected = (s) => {
+      this.streamMessageController.toStreamerHandlers.get("GamepadDisconnected")([s]);
+    });
+  }
+  registerDataChannelEventEmitters(e) {
+    e.onOpen = (t, s) => this.pixelStreaming.dispatchEvent(new Re({ label: t, event: s })), e.onClose = (t, s) => this.pixelStreaming.dispatchEvent(new ke({ label: t, event: s })), e.onError = (t, s) => this.pixelStreaming.dispatchEvent(new Le({ label: t, event: s }));
+  }
+  registerMessageHandler(e, t, s) {
+    t === p.FromStreamer && s === void 0 && r.Warning(r.GetStackTrace(), `Unable to register handler for ${e} as no handler was passed`), this.streamMessageController.registerMessageHandler(t, e, ((n) => s === void 0 && t === p.ToStreamer ? this.sendMessageController.sendMessageToStreamer(e, n) : s(n)));
+  }
+}
+class $ {
+  constructor(e) {
+    this.toStreamerMessagesProvider = e, this.controllers = [];
+  }
+  static deepCopyGamepad(e) {
+    return JSON.parse(JSON.stringify({ buttons: e.buttons.map(((t) => JSON.parse(JSON.stringify({ pressed: t.pressed, touched: t.touched, value: t.value })))), axes: e.axes }));
+  }
+  updateStatus(e, t, s) {
+    if (e.gamepad) {
+      const n = t.getPose(e.gripSpace, s);
+      if (!n) return;
+      let i = 0;
+      e.profiles.includes("htc-vive") ? i = 1 : e.profiles.includes("oculus-touch") && (i = 2), this.toStreamerMessagesProvider.toStreamerHandlers.get("XRSystem")([i]);
+      let o = 2;
+      switch (e.handedness) {
+        case "left":
+          o = 0;
+          break;
+        case "right":
+          o = 1;
+      }
+      const d = n.transform.matrix, c = [];
+      for (let S = 0; S < 16; S++) c[S] = new Float32Array([d[S]])[0];
+      this.toStreamerMessagesProvider.toStreamerHandlers.get("XRControllerTransform")([c[0], c[4], c[8], c[12], c[1], c[5], c[9], c[13], c[2], c[6], c[10], c[14], c[3], c[7], c[11], c[15], o]), this.controllers[o] === void 0 && (this.controllers[o] = { prevState: void 0, currentState: void 0, id: void 0 }, this.controllers[o].prevState = $.deepCopyGamepad(e.gamepad)), this.controllers[o].currentState = $.deepCopyGamepad(e.gamepad);
+      const m = this.controllers[o], u = m.currentState, v = m.prevState;
+      for (let S = 0; S < u.buttons.length; S++) {
+        const y = u.buttons[S], P = v.buttons[S];
+        if (y.pressed) {
+          let x = P.pressed ? 1 : 0;
+          this.toStreamerMessagesProvider.toStreamerHandlers.get("XRButtonPressed")([o, S, x]);
+        } else P.pressed && this.toStreamerMessagesProvider.toStreamerHandlers.get("XRButtonReleased")([o, S, 0]);
+        if (y.touched) {
+          let x = P.touched ? 1 : 0;
+          this.toStreamerMessagesProvider.toStreamerHandlers.get("XRButtonTouched")([o, S, x]);
+        } else P.touched && this.toStreamerMessagesProvider.toStreamerHandlers.get("XRButtonTouchReleased")([o, S, 0]);
+      }
+      for (let S = 0; S < u.axes.length; S++) {
+        let y = u.axes[S];
+        y != v.axes[S] && this.toStreamerMessagesProvider.toStreamerHandlers.get("XRAnalog")([o, S, y]);
+      }
+      this.controllers[o].prevState = u;
+    }
+  }
+}
+class lt {
+  constructor(e) {
+    this.xrViewerPose = null, this.videoTexture = null, this.prevVideoWidth = 0, this.prevVideoHeight = 0, this.leftView = null, this.rightView = null, this.xrSession = null, this.webRtcController = e, this.xrGamepadController = new $(this.webRtcController.streamMessageController), this.onSessionEnded = new EventTarget(), this.onSessionStarted = new EventTarget(), this.onFrame = new EventTarget();
+  }
+  xrClicked() {
+    if (this.xrSession) this.xrSession.end();
+    else {
+      if (!navigator.xr) return void r.Error(r.GetStackTrace(), "This browser does not support XR.");
+      navigator.xr.requestSession("immersive-vr", { optionalFeatures: [] }).then(((e) => {
+        this.onXrSessionStarted(e);
+      }));
+    }
+  }
+  onXrSessionEnded() {
+    r.Log(r.GetStackTrace(), "XR Session ended"), this.xrSession = null, this.onSessionEnded.dispatchEvent(new Event("xrSessionEnded"));
+  }
+  initGL() {
+    if (this.gl) return;
+    const e = document.createElement("canvas");
+    this.gl = e.getContext("webgl2", { xrCompatible: !0 }), this.gl.clearColor(0, 0, 0, 1);
+  }
+  initShaders() {
+    const e = this.gl.createShader(this.gl.VERTEX_SHADER);
+    this.gl.shaderSource(e, `
+        attribute vec2 a_position;
+        attribute vec2 a_texCoord;
+
+        // varyings
+        varying vec2 v_texCoord;
+
+        void main() {
+           gl_Position = vec4(a_position.x, a_position.y, 0, 1);
+           // pass the texCoord to the fragment shader
+           // The GPU will interpolate this value between points.
+           v_texCoord = a_texCoord;
+        }
+        `), this.gl.compileShader(e);
+    const t = this.gl.createShader(this.gl.FRAGMENT_SHADER);
+    this.gl.shaderSource(t, `
+        precision mediump float;
+
+        // our texture
+        uniform sampler2D u_image;
+
+        // the texCoords passed in from the vertex shader.
+        varying vec2 v_texCoord;
+
+        void main() {
+           gl_FragColor = texture2D(u_image, v_texCoord);
+        }
+        `), this.gl.compileShader(t);
+    const s = this.gl.createProgram();
+    this.gl.attachShader(s, e), this.gl.attachShader(s, t), this.gl.linkProgram(s), this.gl.useProgram(s), this.positionLocation = this.gl.getAttribLocation(s, "a_position"), this.texcoordLocation = this.gl.getAttribLocation(s, "a_texCoord");
+  }
+  updateVideoTexture() {
+    this.videoTexture || (this.videoTexture = this.gl.createTexture(), this.gl.bindTexture(this.gl.TEXTURE_2D, this.videoTexture), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.LINEAR), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.LINEAR));
+    let e = this.webRtcController.videoPlayer.getVideoElement().videoHeight, t = this.webRtcController.videoPlayer.getVideoElement().videoWidth;
+    this.prevVideoHeight != e || this.prevVideoWidth != t ? this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.RGBA, t, e, 0, this.gl.RGBA, this.gl.UNSIGNED_BYTE, this.webRtcController.videoPlayer.getVideoElement()) : this.gl.texSubImage2D(this.gl.TEXTURE_2D, 0, 0, 0, t, e, this.gl.RGBA, this.gl.UNSIGNED_BYTE, this.webRtcController.videoPlayer.getVideoElement()), this.prevVideoHeight = e, this.prevVideoWidth = t;
+  }
+  initBuffers() {
+    this.positionBuffer = this.gl.createBuffer(), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.positionBuffer), this.gl.enableVertexAttribArray(this.positionLocation), this.gl.bufferData(this.gl.ARRAY_BUFFER, new Float32Array([-1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, -1]), this.gl.STATIC_DRAW), this.gl.vertexAttribPointer(this.positionLocation, 2, this.gl.FLOAT, !1, 0, 0), this.texcoordBuffer = this.gl.createBuffer(), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.texcoordBuffer), this.gl.enableVertexAttribArray(this.texcoordLocation), this.gl.bufferData(this.gl.ARRAY_BUFFER, new Float32Array([0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1]), this.gl.STATIC_DRAW), this.gl.vertexAttribPointer(this.texcoordLocation, 2, this.gl.FLOAT, !1, 0, 0);
+  }
+  onXrSessionStarted(e) {
+    r.Log(r.GetStackTrace(), "XR Session started"), this.xrSession = e, this.xrSession.addEventListener("end", (() => {
+      this.onXrSessionEnded();
+    })), this.initGL(), this.initShaders(), this.initBuffers(), e.requestReferenceSpace("local").then(((t) => {
+      if (this.xrRefSpace = t, this.xrSession.updateRenderState({ baseLayer: new XRWebGLLayer(this.xrSession, this.gl) }), this.xrSession.supportedFrameRates) for (let s of this.xrSession.supportedFrameRates) s == 90 && e.updateTargetFrameRate(90);
+      this.xrSession.requestAnimationFrame(this.onXrFrame.bind(this));
+    })), this.onSessionStarted.dispatchEvent(new Event("xrSessionStarted"));
+  }
+  sendXRDataToUE() {
+    if (this.leftView == null || this.rightView == null) return;
+    const e = this.leftView.transform.matrix, t = this.leftView.projectionMatrix, s = this.rightView.transform.matrix, n = this.rightView.projectionMatrix;
+    this.webRtcController.streamMessageController.toStreamerHandlers.get("XREyeViews")([e[0], e[4], e[8], e[12], e[1], e[5], e[9], e[13], e[2], e[6], e[10], e[14], e[3], e[7], e[11], e[15], t[0], t[4], t[8], t[12], t[1], t[5], t[9], t[13], t[2], t[6], t[10], t[14], t[3], t[7], t[11], t[15], s[0], s[4], s[8], s[12], s[1], s[5], s[9], s[13], s[2], s[6], s[10], s[14], s[3], s[7], s[11], s[15], n[0], n[4], n[8], n[12], n[1], n[5], n[9], n[13], n[2], n[6], n[10], n[14], n[3], n[7], n[11], n[15]]);
+  }
+  onXrFrame(e, t) {
+    if (this.xrViewerPose = t.getViewerPose(this.xrRefSpace), this.xrViewerPose) {
+      if (this.updateViews(), this.leftView == null || this.rightView == null) return;
+      this.sendXRDataToUE(), this.updateVideoTexture(), this.render();
+    }
+    this.webRtcController.config.isFlagEnabled(l.XRControllerInput) && this.xrSession.inputSources.forEach(((s, n, i) => {
+      this.xrGamepadController.updateStatus(s, t, this.xrRefSpace);
+    }), this), this.xrSession.requestAnimationFrame(((s, n) => this.onXrFrame(s, n))), this.onFrame.dispatchEvent(new Qe({ time: e, frame: t }));
+  }
+  updateViews() {
+    if (this.xrViewerPose) for (const e of this.xrViewerPose.views) e.eye === "left" ? this.leftView = e : e.eye === "right" && (this.rightView = e);
+  }
+  render() {
+    if (!this.gl) return;
+    const e = this.xrSession.renderState.baseLayer;
+    this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, e.framebuffer), this.gl.viewport(0, 0, e.framebufferWidth, e.framebufferHeight), this.gl.drawArrays(this.gl.TRIANGLES, 0, 6);
+  }
+  static isSessionSupported(e) {
+    return location.protocol !== "https:" && r.Info(null, "WebXR requires https, if you want WebXR use https."), navigator.xr ? navigator.xr.isSessionSupported(e) : new Promise((() => !1));
+  }
+}
+class Zt {
+  constructor(e) {
+    this.editTextButton = null, this.hiddenInput = null, "ontouchstart" in document.documentElement && this.createOnScreenKeyboardHelpers(e);
+  }
+  unquantizeAndDenormalizeUnsigned(e, t) {
+    return null;
+  }
+  createOnScreenKeyboardHelpers(e) {
+    this.hiddenInput || (this.hiddenInput = document.createElement("input"), this.hiddenInput.id = "hiddenInput", this.hiddenInput.maxLength = 0, this.hiddenInput.style.position = "absolute", this.hiddenInput.style.left = "-10%", this.hiddenInput.style.width = "0px", this.hiddenInput.style.opacity = "0", e.appendChild(this.hiddenInput)), this.editTextButton || (this.editTextButton = document.createElement("button"), this.editTextButton.id = "editTextButton", this.editTextButton.innerHTML = "edit text", e.appendChild(this.editTextButton), this.editTextButton.style.display = "none", this.editTextButton.addEventListener("touchend", ((t) => {
+      this.hiddenInput.focus(), t.preventDefault();
+    })));
+  }
+  showOnScreenKeyboard(e) {
+    if (e.showOnScreenKeyboard) {
+      this.editTextButton.style.display = "default";
+      const t = this.unquantizeAndDenormalizeUnsigned(e.x, e.y);
+      this.editTextButton.style.top = t.y.toString() + "px", this.editTextButton.style.left = (t.x - 40).toString() + "px";
+    } else this.editTextButton.style.display = "none", this.hiddenInput.blur();
+  }
+}
+class es {
+  constructor(e) {
+    this.seq = e.Seq, this.playerSentTimestamp = Date.now(), this.requestFillerSize = e.Filler ? e.Filler.length : 0;
+  }
+  update(e) {
+    this.playerReceivedTimestamp = Date.now(), this.streamerReceivedTimestamp = e.ReceivedTimestamp, this.streamerSentTimestamp = e.SentTimestamp, this.responseFillerSize = e.Filler ? e.Filler.length : 0;
+  }
+}
+class ts {
+  constructor(e, t) {
+    this.sink = e, this.callback = t, this.records = /* @__PURE__ */ new Map(), this.seq = 0;
+  }
+  start(e) {
+    return !this.isRunning() && (this.startTime = Date.now(), this.records.clear(), this.interval = setInterval((() => {
+      Date.now() - this.startTime >= e.duration ? this.stop() : this.sendRequest(e.requestSize, e.responseSize);
+    }).bind(this), Math.floor(1e3 / e.rps)), !0);
+  }
+  stop() {
+    this.interval && (clearInterval(this.interval), this.interval = void 0, this.callback(this.produceResult()));
+  }
+  produceResult() {
+    const e = new Map(this.records);
+    return { records: e, dataChannelRtt: Math.ceil(Array.from(this.records.values()).reduce(((t, s) => t + (s.playerReceivedTimestamp - s.playerSentTimestamp)), 0) / this.records.size), playerToStreamerTime: Math.ceil(Array.from(this.records.values()).reduce(((t, s) => t + (s.streamerReceivedTimestamp - s.playerSentTimestamp)), 0) / this.records.size), streamerToPlayerTime: Math.ceil(Array.from(this.records.values()).reduce(((t, s) => t + (s.playerReceivedTimestamp - s.streamerSentTimestamp)), 0) / this.records.size), exportLatencyAsCSV: () => {
+      let t = `Timestamp;RTT;PlayerToStreamer;StreamerToPlayer;
+`;
+      return e.forEach(((s) => {
+        t += s.playerSentTimestamp + ";", t += s.playerReceivedTimestamp - s.playerSentTimestamp + ";", t += s.streamerReceivedTimestamp - s.playerSentTimestamp + ";", t += s.playerReceivedTimestamp - s.streamerSentTimestamp + ";", t += `
+`;
+      })), t;
+    } };
+  }
+  isRunning() {
+    return !!this.interval;
+  }
+  receive(e) {
+    if (!this.isRunning()) return;
+    if (!e) return void r.Error(r.GetStackTrace(), "Undefined response from server");
+    let t = this.records.get(e.Seq);
+    t && t.update(e);
+  }
+  sendRequest(e, t) {
+    let s = this.createRequest(e, t), n = new es(s);
+    this.records.set(n.seq, n), this.sink(s);
+  }
+  createRequest(e, t) {
+    return { Seq: this.seq++, FillResponseSize: t, Filler: e ? "A".repeat(e) : "" };
+  }
+}
+class ss {
+  constructor(e, t) {
+    this.allowConsoleCommands = !1, this.config = e, t?.videoElementParent && (this._videoElementParent = t.videoElementParent), this._eventEmitter = new je(), this.configureSettings(), this.setWebRtcPlayerController(new ot(this.config, this)), this.onScreenKeyboardHelper = new Zt(this.videoElementParent), this.onScreenKeyboardHelper.unquantizeAndDenormalizeUnsigned = (s, n) => this._webRtcController.requestUnquantizedAndDenormalizeUnsigned(s, n), this._activateOnScreenKeyboard = (s) => this.onScreenKeyboardHelper.showOnScreenKeyboard(s), this._webXrController = new lt(this._webRtcController), this._setupWebRtcTCPRelayDetection = this._setupWebRtcTCPRelayDetection.bind(this), this._eventEmitter.addEventListener("webRtcConnected", ((s) => {
+      this._eventEmitter.addEventListener("statsReceived", this._setupWebRtcTCPRelayDetection);
+    }));
+  }
+  get videoElementParent() {
+    return this._videoElementParent || (this._videoElementParent = document.createElement("div"), this._videoElementParent.id = "videoElementParent"), this._videoElementParent;
+  }
+  configureSettings() {
+    this.config._addOnSettingChangedListener(l.IsQualityController, ((e) => {
+      e !== !0 || this._webRtcController.isQualityController || this._webRtcController.sendRequestQualityControlOwnership();
+    })), this.config._addOnSettingChangedListener(l.AFKDetection, ((e) => {
+      this._webRtcController.setAfkEnabled(e);
+    })), this.config._addOnSettingChangedListener(l.MatchViewportResolution, (() => {
+      this._webRtcController.videoPlayer.updateVideoStreamSize();
+    })), this.config._addOnSettingChangedListener(l.HoveringMouseMode, ((e) => {
+      this.config.setFlagLabel(l.HoveringMouseMode, `Control Scheme: ${e ? "Hovering" : "Locked"} Mouse`), this._webRtcController.setMouseInputEnabled(this.config.isFlagEnabled(l.MouseInput));
+    })), this.config._addOnSettingChangedListener(l.KeyboardInput, ((e) => {
+      this._webRtcController.setKeyboardInputEnabled(e);
+    })), this.config._addOnSettingChangedListener(l.MouseInput, ((e) => {
+      this._webRtcController.setMouseInputEnabled(e);
+    })), this.config._addOnSettingChangedListener(l.FakeMouseWithTouches, ((e) => {
+      this._webRtcController.setTouchInputEnabled(this.config.isFlagEnabled(l.TouchInput));
+    })), this.config._addOnSettingChangedListener(l.TouchInput, ((e) => {
+      this._webRtcController.setTouchInputEnabled(e);
+    })), this.config._addOnSettingChangedListener(l.GamepadInput, ((e) => {
+      this._webRtcController.setGamePadInputEnabled(e);
+    })), this.config._addOnNumericSettingChangedListener(h.MinQP, ((e) => {
+      r.Log(r.GetStackTrace(), "--------  Sending MinQP  --------", 7), this._webRtcController.sendEncoderMinQP(e), r.Log(r.GetStackTrace(), "-------------------------------------------", 7);
+    })), this.config._addOnNumericSettingChangedListener(h.MaxQP, ((e) => {
+      r.Log(r.GetStackTrace(), "--------  Sending encoder settings  --------", 7), this._webRtcController.sendEncoderMaxQP(e), r.Log(r.GetStackTrace(), "-------------------------------------------", 7);
+    })), this.config._addOnNumericSettingChangedListener(h.WebRTCMinBitrate, ((e) => {
+      r.Log(r.GetStackTrace(), "--------  Sending web rtc settings  --------", 7), this._webRtcController.sendWebRTCMinBitrate(1e3 * e), r.Log(r.GetStackTrace(), "-------------------------------------------", 7);
+    })), this.config._addOnNumericSettingChangedListener(h.WebRTCMaxBitrate, ((e) => {
+      r.Log(r.GetStackTrace(), "--------  Sending web rtc settings  --------", 7), this._webRtcController.sendWebRTCMaxBitrate(1e3 * e), r.Log(r.GetStackTrace(), "-------------------------------------------", 7);
+    })), this.config._addOnNumericSettingChangedListener(h.WebRTCFPS, ((e) => {
+      r.Log(r.GetStackTrace(), "--------  Sending web rtc settings  --------", 7), this._webRtcController.sendWebRTCFps(e), r.Log(r.GetStackTrace(), "-------------------------------------------", 7);
+    })), this.config._addOnOptionSettingChangedListener(f.PreferredCodec, ((e) => {
+      this._webRtcController && this._webRtcController.setPreferredCodec(e);
+    })), this.config._registerOnChangeEvents(this._eventEmitter);
+  }
+  _activateOnScreenKeyboard(e) {
+    throw new Error("Method not implemented.");
+  }
+  _onInputControlOwnership(e) {
+    this._inputController = e;
+  }
+  setWebRtcPlayerController(e) {
+    this._webRtcController = e, this._webRtcController.setPreferredCodec(this.config.getSettingOption(f.PreferredCodec).selected), this._webRtcController.resizePlayerStyle(), this.checkForAutoConnect();
+  }
+  connect() {
+    this._eventEmitter.dispatchEvent(new Ae()), this._webRtcController.connectToSignallingServer();
+  }
+  reconnect() {
+    this._eventEmitter.dispatchEvent(new Oe()), this._webRtcController.tryReconnect("Reconnecting...");
+  }
+  disconnect() {
+    this._eventEmitter.dispatchEvent(new De()), this._webRtcController.close();
+  }
+  play() {
+    this._onStreamLoading(), this._webRtcController.playStream();
+  }
+  checkForAutoConnect() {
+    this.config.isFlagEnabled(l.AutoConnect) && (this._onWebRtcAutoConnect(), this._webRtcController.connectToSignallingServer());
+  }
+  unmuteMicrophone(e = !1) {
+    if (!this.config.isFlagEnabled("UseMic")) return e ? (this.config.setFlagEnabled("UseMic", !0), void this.reconnect()) : void r.Warning(r.GetStackTrace(), "Trying to unmute mic, but PixelStreaming was initialized with no microphone track. Call with forceEnable == true to re-connect with a mic track.");
+    this.setMicrophoneMuted(!1);
+  }
+  muteMicrophone() {
+    this.config.isFlagEnabled("UseMic") ? this.setMicrophoneMuted(!0) : r.Info(r.GetStackTrace(), "Trying to mute mic, but PixelStreaming has no microphone track, so sending sound is already disabled.");
+  }
+  setMicrophoneMuted(e) {
+    var t, s, n, i;
+    for (const o of (i = (n = (s = (t = this._webRtcController) === null || t === void 0 ? void 0 : t.peerConnectionController) === null || s === void 0 ? void 0 : s.peerConnection) === null || n === void 0 ? void 0 : n.getTransceivers()) !== null && i !== void 0 ? i : []) st.canTransceiverSendAudio(o) && (o.sender.track.enabled = !e);
+  }
+  _onWebRtcAutoConnect() {
+    this._eventEmitter.dispatchEvent(new Ee());
+  }
+  _onWebRtcSdp() {
+    this._eventEmitter.dispatchEvent(new ye());
+  }
+  _onStreamLoading() {
+    this._eventEmitter.dispatchEvent(new Fe());
+  }
+  _onDisconnect(e, t) {
+    this._eventEmitter.dispatchEvent(new Pe({ eventString: e, allowClickToReconnect: t }));
+  }
+  _onWebRtcConnecting() {
+    this._eventEmitter.dispatchEvent(new Me());
+  }
+  _onWebRtcConnected() {
+    this._eventEmitter.dispatchEvent(new we());
+  }
+  _onWebRtcFailed() {
+    this._eventEmitter.dispatchEvent(new be());
+  }
+  _onVideoInitialized() {
+    this._eventEmitter.dispatchEvent(new xe()), this._videoStartTime = Date.now();
+  }
+  _onLatencyTestResult(e) {
+    this._eventEmitter.dispatchEvent(new He({ latencyTimings: e }));
+  }
+  _onDataChannelLatencyTestResponse(e) {
+    this._eventEmitter.dispatchEvent(new We({ response: e }));
+  }
+  _onVideoStats(e) {
+    this._videoStartTime && this._videoStartTime !== void 0 || (this._videoStartTime = Date.now()), e.handleSessionStatistics(this._videoStartTime, this._inputController, this._webRtcController.videoAvgQp), this._eventEmitter.dispatchEvent(new ze({ aggregatedStats: e }));
+  }
+  _onVideoEncoderAvgQP(e) {
+    this._eventEmitter.dispatchEvent(new Te({ avgQP: e }));
+  }
+  _onInitialSettings(e) {
+    var t;
+    this._eventEmitter.dispatchEvent(new Ke({ settings: e })), e.PixelStreamingSettings && (this.allowConsoleCommands = (t = e.PixelStreamingSettings.AllowPixelStreamingCommands) !== null && t !== void 0 && t, this.allowConsoleCommands === !1 && r.Info(r.GetStackTrace(), "-AllowPixelStreamingCommands=false, sending arbitrary console commands from browser to UE is disabled."));
+    const s = this.config.useUrlParams, n = new URLSearchParams(window.location.search);
+    r.Info(r.GetStackTrace(), `using URL parameters ${s}`), e.EncoderSettings && (this.config.setNumericSetting(h.MinQP, s && n.has(h.MinQP) ? Number.parseFloat(n.get(h.MinQP)) : e.EncoderSettings.MinQP), this.config.setNumericSetting(h.MaxQP, s && n.has(h.MaxQP) ? Number.parseFloat(n.get(h.MaxQP)) : e.EncoderSettings.MaxQP)), e.WebRTCSettings && (this.config.setNumericSetting(h.WebRTCMinBitrate, s && n.has(h.WebRTCMinBitrate) ? Number.parseFloat(n.get(h.WebRTCMinBitrate)) : e.WebRTCSettings.MinBitrate / 1e3), this.config.setNumericSetting(h.WebRTCMaxBitrate, s && n.has(h.WebRTCMaxBitrate) ? Number.parseFloat(n.get(h.WebRTCMaxBitrate)) : e.WebRTCSettings.MaxBitrate / 1e3), this.config.setNumericSetting(h.WebRTCFPS, s && n.has(h.WebRTCFPS) ? Number.parseFloat(n.get(h.WebRTCFPS)) : e.WebRTCSettings.FPS));
+  }
+  _onQualityControlOwnership(e) {
+    this.config.setFlagEnabled(l.IsQualityController, e);
+  }
+  _onPlayerCount(e) {
+    this._eventEmitter.dispatchEvent(new qe({ count: e }));
+  }
+  _setupWebRtcTCPRelayDetection(e) {
+    let t = e.data.aggregatedStats.getActiveCandidatePair();
+    if (t != null) {
+      let s = e.data.aggregatedStats.localCandidates.find(((n) => n.id == t.localCandidateId), null);
+      s != null && s.candidateType == "relay" && s.relayProtocol == "tcp" && this._eventEmitter.dispatchEvent(new $e()), this._eventEmitter.removeEventListener("statsReceived", this._setupWebRtcTCPRelayDetection);
+    }
+  }
+  requestLatencyTest() {
+    return !!this._webRtcController.videoPlayer.isVideoReady() && (this._webRtcController.sendLatencyTest(), !0);
+  }
+  requestDataChannelLatencyTest(e) {
+    return !!this._webRtcController.videoPlayer.isVideoReady() && (this._dataChannelLatencyTestController || (this._dataChannelLatencyTestController = new ts(this._webRtcController.sendDataChannelLatencyTest.bind(this._webRtcController), ((t) => {
+      this._eventEmitter.dispatchEvent(new Ne({ result: t }));
+    })), this.addEventListener("dataChannelLatencyTestResponse", (({ data: { response: t } }) => {
+      this._dataChannelLatencyTestController.receive(t);
+    }))), this._dataChannelLatencyTestController.start(e));
+  }
+  requestShowFps() {
+    return !!this._webRtcController.videoPlayer.isVideoReady() && (this._webRtcController.sendShowFps(), !0);
+  }
+  requestIframe() {
+    return !!this._webRtcController.videoPlayer.isVideoReady() && (this._webRtcController.sendIframeRequest(), !0);
+  }
+  emitUIInteraction(e) {
+    return !!this._webRtcController.videoPlayer.isVideoReady() && (this._webRtcController.emitUIInteraction(e), !0);
+  }
+  emitCommand(e) {
+    return !(!this._webRtcController.videoPlayer.isVideoReady() || !this.allowConsoleCommands && "ConsoleCommand" in e || (this._webRtcController.emitCommand(e), 0));
+  }
+  emitConsoleCommand(e) {
+    return !(!this.allowConsoleCommands || !this._webRtcController.videoPlayer.isVideoReady() || (this._webRtcController.emitConsoleCommand(e), 0));
+  }
+  addResponseEventListener(e, t) {
+    this._webRtcController.responseController.addResponseEventListener(e, t);
+  }
+  removeResponseEventListener(e) {
+    this._webRtcController.responseController.removeResponseEventListener(e);
+  }
+  dispatchEvent(e) {
+    return this._eventEmitter.dispatchEvent(e);
+  }
+  addEventListener(e, t) {
+    this._eventEmitter.addEventListener(e, t);
+  }
+  removeEventListener(e, t) {
+    this._eventEmitter.removeEventListener(e, t);
+  }
+  toggleXR() {
+    this.webXrController.xrClicked();
+  }
+  setSignallingUrlBuilder(e) {
+    this._webRtcController.signallingUrlBuilder = e;
+  }
+  get webSocketController() {
+    return this._webRtcController.webSocketController;
+  }
+  get webXrController() {
+    return this._webXrController;
+  }
+  registerMessageHandler(e, t, s) {
+    t !== p.FromStreamer || s !== void 0 ? t === p.ToStreamer && s === void 0 ? this._webRtcController.streamMessageController.registerMessageHandler(t, e, ((n) => this._webRtcController.sendMessageController.sendMessageToStreamer(e, n))) : this._webRtcController.streamMessageController.registerMessageHandler(t, e, ((n) => s(n))) : r.Warning(r.GetStackTrace(), `Unable to register an undefined handler for ${e}`);
+  }
+  get toStreamerHandlers() {
+    return this._webRtcController.streamMessageController.toStreamerHandlers;
+  }
+  isReconnecting() {
+    return this._webRtcController.isReconnecting;
+  }
+}
+class ns {
+}
+g.Dz;
+g.g$;
+g.Lt;
+g.Q9;
+g.qf;
+g.hV;
+g.z$;
+g.J0;
+var rs = g.De;
+g.$C;
+g.al;
+g._W;
+g.Gv;
+g.m;
+g.tz;
+g.Nu;
+g.zg;
+g.vp;
+g.vU;
+g.wF;
+g.rv;
+g.Nh;
+g.ss;
+g.qW;
+g.QL;
+g.cf;
+g.eM;
+g.Yd;
+g.Tk;
+g.iM;
+g.qy;
+g.ce;
+g.sK;
+g.Ok;
+g.q5;
+var is = g.g;
+g.xl;
+g.I;
+g.bx;
+g.dD;
+g.Ib;
+g.Az;
+g.Iw;
+g.qY;
+g.db;
+g.mR;
+g.Tn;
+g.rV;
+g.gh;
+g.Mi;
+g.j;
+g.YB;
+g.Yt;
+g.i5;
+g.x_;
+g.Am;
+g.eR;
+g.r8;
+g.u3;
+g.vd;
+g.iV;
+g.jZ;
+g.SW;
+g.ZH;
+g.Ni;
+g.lh;
+g.ZP;
+g.bq;
+g.$f;
+g.eu;
+g.Ax;
+g.Mc;
+const as = ({
+  signallingUrl: a,
+  autoConnect: e = !0,
+  width: t,
+  height: s,
+  onConnecting: n,
+  onLoading: i,
+  onConnected: o,
+  onDisconnected: d,
+  onError: c,
+  muted: m = !1
+}) => {
+  const u = G.useRef(null), v = G.useRef(null), S = G.useRef(!1), [y, P] = G.useState(!1), [x, C] = G.useState(!1), [A, R] = G.useState(null);
+  return G.useEffect(() => {
+    if (!(!u.current || !a)) {
+      n && n(), "mediaDevices" in navigator || Object.defineProperty(navigator, "mediaDevices", { value: {} }), navigator.mediaDevices.getUserMedia || (navigator.mediaDevices.getUserMedia = function() {
+        return Promise.reject(new Error("getUserMedia is not supported"));
+      });
+      try {
+        const w = new rs({
+          useUrlParams: !1,
+          initialSettings: {
+            ss: a,
+            AutoConnect: e,
+            AutoPlayVideo: !0,
+            StartVideoMuted: m,
+            UseMic: !1,
+            HoveringMouse: !1,
+            FakeMouseWithTouches: !0,
+            TouchInput: !1,
+            MouseInput: !1,
+            KeyboardInput: !1,
+            WaitForStreamer: !0
+          }
+        }), T = new is(w, {
+          videoElementParent: u.current
+        });
+        T.addEventListener("webRtcConnected", () => {
+          S.current = !0, P(!0), C(!1), R(null), o?.();
+        }), T.addEventListener("webRtcDisconnected", () => {
+          S.current = !1, P(!1), d?.();
+        }), T.addEventListener("streamLoading", () => {
+          C(!0), i?.();
+        }), T.addEventListener("playStreamError", () => {
+          R("Failed to play stream"), C(!1), c?.("Failed to play stream");
+        }), T.addEventListener("playStream", () => {
+          C(!1), S.current || (S.current = !0, P(!0), o?.());
+        }), T.addEventListener("videoInitialized", () => {
+          C(!1);
+        }), v.current = T;
+      } catch (w) {
+        R("Failed to initialize streaming: " + w.message), C(!1), c?.(w.message);
+      }
+      return () => {
+        if (v.current) {
+          try {
+            const w = v.current;
+            w._webSocketController && w._webSocketController.close(), v.current.disconnect();
+          } catch {
+          }
+          v.current = null;
+        }
+      };
+    }
+  }, [a, e, n, i, o, d, c]), G.useEffect(() => {
+    if (v.current)
+      try {
+        const T = v.current._webRtcController?.videoPlayer;
+        if (!T) return;
+        let j = !1;
+        if (T.audioElement) {
+          const X = T.audioElement.srcObject;
+          if (X) {
+            const H = X.getAudioTracks();
+            H.length > 0 && (H.forEach((J) => {
+              J.enabled = !m;
+            }), j = !0);
+          }
+        }
+        const z = T.getVideoElement();
+        if (z && z.srcObject && z.srcObject instanceof MediaStream) {
+          const H = z.srcObject.getAudioTracks();
+          H.length > 0 && (H.forEach((J) => {
+            J.enabled = !m;
+          }), j = !0);
+        }
+        !j && z && (z.muted = m);
+      } catch {
+      }
+  }, [m]), /* @__PURE__ */ O.jsxs(
+    "div",
+    {
+      className: "pixel-streaming-container",
+      style: {
+        width: t || "100%",
+        height: s || "100%",
+        position: "relative",
+        display: "flex",
+        flexDirection: "column",
+        touchAction: "none",
+        WebkitTouchCallout: "none",
+        WebkitUserSelect: "none",
+        userSelect: "none"
+      },
+      children: [
+        /* @__PURE__ */ O.jsx(
+          "div",
+          {
+            ref: u,
+            className: "player-container",
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              width: "100%",
+              height: "100%",
+              overflow: "hidden",
+              touchAction: "none"
+            }
+          }
+        ),
+        x && /* @__PURE__ */ O.jsxs("div", { className: "loading-overlay", children: [
+          /* @__PURE__ */ O.jsx("div", { className: "loading-spinner" }),
+          /* @__PURE__ */ O.jsx("div", { className: "loading-text", children: "Connecting to stream..." })
+        ] }),
+        !y && !x && A && /* @__PURE__ */ O.jsx("div", { className: "connection-overlay", children: /* @__PURE__ */ O.jsx("div", { className: "error-message", children: A }) })
+      ]
+    }
+  );
+};
+function ds({
+  className: a,
+  style: e,
+  autoConnect: t = !0,
+  muted: s = !1,
+  onConnected: n,
+  onDisconnected: i,
+  onError: o
+}) {
+  const { streamingUrl: d, setCloudStreamState: c } = dt();
+  if (!d)
+    return null;
+  const m = () => {
+    c(W.CONNECTING);
+  }, u = () => {
+    c(W.LOADING);
+  }, v = () => {
+    c(W.CONNECTED), n?.();
+  }, S = () => {
+    c(W.DISCONNECTED), i?.();
+  }, y = (P) => {
+    c(W.ERROR, P), o?.(P);
+  };
+  return /* @__PURE__ */ O.jsx("div", { className: a, style: e, children: /* @__PURE__ */ O.jsx(
+    as,
+    {
+      signallingUrl: d,
+      autoConnect: t,
+      muted: s,
+      onConnecting: m,
+      onLoading: u,
+      onConnected: v,
+      onDisconnected: S,
+      onError: y
+    }
+  ) });
+}
+export {
+  ds as RqmiiCloudAvatarPlayer
+};
+//# sourceMappingURL=RqmiiCloudAvatarPlayer-DpvI9bmI.js.map