@whereby.com/media 8.0.5 → 8.0.6

package/dist/index.mjs

@@ -1,99 +1,14 @@
-import { Device, detectDeviceAsync } from 'mediasoup-client';
 import adapterRaw from 'webrtc-adapter';
-import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
 import rtcstats from 'rtcstats';
 import { v4 as v4$1 } from 'uuid';
-import { io } from 'socket.io-client';
 import SDPUtils from 'sdp';
 import * as sdpTransform from 'sdp-transform';
 import { Address6 } from 'ip-address';
 import checkIp from 'check-ip';
 import validate from 'uuid-validate';
-
-class AssertionError extends Error {
-    constructor(options) {
-        super(options.message);
-        this.name = "AssertionError";
-        this.code = "ERR_ASSERTION";
-        this.actual = options.actual;
-        this.expected = options.expected;
-        this.operator = options.operator;
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, options.stackStartFn);
-        }
-    }
-}
-function innerOk(fn, argLen, value, message) {
-    if (!value) {
-        let generatedMessage = false;
-        if (argLen === 0) {
-            generatedMessage = true;
-            message = "No value argument passed to `assert.ok()`";
-        }
-        else if (message instanceof Error) {
-            throw message;
-        }
-        const err = new AssertionError({
-            actual: value,
-            expected: true,
-            message,
-            operator: "==",
-            stackStartFn: fn,
-        });
-        err.generatedMessage = generatedMessage;
-        throw err;
-    }
-}
-function innerFail(obj) {
-    if (obj.message instanceof Error)
-        throw obj.message;
-    throw new AssertionError(obj);
-}
-function ok(...args) {
-    innerOk(ok, args.length, ...args);
-}
-const assert = {
-    fail: (message) => {
-        innerFail({
-            actual: "fail()",
-            expected: "fail() should not be called",
-            message,
-            operator: "fail",
-            stackStartFn: assert.fail,
-        });
-    },
-    ok,
-};
-assert.notEqual = function notEqual(actual, expected, message) {
-    if (arguments.length < 2) {
-        throw new Error("'actual' and 'expected' arguments are required");
-    }
-    if (actual == expected) {
-        innerFail({
-            actual,
-            expected,
-            message,
-            operator: "!=",
-            stackStartFn: notEqual,
-        });
-    }
-};
-assert.ok = ok;
-
-const createWorker = (fn) => {
-    return new Worker(URL.createObjectURL(new Blob(["self.onmessage = ", fn.toString()], { type: "text/javascript" })));
-};
-const generateByteString = (count) => {
-    if (count === 0) {
-        return "";
-    }
-    const count2 = count / 2;
-    let result = "F";
-    while (result.length <= count2) {
-        result += result;
-    }
-    return result + result.substring(0, count - result.length);
-};
+import { Device, detectDeviceAsync } from 'mediasoup-client';
+import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';
+import { io } from 'socket.io-client';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -127,2389 +42,2357 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const getMediasoupDeviceAsync = (features) => __awaiter(void 0, void 0, void 0, function* () {
-    if (features.isNodeSdk) {
-        return new Device({ handlerName: "Safari12" });
-    }
-    let handlerName = (yield detectDeviceAsync()) ||
-        (/applecoremedia|applewebkit|safari/i.test(navigator.userAgent) ? "Safari12" : undefined);
-    if (/iphone|ipad/i.test(navigator.userAgent)) {
-        handlerName = "Safari12";
-    }
-    if (!handlerName)
-        handlerName = "Chrome111";
-    return new Device({ handlerName });
-});
-
-const word = "[a-fA-F\\d:]";
-const boundry = (options) => options && options.includeBoundaries ? `(?:(?<=\\s|^)(?=${word})|(?<=${word})(?=\\s|$))` : "";
-const v4 = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}";
-const v6segment = "[a-fA-F\\d]{1,4}";
-const v6 = `
-(?:
-(?:${v6segment}:){7}(?:${v6segment}|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
-(?:${v6segment}:){6}(?:${v4}|:${v6segment}|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4
-(?:${v6segment}:){5}(?::${v4}|(?::${v6segment}){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4
-(?:${v6segment}:){4}(?:(?::${v6segment}){0,1}:${v4}|(?::${v6segment}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4
-(?:${v6segment}:){3}(?:(?::${v6segment}){0,2}:${v4}|(?::${v6segment}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4
-(?:${v6segment}:){2}(?:(?::${v6segment}){0,3}:${v4}|(?::${v6segment}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4
-(?:${v6segment}:){1}(?:(?::${v6segment}){0,4}:${v4}|(?::${v6segment}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4
-(?::(?:(?::${v6segment}){0,5}:${v4}|(?::${v6segment}){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4
-)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1
-`
-    .replace(/\s*\/\/.*$/gm, "")
-    .replace(/\n/g, "")
-    .trim();
-const v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);
-const v4exact = new RegExp(`^${v4}$`);
-const v6exact = new RegExp(`^${v6}$`);
-const ipRegex = (options) => options && options.exact
-    ? v46Exact
-    : new RegExp(`(?:${boundry(options)}${v4}${boundry(options)})|(?:${boundry(options)}${v6}${boundry(options)})`, "g");
-ipRegex.v4 = (options) => options && options.exact ? v4exact : new RegExp(`${boundry(options)}${v4}${boundry(options)}`, "g");
-ipRegex.v6 = (options) => options && options.exact ? v6exact : new RegExp(`${boundry(options)}${v6}${boundry(options)}`, "g");
-
-const debugOn = new URLSearchParams(window.location.search).has("debug");
-class Logger {
-    constructor() {
-        this._isEnabled = false;
-        this._isEnabled = debugOn;
-    }
-    isEnabled() {
-        return this._isEnabled;
-    }
-    enable() {
-        this._isEnabled = true;
-    }
-    disable() {
-        this._isEnabled = false;
-    }
-    info(...params) {
-        if (!this._isEnabled) {
-            return;
-        }
-        return console.info(...params);
-    }
-    warn(...params) {
-        if (!this._isEnabled) {
-            return;
-        }
-        return console.warn(...params);
-    }
-    error(...params) {
-        if (!this._isEnabled) {
-            return;
-        }
-        return console.error(...params);
-    }
-    withDebugLogger(myDebugger) {
-        this._debugger = myDebugger;
-        return this;
-    }
-    debug(...params) {
-        if (!this._isEnabled || !this._debugger) {
-            return;
-        }
-        const suppliedParams = [];
-        params.forEach((param) => {
-            if (typeof param === "function") {
-                const suppliedParam = param();
-                suppliedParams.push(suppliedParam);
+var _a$7;
+(_a$7 = adapterRaw.default) !== null && _a$7 !== void 0 ? _a$7 : adapterRaw;
+const RTCSTATS_PROTOCOL_VERSION = "1.0";
+const GETSTATS_BUFFER_SIZE = 20;
+const clientInfo = {
+    id: v4$1(),
+    connectionNumber: 0,
+};
+const noop = () => { };
+let resetDelta = noop;
+function rtcStatsConnection(wsURL, logger = console) {
+    const buffer = [];
+    let ws;
+    let organizationId;
+    let clientId;
+    let displayName;
+    let userRole;
+    let roomSessionId;
+    let connectionShouldBeOpen;
+    let connectionAttempt = 0;
+    let hasPassedOnRoomSessionId = false;
+    let getStatsBufferUsed = 0;
+    let deviceId;
+    let roomProduct;
+    let roomMode;
+    let sfuServer;
+    let featureFlags;
+    const connection = {
+        connected: false,
+        attemptedConnectedAtLeastOnce: false,
+        trace: (...args) => {
+            args.push(Date.now());
+            if (args[0] === "customEvent" && args[2].type === "roomSessionId") {
+                const oldRoomSessionIdValue = roomSessionId && roomSessionId[2].value.roomSessionId;
+                const newRoomSessionIdValue = args[2].value.roomSessionId;
+                roomSessionId = args;
+                if (hasPassedOnRoomSessionId &&
+                    newRoomSessionIdValue &&
+                    newRoomSessionIdValue !== oldRoomSessionIdValue) {
+                    ws === null || ws === void 0 ? void 0 : ws.close();
+                }
+                if (newRoomSessionIdValue)
+                    hasPassedOnRoomSessionId = true;
             }
-            else {
-                suppliedParams.push(param);
+            else if (args[0] === "customEvent" && args[2].type === "clientId") {
+                clientId = args;
             }
-        });
-        this._debugger.print(...suppliedParams);
-    }
-}
-
-const logger$b = new Logger();
-const AUDIO_SETTINGS = {
-    codecOptions: {
-        opusDtx: true,
-        opusFec: true,
-    },
-    encodings: [{ dtx: true }],
-};
-const VIDEO_SETTINGS_HD = {
-    codecOptions: {
-        videoGoogleStartBitrate: 500,
-    },
-    encodings: [
-        { scaleResolutionDownBy: 4, maxBitrate: 150000 },
-        { scaleResolutionDownBy: 2, maxBitrate: 500000 },
-        { scaleResolutionDownBy: 1, maxBitrate: 1000000 },
-    ],
-};
-const VIDEO_SETTINGS_SD = {
-    codecOptions: {
-        videoGoogleStartBitrate: 500,
-    },
-    encodings: [
-        { scaleResolutionDownBy: 2, maxBitrate: 150000 },
-        { scaleResolutionDownBy: 1, maxBitrate: 500000 },
-    ],
-};
-const VIDEO_SETTINGS_VP9 = {
-    codecOptions: {
-        videoGoogleStartBitrate: 500,
+            else if (args[0] === "customEvent" && args[2].type === "organizationId") {
+                organizationId = args;
+            }
+            else if (args[0] === "customEvent" && args[2].type === "displayName") {
+                displayName = args;
+            }
+            else if (args[0] === "customEvent" && args[2].type === "userRole") {
+                userRole = args;
+            }
+            else if (args[0] === "customEvent" && args[2].type === "deviceId") {
+                deviceId = args;
+            }
+            else if (args[0] === "customEvent" && args[2].type === "roomProduct") {
+                roomProduct = args;
+            }
+            else if (args[0] === "customEvent" && args[2].type === "roomMode") {
+                roomMode = args;
+            }
+            else if (args[0] === "customEvent" && args[2].type === "sfuServer") {
+                sfuServer = args;
+            }
+            else if (args[0] === "customEvent" && args[2].type === "featureFlags") {
+                featureFlags = args;
+            }
+            if ((ws === null || ws === void 0 ? void 0 : ws.readyState) === WebSocket.OPEN) {
+                connectionAttempt = 0;
+                ws.send(JSON.stringify(args));
+            }
+            else if (args[0] === "getstats") {
+                if (getStatsBufferUsed < GETSTATS_BUFFER_SIZE) {
+                    getStatsBufferUsed++;
+                    buffer.push(args);
+                }
+            }
+            else if (args[0] === "customEvent" && args[2].type === "insightsStats") ;
+            else {
+                buffer.push(args);
+            }
+            if ((ws === null || ws === void 0 ? void 0 : ws.readyState) === WebSocket.CLOSED && connectionShouldBeOpen) {
+                setTimeout(() => {
+                    if (ws.readyState === WebSocket.CLOSED && connectionShouldBeOpen) {
+                        connection.connect();
+                    }
+                }, 1000 * connectionAttempt);
+            }
+        },
+        close: () => {
+            connectionShouldBeOpen = false;
+            ws === null || ws === void 0 ? void 0 : ws.close();
+        },
+        connect: () => {
+            connectionShouldBeOpen = true;
+            connectionAttempt += 1;
+            ws === null || ws === void 0 ? void 0 : ws.close();
+            connection.connected = true;
+            connection.attemptedConnectedAtLeastOnce = true;
+            ws = new WebSocket(wsURL + window.location.pathname, RTCSTATS_PROTOCOL_VERSION);
+            ws.onerror = (e) => {
+                connection.connected = false;
+                logger.warn(`[RTCSTATS] WebSocket error`, e);
+            };
+            ws.onclose = (e) => {
+                connection.connected = false;
+                logger.info(`[RTCSTATS] Closed ${e.code}`);
+                resetDelta();
+            };
+            ws.onopen = () => {
+                clientInfo.connectionNumber++;
+                ws.send(JSON.stringify(["clientInfo", null, clientInfo]));
+                if (organizationId) {
+                    ws.send(JSON.stringify(organizationId));
+                }
+                if (clientId) {
+                    ws.send(JSON.stringify(clientId));
+                }
+                if (roomSessionId) {
+                    ws.send(JSON.stringify(roomSessionId));
+                }
+                if (displayName) {
+                    ws.send(JSON.stringify(displayName));
+                }
+                if (userRole) {
+                    ws.send(JSON.stringify(userRole));
+                }
+                if (deviceId) {
+                    ws.send(JSON.stringify(deviceId));
+                }
+                if (roomMode) {
+                    ws.send(JSON.stringify(roomMode));
+                }
+                if (roomProduct) {
+                    ws.send(JSON.stringify(roomProduct));
+                }
+                if (sfuServer) {
+                    ws.send(JSON.stringify(sfuServer));
+                }
+                if (featureFlags) {
+                    ws.send(JSON.stringify(featureFlags));
+                }
+                while (buffer.length) {
+                    ws.send(JSON.stringify(buffer.shift()));
+                }
+                getStatsBufferUsed = 0;
+            };
+        },
+    };
+    return connection;
+}
+const RTCSTATS_URL = "wss://rtcstats.srv.whereby.com";
+const server = rtcStatsConnection(RTCSTATS_URL);
+const stats = rtcstats(server.trace, 10000, [""]);
+resetDelta = (stats === null || stats === void 0 ? void 0 : stats.resetDelta) || noop;
+const rtcStats = {
+    sendEvent: (type, value) => {
+        server.trace("customEvent", null, {
+            type,
+            value,
+        });
     },
-    encodings: [{ scalabilityMode: "L3T2", maxBitrate: 1000000 }],
-};
-const VIDEO_SETTINGS_VP9_LOW_BANDWIDTH = {
-    codecOptions: {
-        videoGoogleStartBitrate: 500,
+    sendAudioMuted: (muted) => {
+        rtcStats.sendEvent("audio_muted", { muted });
     },
-    encodings: [{ scalabilityMode: "L2T2", maxBitrate: 500000 }],
-};
-const SCREEN_SHARE_SETTINGS = {
-    encodings: [{}],
-};
-const SCREEN_SHARE_SIMULCAST_SETTINGS = {
-    encodings: [
-        { scaleResolutionDownBy: 2, dtx: true, maxBitrate: 500000 },
-        { scaleResolutionDownBy: 1, dtx: true, maxBitrate: 1500000 },
-    ],
-};
-const ADDITIONAL_SCREEN_SHARE_SETTINGS = {
-    encodings: [
-        { scaleResolutionDownBy: 4, dtx: true, maxBitrate: 150000 },
-        { scaleResolutionDownBy: 2, dtx: true, maxBitrate: 500000 },
-        { scaleResolutionDownBy: 1, dtx: true, maxBitrate: 1500000 },
-    ],
+    sendVideoMuted: (muted) => {
+        rtcStats.sendEvent("video_muted", { muted });
+    },
+    server,
 };
-const getMediaSettings = (kind, isScreenShare, features, areTooManyAlreadyPresenting = false) => {
-    var _a;
-    const { lowDataModeEnabled, simulcastScreenshareOn, vp9On } = features;
-    if (kind === "audio") {
-        return AUDIO_SETTINGS;
-    }
-    const isChrome = ((_a = adapterRaw.browserDetails) === null || _a === void 0 ? void 0 : _a.browser) === "chrome";
-    const isVp9Available = isChrome && vp9On;
-    if (isScreenShare) {
-        return getScreenShareMediaSettings({
-            areTooManyAlreadyPresenting,
-            simulcastScreenshareOn,
-        });
-    }
-    else {
-        return getCameraMediaSettings({
-            lowBandwidth: lowDataModeEnabled,
-            isVp9Available,
-        });
+
+const debugOn = new URLSearchParams(window.location.search).has("debug");
+class Logger {
+    constructor() {
+        this._isEnabled = false;
+        this._isEnabled = debugOn;
     }
-};
-const getCameraMediaSettings = ({ lowBandwidth, isVp9Available, }) => {
-    if (lowBandwidth) {
-        if (isVp9Available) {
-            return VIDEO_SETTINGS_VP9_LOW_BANDWIDTH;
-        }
-        return VIDEO_SETTINGS_SD;
+    isEnabled() {
+        return this._isEnabled;
     }
-    if (isVp9Available) {
-        return VIDEO_SETTINGS_VP9;
+    enable() {
+        this._isEnabled = true;
     }
-    return VIDEO_SETTINGS_HD;
-};
-const getScreenShareMediaSettings = ({ areTooManyAlreadyPresenting, simulcastScreenshareOn, }) => {
-    if (areTooManyAlreadyPresenting) {
-        return ADDITIONAL_SCREEN_SHARE_SETTINGS;
+    disable() {
+        this._isEnabled = false;
     }
-    if (simulcastScreenshareOn)
-        return SCREEN_SHARE_SIMULCAST_SETTINGS;
-    return SCREEN_SHARE_SETTINGS;
-};
-var PrioritizableCodec;
-(function (PrioritizableCodec) {
-    PrioritizableCodec["H264"] = "video/h264";
-    PrioritizableCodec["VP9"] = "video/vp9";
-})(PrioritizableCodec || (PrioritizableCodec = {}));
-const modifyMediaCapabilities = (routerRtpCapabilities, features) => {
-    var _a;
-    const { vp9On, h264On } = features;
-    const isChrome = ((_a = adapterRaw.browserDetails) === null || _a === void 0 ? void 0 : _a.browser) === "chrome";
-    if (!(routerRtpCapabilities === null || routerRtpCapabilities === void 0 ? void 0 : routerRtpCapabilities.codecs)) {
-        return routerRtpCapabilities;
+    info(...params) {
+        if (!this._isEnabled) {
+            return;
+        }
+        return console.info(...params);
     }
-    if (vp9On && isChrome) {
-        const sorted = prioritizeRouterRtpCapabilitiesCodecs(routerRtpCapabilities.codecs, PrioritizableCodec.VP9);
-        return Object.assign(Object.assign({}, routerRtpCapabilities), { codecs: sorted });
+    warn(...params) {
+        if (!this._isEnabled) {
+            return;
+        }
+        return console.warn(...params);
     }
-    else if (h264On) {
-        const sorted = prioritizeRouterRtpCapabilitiesCodecs(routerRtpCapabilities.codecs, PrioritizableCodec.H264);
-        return Object.assign(Object.assign({}, routerRtpCapabilities), { codecs: sorted });
+    error(...params) {
+        if (!this._isEnabled) {
+            return;
+        }
+        return console.error(...params);
     }
-    return routerRtpCapabilities;
-};
-function prioritizeRouterRtpCapabilitiesCodecs(codecs, preferredCodec) {
-    const preferredCodecEntry = codecs.find(({ mimeType }) => mimeType.toLowerCase() === preferredCodec);
-    if (!preferredCodecEntry) {
-        return codecs;
+    withDebugLogger(myDebugger) {
+        this._debugger = myDebugger;
+        return this;
     }
-    return [...codecs].sort((left, right) => {
-        var _a;
-        if (left.mimeType.toLowerCase() === preferredCodec) {
-            return -1;
+    debug(...params) {
+        if (!this._isEnabled || !this._debugger) {
+            return;
         }
-        if (left.mimeType.toLowerCase() === "video/rtx" &&
-            ((_a = left.parameters) === null || _a === void 0 ? void 0 : _a.apt) === preferredCodecEntry.preferredPayloadType) {
-            if (right.mimeType.toLowerCase() === preferredCodec) {
-                return 1;
+        const suppliedParams = [];
+        params.forEach((param) => {
+            if (typeof param === "function") {
+                const suppliedParam = param();
+                suppliedParams.push(suppliedParam);
             }
-            return -1;
-        }
-        return 0;
-    });
-}
-function getPreferredOrder(availableCodecs, { av1On }) {
-    availableCodecs.unshift("video/vp9");
-    if (av1On) {
-        availableCodecs.unshift("video/av1");
+            else {
+                suppliedParams.push(param);
+            }
+        });
+        this._debugger.print(...suppliedParams);
     }
-    return availableCodecs;
 }
-function sortCodecsByMimeType(codecs, features) {
-    const availableCodecs = codecs
-        .map(({ mimeType }) => mimeType)
-        .filter((value, index, array) => array.indexOf(value) === index);
-    const preferredOrder = getPreferredOrder(availableCodecs, features);
-    return codecs.sort((a, b) => {
-        const indexA = preferredOrder.indexOf(a.mimeType.toLowerCase());
-        const indexB = preferredOrder.indexOf(b.mimeType.toLowerCase());
-        const orderA = indexA >= 0 ? indexA : Number.MAX_VALUE;
-        const orderB = indexB >= 0 ? indexB : Number.MAX_VALUE;
-        return orderA - orderB;
-    });
+
+var _a$6, _b$2;
+const adapter$6 = (_a$6 = adapterRaw.default) !== null && _a$6 !== void 0 ? _a$6 : adapterRaw;
+const logger$a = new Logger();
+const browserName$2 = (_b$2 = adapter$6.browserDetails) === null || _b$2 === void 0 ? void 0 : _b$2.browser;
+const browserVersion$1 = adapter$6.browserDetails.version;
+function setCodecPreferenceSDP({ sdp, redOn }) {
+    var _a, _b;
+    try {
+        const sdpObject = sdpTransform.parse(sdp);
+        if (Array.isArray(sdpObject === null || sdpObject === void 0 ? void 0 : sdpObject.media)) {
+            const mediaAudio = sdpObject.media.find((m) => m.type === "audio");
+            if (Array.isArray(mediaAudio === null || mediaAudio === void 0 ? void 0 : mediaAudio.rtp)) {
+                const rtp = mediaAudio.rtp;
+                for (let i = 0; i < rtp.length; i++) {
+                    if (redOn && rtp[i].codec === "red") {
+                        const payloads = (_a = mediaAudio.payloads) === null || _a === void 0 ? void 0 : _a.split(" ");
+                        const pt = payloads === null || payloads === void 0 ? void 0 : payloads.indexOf("" + rtp[i].payload);
+                        if (pt && pt !== -1 && pt >= 0) {
+                            payloads === null || payloads === void 0 ? void 0 : payloads.unshift(payloads.splice(pt, 1)[0]);
+                            mediaAudio.payloads = payloads === null || payloads === void 0 ? void 0 : payloads.join(" ");
+                        }
+                    }
+                }
+            }
+            const mediaVideo = sdpObject.media.find((m) => m.type === "video");
+            if (Array.isArray(mediaVideo === null || mediaVideo === void 0 ? void 0 : mediaVideo.rtp)) {
+                const rtp = mediaVideo.rtp;
+                for (let i = 0; i < rtp.length; i++) {
+                    if (rtp[i].codec === "VP9") {
+                        const payloads = (_b = mediaVideo.payloads) === null || _b === void 0 ? void 0 : _b.split(" ");
+                        const pt = payloads === null || payloads === void 0 ? void 0 : payloads.indexOf("" + rtp[i].payload);
+                        if (pt && pt !== -1 && pt >= 0) {
+                            payloads === null || payloads === void 0 ? void 0 : payloads.unshift(payloads.splice(pt, 1)[0]);
+                            mediaVideo.payloads = payloads === null || payloads === void 0 ? void 0 : payloads.join(" ");
+                        }
+                    }
+                }
+            }
+        }
+        const newSdp = sdpTransform.write(sdpObject);
+        return newSdp;
+    }
+    catch (error) {
+        logger$a.error("setCodecPreferenceSDP error:", error);
+        return sdp;
+    }
 }
-function getIsCodecDecodingPowerEfficient(codec) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { powerEfficient } = yield navigator.mediaCapabilities.decodingInfo({
-            type: "webrtc",
-            video: {
-                width: 1280,
-                height: 720,
-                bitrate: 2580,
-                framerate: 24,
-                contentType: codec,
-            },
+function cleanSdp(sdp) {
+    try {
+        const sdpObject = sdpTransform.parse(sdp);
+        sdpObject.media.forEach((mediaObject) => {
+            const usedPayloads = {};
+            if (mediaObject.payloads)
+                mediaObject.payloads = ("" + mediaObject.payloads)
+                    .split(" ")
+                    .filter((p) => !usedPayloads[p] && (usedPayloads[p] = true))
+                    .join(" ");
+            const usedRtps = {};
+            mediaObject.rtp = mediaObject.rtp.filter((p) => !p.payload || (usedPayloads[p.payload] && !usedRtps[p.payload] && (usedRtps[p.payload] = true)));
+            const usedFmtps = {};
+            if (mediaObject.fmtp)
+                mediaObject.fmtp = mediaObject.fmtp.filter((p) => !p.payload ||
+                    (usedPayloads[p.payload] && !usedFmtps[p.payload] && (usedFmtps[p.payload] = true)));
+            const usedRtcpFb = {};
+            if (mediaObject.rtcpFb)
+                mediaObject.rtcpFb = mediaObject.rtcpFb.filter((p) => !p.payload ||
+                    (usedPayloads[p.payload] &&
+                        !usedRtcpFb[p.payload + p.type + p.subtype] &&
+                        (usedRtcpFb[p.payload + p.type + p.subtype] = true)));
         });
-        return powerEfficient;
-    });
+        return sdpTransform.write(sdpObject);
+    }
+    catch (_) { }
+    return sdp;
 }
-function sortCodecsByPowerEfficiency(codecs) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let codecPowerEfficiencyEntries;
-        try {
-            codecPowerEfficiencyEntries = yield Promise.all(codecs.map(({ mimeType }) => getIsCodecDecodingPowerEfficient(mimeType).then((val) => [mimeType, val])));
+function deprioritizeH264(sdp) {
+    return SDPUtils.splitSections(sdp)
+        .map((section) => {
+        if (SDPUtils.getKind(section) !== "video")
+            return section;
+        const h264payloadTypes = SDPUtils.matchPrefix(section, "a=rtpmap:")
+            .map((line) => SDPUtils.parseRtpMap(line))
+            .filter((codec) => /h264/i.test(codec.name))
+            .map((codec) => "" + codec.payloadType);
+        if (!h264payloadTypes.length)
+            return section;
+        const mline = SDPUtils.matchPrefix(section, "m=video")[0];
+        const mlinePayloadsSectionExec = /(\s\d+)+$/i.exec(mline);
+        const mlinePayloadsSection = mlinePayloadsSectionExec ? mlinePayloadsSectionExec[0] : "";
+        const mlinePayloadsNonH264 = mlinePayloadsSection
+            .split(" ")
+            .filter((payloadType) => payloadType && !h264payloadTypes.includes(payloadType));
+        const reorderedPayloads = [...mlinePayloadsNonH264, ...h264payloadTypes].join(" ");
+        const newmline = mline.replace(mlinePayloadsSection, " " + reorderedPayloads);
+        return section.replace(mline, newmline);
+    })
+        .join("");
+}
+function filterMidExtension(sdp) {
+    if (browserName$2 !== "firefox" || (browserVersion$1 && browserVersion$1 >= 63) || browserVersion$1 === 60) {
+        return sdp;
+    }
+    return (SDPUtils.splitLines(sdp.trim())
+        .filter((line) => {
+        if (!line.startsWith("a=extmap:")) {
+            return true;
         }
-        catch (error) {
-            logger$b.error(error);
-            return codecs;
+        const extmap = SDPUtils.parseExtmap(line);
+        return extmap.uri !== "urn:ietf:params:rtp-hdrext:sdes:mid";
+    })
+        .join("\r\n") + "\r\n");
+}
+function filterMsidSemantic(sdp) {
+    if (browserName$2 !== "firefox" && browserVersion$1 < 68) {
+        return sdp;
+    }
+    return (SDPUtils.splitLines(sdp.trim())
+        .map((line) => (line.startsWith("a=msid-semantic:") ? "a=msid-semantic: WMS *" : line))
+        .join("\r\n") + "\r\n");
+}
+function addExtMap(sdp, extmapUri, modifyAudio = false, modifyVideo = false) {
+    var _a, _b;
+    try {
+        const sdpObj = sdpTransform.parse(sdp);
+        if (((_a = sdpObj === null || sdpObj === void 0 ? void 0 : sdpObj.ext) === null || _a === void 0 ? void 0 : _a.length) && sdpObj.ext.length > 0) {
+            return sdp;
         }
-        const codecPowerEfficiencies = Object.fromEntries(codecPowerEfficiencyEntries);
-        const sorted = codecs.sort((a, b) => {
-            const aPowerEfficient = codecPowerEfficiencies[a.mimeType];
-            const bPowerEfficient = codecPowerEfficiencies[b.mimeType];
-            return aPowerEfficient === bPowerEfficient ? 0 : aPowerEfficient ? -1 : 1;
+        if ((sdpObj === null || sdpObj === void 0 ? void 0 : sdpObj.media.length) < 1)
+            return sdp;
+        const allHeaderExtensions = sdpObj === null || sdpObj === void 0 ? void 0 : sdpObj.media.flatMap((section) => section.ext || []);
+        const extmapId = ((_b = allHeaderExtensions.find((ext) => ext.uri === extmapUri)) === null || _b === void 0 ? void 0 : _b.value) ||
+            [...new Set([0, 15, ...allHeaderExtensions.map((ext) => ext.value)])]
+                .sort((a, b) => a - b)
+                .find((n, i, arr) => n + 1 !== arr[i + 1]) + 1;
+        sdpObj.media.forEach((mediaSection) => {
+            var _a;
+            if ((modifyAudio && mediaSection.type === "audio") || (modifyVideo && mediaSection.type === "video")) {
+                if (!((_a = mediaSection.ext) === null || _a === void 0 ? void 0 : _a.find((e) => e.uri === extmapUri))) {
+                    if (Array.isArray(mediaSection.ext)) {
+                        mediaSection["ext"].push({ value: extmapId, uri: extmapUri });
+                    }
+                    else {
+                        mediaSection["ext"] = [{ value: extmapId, uri: extmapUri }];
+                    }
+                }
+            }
         });
-        return sorted;
-    });
+        return sdpTransform.write(sdpObj);
+    }
+    catch (error) {
+        console.error("Error during addAbsCaptureTimeExtMap: ", error);
+    }
+    return sdp;
 }
-function sortCodecs(codecs, features) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let sortedCodecs = sortCodecsByMimeType(codecs, features);
-        sortedCodecs = yield sortCodecsByPowerEfficiency(codecs);
-        return sortedCodecs;
-    });
+function addAbsCaptureTimeExtMap(sdp) {
+    const absCaptureTimeUri = "http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time";
+    return addExtMap(sdp, absCaptureTimeUri, true, true);
 }
 
-function captureCandidatePairInfoMetrics(cpMetrics, currentCptats, prevCptats, timeDiff, report) {
-    const bytesReceivedDiff = currentCptats.bytesReceived - ((prevCptats === null || prevCptats === void 0 ? void 0 : prevCptats.bytesReceived) || 0);
-    const bytesSentDiff = currentCptats.bytesSent - ((prevCptats === null || prevCptats === void 0 ? void 0 : prevCptats.bytesSent) || 0);
-    cpMetrics.bitrateIn = (8000 * bytesReceivedDiff) / timeDiff;
-    cpMetrics.bitrateOut = (8000 * bytesSentDiff) / timeDiff;
-    cpMetrics.state = currentCptats.state;
-    cpMetrics.roundTripTime = currentCptats.currentRoundTripTime;
-    cpMetrics.requestsSent = currentCptats.requestsSent;
-    cpMetrics.responsesReceived = currentCptats.responsesReceived;
-    cpMetrics.requestsReceived = currentCptats.requestsReceived;
-    cpMetrics.responsesSent = currentCptats.responsesSent;
-    cpMetrics.availableOutgoingBitrate = currentCptats.availableOutgoingBitrate;
-    cpMetrics.availableIncomingBitrate = currentCptats.availableIncomingBitrate;
-    const remote = report.get(currentCptats.remoteCandidateId);
-    const local = report.get(currentCptats.localCandidateId);
-    cpMetrics.usingTurn = false;
-    if (local) {
-        if (/relay/i.test(local.candidateType || "")) {
-            cpMetrics.usingTurn = true;
-            cpMetrics.turnProtocol = local.relayProtocol;
-        }
+function setVideoBandwidthUsingSetParameters(pc, bandwidth, logger = console) {
+    const sender = pc.getSenders().find((s) => s.track && s.track.kind === "video");
+    if (!sender) {
+        return Promise.resolve();
     }
-    if (remote && local) {
-        cpMetrics.localEp = `${local.protocol}:${local.address || local.ip}:${local.port} ${local.candidateType} (${local.networkType})`;
-        cpMetrics.remoteEp = `${remote.protocol}:${remote.address || remote.ip}:${remote.port} ${remote.candidateType}`;
+    const parameters = sender.getParameters();
+    if (parameters.encodings && parameters.encodings.length === 0) {
+        return Promise.resolve();
+    }
+    if (!parameters.encodings) {
+        parameters.encodings = [{}];
     }
+    if (bandwidth === 0) {
+        delete parameters.encodings[0].maxBitrate;
+    }
+    else {
+        parameters.encodings[0].maxBitrate = bandwidth * 1000;
+    }
+    return sender.setParameters(parameters).catch((err) => {
+        logger.error("setParameters err: ", err);
+    });
 }
-function captureSsrcInfo(ssrcMetrics, currentSsrcStats, prevSsrcStats, timeDiff, report) {
-    if (ssrcMetrics.codec)
-        return;
-    ssrcMetrics.kind = currentSsrcStats.kind || currentSsrcStats.mediaType;
-    ssrcMetrics.ssrc = currentSsrcStats.ssrc;
-    ssrcMetrics.direction = currentSsrcStats.type === "inbound-rtp" ? "in" : "out";
-    const codecStats = currentSsrcStats.codecId && report.get(currentSsrcStats.codecId);
-    ssrcMetrics.codec =
-        codecStats &&
-            [
-                codecStats.mimeType,
-                codecStats.channels && `${codecStats.channels}ch`,
-                codecStats.clockRate,
-                codecStats.payloadType,
-                currentSsrcStats.encoderImplementation || currentSsrcStats.decoderImplementation,
-                codecStats.sdpFmtpLine,
-            ]
-                .filter(Boolean)
-                .join(" ");
-    ssrcMetrics.mid = currentSsrcStats.mid;
-    ssrcMetrics.rid = currentSsrcStats.rid;
+
+const _trackAnnotations = new WeakMap();
+function trackAnnotations(o) {
+    let props = _trackAnnotations.get(o);
+    if (!props) {
+        props = {};
+        _trackAnnotations.set(o, props);
+    }
+    return props;
 }
-function captureCommonSsrcMetrics(ssrcMetrics, currentSsrcStats, prevSsrcStats, timeDiff, report) {
-    const nackCountDiff = (currentSsrcStats.nackCount || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.nackCount) || 0);
-    ssrcMetrics.nackCount = (ssrcMetrics.nackCount || 0) + nackCountDiff;
-    ssrcMetrics.nackRate = (1000 * nackCountDiff) / timeDiff;
-    if (ssrcMetrics.direction === "in") {
-        const packetCountDiff = currentSsrcStats.packetsReceived - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.packetsReceived) || 0);
-        ssrcMetrics.packetCount = (ssrcMetrics.packetCount || 0) + packetCountDiff;
-        ssrcMetrics.packetRate = (1000 * packetCountDiff) / timeDiff;
-        const packetLossCountDiff = currentSsrcStats.packetsLost - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.packetsLost) || 0);
-        ssrcMetrics.packetLossCount = (ssrcMetrics.packetLossCount || 0) + packetLossCountDiff;
-        ssrcMetrics.packetLossRate = (1000 * packetLossCountDiff) / timeDiff;
-        ssrcMetrics.lossRatio = (1000 * (packetLossCountDiff / (packetLossCountDiff + packetCountDiff))) / timeDiff;
-        const byteCountDiff = currentSsrcStats.bytesReceived - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.bytesReceived) || 0);
-        ssrcMetrics.byteCount = (ssrcMetrics.byteCount || 0) + byteCountDiff;
-        let headerByteCountDiff = 0;
-        if (currentSsrcStats.headerBytesReceived) {
-            headerByteCountDiff = currentSsrcStats.headerBytesReceived - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.headerBytesReceived) || 0);
-            ssrcMetrics.headerByteCount = (ssrcMetrics.headerByteCount || 0) + headerByteCountDiff;
+
+var _a$5;
+const adapter$5 = (_a$5 = adapterRaw.default) !== null && _a$5 !== void 0 ? _a$5 : adapterRaw;
+const logger$9 = new Logger();
+class Session {
+    constructor({ clientId, bandwidth, peerConnectionConfig, deprioritizeH264Encoding, incrementAnalyticMetric, }) {
+        this.relayCandidateSeen = false;
+        this.serverReflexiveCandidateSeen = false;
+        this.publicHostCandidateSeen = false;
+        this.ipv6HostCandidateSeen = false;
+        this.ipv6HostCandidateTeredoSeen = false;
+        this.ipv6HostCandidate6to4Seen = false;
+        this.mdnsHostCandidateSeen = false;
+        this.pendingReplaceTrackActions = [];
+        this.peerConnectionConfig = peerConnectionConfig;
+        this.clientId = clientId;
+        this.pc = new RTCPeerConnection(this.peerConnectionConfig);
+        this.signalingState = this.pc.signalingState;
+        this.pc.addEventListener("signalingstatechange", () => {
+            if (this.signalingState === this.pc.signalingState) {
+                return;
+            }
+            this.signalingState = this.pc.signalingState;
+            if (this.pc.signalingState === "stable") {
+                this.isOperationPending = false;
+                const action = this.pending.shift();
+                if (action) {
+                    action.apply();
+                }
+            }
+        });
+        this.wasEverConnected = false;
+        this.connectionStatus = null;
+        this.bandwidth = bandwidth || 0;
+        this.pending = [];
+        this.isOperationPending = false;
+        this.streamIds = [];
+        this.streams = [];
+        this.earlyIceCandidates = [];
+        this.afterConnected = new Promise((resolve) => {
+            this.registerConnected = resolve;
+        });
+        this._deprioritizeH264Encoding = deprioritizeH264Encoding;
+        this._incrementAnalyticMetric = incrementAnalyticMetric;
+    }
+    addStream(stream) {
+        this.streamIds.push(stream.id);
+        this.streams.push(stream);
+        stream.getAudioTracks().forEach((track) => {
+            this.pc.addTrack(track, stream);
+        });
+        stream.getVideoTracks().forEach((track) => {
+            this.pc.addTrack(track, stream);
+        });
+    }
+    addTrack(track, stream) {
+        if (!stream) {
+            stream = this.streams[0];
         }
-        const totalBytesDiff = byteCountDiff + headerByteCountDiff;
-        ssrcMetrics.bitrate = (8000 * totalBytesDiff) / timeDiff;
-        ssrcMetrics.mediaRatio = byteCountDiff / totalBytesDiff;
-        if (currentSsrcStats.kind === "audio") {
-            const fecBytesDiff = (currentSsrcStats.fecBytesReceived || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.fecBytesReceived) || 0);
-            ssrcMetrics.fecRatio = fecBytesDiff / byteCountDiff;
+        stream === null || stream === void 0 ? void 0 : stream.addTrack(track);
+        this.pc.addTrack(track, stream);
+    }
+    removeTrack(track) {
+        const stream = this.streams[0];
+        stream.removeTrack(track);
+        const sender = this.pc.getSenders().find((sender) => sender.track === track);
+        if (sender) {
+            this.pc.removeTrack(sender);
         }
-        const jitterBufferDelayDiff = (currentSsrcStats.jitterBufferDelay || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.jitterBufferDelay) || 0);
-        const jitterBufferEmittedDiff = (currentSsrcStats.jitterBufferEmittedCount || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.jitterBufferEmittedCount) || 0);
-        ssrcMetrics.jitter = jitterBufferEmittedDiff ? jitterBufferDelayDiff / jitterBufferEmittedDiff : 0;
     }
-    else {
-        const packetCountDiff = currentSsrcStats.packetsSent - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.packetsSent) || 0);
-        ssrcMetrics.packetCount = (ssrcMetrics.packetCount || 0) + packetCountDiff;
-        ssrcMetrics.packetRate = (1000 * packetCountDiff) / timeDiff;
-        const byteCountDiff = currentSsrcStats.bytesSent - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.bytesSent) || 0);
-        ssrcMetrics.byteCount = (ssrcMetrics.byteCount || 0) + byteCountDiff;
-        let headerByteCountDiff = 0;
-        if (currentSsrcStats.headerBytesSent) {
-            headerByteCountDiff = currentSsrcStats.headerBytesSent - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.headerBytesSent) || 0);
-            ssrcMetrics.headerByteCount = (ssrcMetrics.headerByteCount || 0) + headerByteCountDiff;
+    removeStream(stream) {
+        const streamIdIndex = this.streamIds.indexOf(stream.id);
+        if (streamIdIndex !== -1) {
+            this.streamIds.splice(streamIdIndex, 1);
         }
-        const totalBytesDiff = byteCountDiff + headerByteCountDiff;
-        ssrcMetrics.bitrate = (8000 * totalBytesDiff) / timeDiff;
-        ssrcMetrics.mediaRatio = byteCountDiff / totalBytesDiff;
-        const sendDelayDiff = currentSsrcStats.totalPacketSendDelay - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.totalPacketSendDelay) || 0);
-        ssrcMetrics.sendDelay = sendDelayDiff / packetCountDiff;
-        const retransDiff = currentSsrcStats.retransmittedPacketsSent - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.retransmittedPacketsSent) || 0);
-        ssrcMetrics.retransRatio = (1000 * (retransDiff / packetCountDiff)) / timeDiff;
-        if (currentSsrcStats.remoteId) {
-            const remoteReport = report.get(currentSsrcStats.remoteId);
-            if (remoteReport) {
-                ssrcMetrics.roundTripTime = remoteReport.roundTripTime || 0;
-                ssrcMetrics.jitter = remoteReport.jitter || 0;
-                ssrcMetrics.fractionLost = remoteReport.fractionLost || 0;
-            }
+        const streamIndex = this.streams.indexOf(stream);
+        if (streamIndex !== -1) {
+            this.streams.splice(streamIndex, 1);
         }
+        stream.getTracks().forEach((track) => {
+            const sender = this.pc.getSenders().find((sender) => sender.track === track);
+            if (sender) {
+                this.pc.removeTrack(sender);
+            }
+        });
     }
-}
-function captureAudioSsrcMetrics(ssrcMetrics, currentSsrcStats, prevSsrcStats, timeDiff, report) {
-    const packetsDiscardedDiff = currentSsrcStats.packetsDiscarded - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.packetsDiscarded) || 0);
-    ssrcMetrics.packetsDiscarded = (ssrcMetrics.packetsDiscarded || 0) + packetsDiscardedDiff;
-    if (ssrcMetrics.direction === "in") {
-        const totalAudioEnergyDiff = currentSsrcStats.totalAudioEnergy - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.totalAudioEnergy) || 0);
-        const totalSamplesDurationDiff = currentSsrcStats.totalSamplesDuration - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.totalSamplesDuration) || 0);
-        ssrcMetrics.audioLevel = Math.sqrt(totalAudioEnergyDiff / totalSamplesDurationDiff);
-        const samples = currentSsrcStats.totalSamplesReceived || 0;
-        const concealmentEvents = currentSsrcStats.concealmentEvents || 0;
-        const samplesDiff = samples - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.totalSamplesReceived) || 0);
-        const concealedSamples = currentSsrcStats.concealedSamples || 0;
-        const concealedDiff = concealedSamples - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.concealedSamples) || 0);
-        const silentConcealedDiff = (currentSsrcStats.silentConcealedSamples || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.silentConcealedSamples) || 0);
-        const insDiff = (currentSsrcStats.insertedSamplesForDeceleration || 0) -
-            ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.insertedSamplesForDeceleration) || 0);
-        const remDiff = (currentSsrcStats.removedSamplesForAcceleration || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.removedSamplesForAcceleration) || 0);
-        ssrcMetrics.audioSamples = samples;
-        ssrcMetrics.audioConcealmentEvents = concealmentEvents;
-        ssrcMetrics.audioConcealedSamples = concealedSamples;
-        ssrcMetrics.audioConcealment = concealedDiff ? concealedDiff / samplesDiff : 0;
-        ssrcMetrics.audioSilentConcealment = silentConcealedDiff ? silentConcealedDiff / samplesDiff : 0;
-        ssrcMetrics.audioAcceleration = remDiff ? remDiff / samplesDiff : 0;
-        ssrcMetrics.audioDeceleration = insDiff ? insDiff / samplesDiff : 0;
-    }
-}
-function captureVideoSsrcMetrics(ssrcMetrics, currentSsrcStats, prevSsrcStats, timeDiff, report) {
-    ssrcMetrics.width = currentSsrcStats.frameWidth;
-    ssrcMetrics.height = currentSsrcStats.frameHeight;
-    ssrcMetrics.qualityLimitationReason = currentSsrcStats.qualityLimitationReason || "";
-    const pliCountDiff = currentSsrcStats.pliCount - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.pliCount) || 0);
-    ssrcMetrics.pliCount = (ssrcMetrics.pliCount || 0) + pliCountDiff;
-    ssrcMetrics.pliRate = (1000 * pliCountDiff) / timeDiff;
-    const firCountDiff = currentSsrcStats.firCount - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.firCount) || 0);
-    ssrcMetrics.firCount = (ssrcMetrics.firCount || 0) + firCountDiff;
-    ssrcMetrics.firRate = (1000 * firCountDiff) / timeDiff;
-    if (ssrcMetrics.direction === "in") {
-        const kfCountDiff = currentSsrcStats.keyFramesDecoded - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.keyFramesDecoded) || 0);
-        ssrcMetrics.kfCount = (ssrcMetrics.kfCount || 0) + kfCountDiff;
-        ssrcMetrics.kfRate = (1000 * kfCountDiff) / timeDiff;
-        const frameCountDiff = currentSsrcStats.framesDecoded - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.framesDecoded) || 0);
-        ssrcMetrics.frameCount = (ssrcMetrics.frameCount || 0) + frameCountDiff;
-        const qpsumDiff = currentSsrcStats.qpSum - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.qpSum) || 0);
-        ssrcMetrics.qpf = qpsumDiff / frameCountDiff;
-        ssrcMetrics.fps = (frameCountDiff * 1000) / timeDiff;
+    _setRemoteDescription(desc) {
+        if (this._deprioritizeH264Encoding)
+            desc.sdp = deprioritizeH264(desc.sdp);
+        this.srdComplete = this.pc.setRemoteDescription(desc);
+        return this.srdComplete.then(() => {
+            this.earlyIceCandidates.forEach((candidate) => this.pc.addIceCandidate(candidate));
+            this.earlyIceCandidates = [];
+        });
     }
-    else {
-        const kfCountDiff = currentSsrcStats.keyFramesEncoded - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.keyFramesEncoded) || 0);
-        ssrcMetrics.kfCount = (ssrcMetrics.kfCount || 0) + kfCountDiff;
-        ssrcMetrics.kfRate = (1000 * kfCountDiff) / timeDiff;
-        const frameCountDiff = currentSsrcStats.framesEncoded - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.framesEncoded) || 0);
-        ssrcMetrics.frameCount = (ssrcMetrics.frameCount || 0) + frameCountDiff;
-        const qpsumDiff = currentSsrcStats.qpSum - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.qpSum) || 0);
-        ssrcMetrics.qpf = qpsumDiff / frameCountDiff;
-        ssrcMetrics.fps = (frameCountDiff * 1000) / timeDiff;
-        const encodeTimeDiff = currentSsrcStats.totalEncodeTime - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.totalEncodeTime) || 0);
-        ssrcMetrics.encodeTime = encodeTimeDiff / frameCountDiff;
-        if (currentSsrcStats.mediaSourceId) {
-            const mediaSourceReport = report.get(currentSsrcStats.mediaSourceId);
-            if (mediaSourceReport) {
-                ssrcMetrics.sourceWidth = mediaSourceReport.width || 0;
-                ssrcMetrics.sourceHeight = mediaSourceReport.height || 0;
-                ssrcMetrics.sourceFps = mediaSourceReport.framesPerSecond || 0;
-            }
+    handleOffer(offer) {
+        if (!this.canModifyPeerConnection()) {
+            return new Promise((resolve) => {
+                this.pending.push(() => this.handleOffer(offer).then(resolve));
+            });
         }
-    }
-}
-
-var _a$7;
-(_a$7 = adapterRaw.default) !== null && _a$7 !== void 0 ? _a$7 : adapterRaw;
-const RTCSTATS_PROTOCOL_VERSION = "1.0";
-const GETSTATS_BUFFER_SIZE = 20;
-const clientInfo = {
-    id: v4$1(),
-    connectionNumber: 0,
-};
-const noop = () => { };
-let resetDelta = noop;
-function rtcStatsConnection(wsURL, logger = console) {
-    const buffer = [];
-    let ws;
-    let organizationId;
-    let clientId;
-    let displayName;
-    let userRole;
-    let roomSessionId;
-    let connectionShouldBeOpen;
-    let connectionAttempt = 0;
-    let hasPassedOnRoomSessionId = false;
-    let getStatsBufferUsed = 0;
-    let deviceId;
-    let roomProduct;
-    let roomMode;
-    let sfuServer;
-    let featureFlags;
-    const connection = {
-        connected: false,
-        attemptedConnectedAtLeastOnce: false,
-        trace: (...args) => {
-            args.push(Date.now());
-            if (args[0] === "customEvent" && args[2].type === "roomSessionId") {
-                const oldRoomSessionIdValue = roomSessionId && roomSessionId[2].value.roomSessionId;
-                const newRoomSessionIdValue = args[2].value.roomSessionId;
-                roomSessionId = args;
-                if (hasPassedOnRoomSessionId &&
-                    newRoomSessionIdValue &&
-                    newRoomSessionIdValue !== oldRoomSessionIdValue) {
-                    ws === null || ws === void 0 ? void 0 : ws.close();
-                }
-                if (newRoomSessionIdValue)
-                    hasPassedOnRoomSessionId = true;
-            }
-            else if (args[0] === "customEvent" && args[2].type === "clientId") {
-                clientId = args;
-            }
-            else if (args[0] === "customEvent" && args[2].type === "organizationId") {
-                organizationId = args;
+        this.isOperationPending = true;
+        let sdp = offer.sdp;
+        sdp = filterMidExtension(sdp);
+        sdp = filterMsidSemantic(sdp);
+        const desc = { type: offer.type, sdp };
+        let answerToSignal;
+        return this._setRemoteDescription(desc)
+            .then(() => {
+            return this.pc.createAnswer();
+        })
+            .then((answer) => {
+            if (!answer.sdp) {
+                throw new Error("SDP undefined while creating answer");
             }
-            else if (args[0] === "customEvent" && args[2].type === "displayName") {
-                displayName = args;
+            else {
+                answerToSignal = {
+                    sdp: answer.sdp,
+                    sdpU: answer.sdp,
+                    type: answer.type,
+                };
+                return this.pc.setLocalDescription(answer);
             }
-            else if (args[0] === "customEvent" && args[2].type === "userRole") {
-                userRole = args;
+        })
+            .then(() => {
+            return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
+        })
+            .then(() => {
+            return answerToSignal;
+        });
+    }
+    handleAnswer(message) {
+        const sdp = filterMsidSemantic(message.sdp);
+        const desc = { type: message.type, sdp };
+        return this._setRemoteDescription(desc).then(() => {
+            return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
+        });
+    }
+    addIceCandidate(candidate) {
+        if (!this.srdComplete) {
+            this.earlyIceCandidates.push(candidate);
+            return;
+        }
+        this.srdComplete.then(() => {
+            var _a;
+            if (this.pc.signalingState === "closed") {
+                return;
             }
-            else if (args[0] === "customEvent" && args[2].type === "deviceId") {
-                deviceId = args;
+            if (((_a = adapter$5.browserDetails) === null || _a === void 0 ? void 0 : _a.browser) === "safari" && candidate && candidate.candidate === "") {
+                return;
             }
-            else if (args[0] === "customEvent" && args[2].type === "roomProduct") {
-                roomProduct = args;
+            this.pc.addIceCandidate(candidate).catch((e) => {
+                logger$9.warn("Failed to add ICE candidate ('%s'): %s", candidate ? candidate.candidate : null, e);
+            });
+        });
+    }
+    canModifyPeerConnection() {
+        return this.pc.signalingState === "stable" && !this.isOperationPending;
+    }
+    close() {
+        const pc = this.pc;
+        if (!pc) {
+            return;
+        }
+        pc.oniceconnectionstatechange = null;
+        pc.onicecandidate = null;
+        pc.ontrack = null;
+        try {
+            pc.close();
+        }
+        catch (e) {
+            logger$9.warn("failures during close of session", e);
+        }
+    }
+    hasConnectedPeerConnection() {
+        return this.pc.connectionState === "connected";
+    }
+    replaceTrack(oldTrack, newTrack) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger$9.info("replacetrack() [oldTrackId: %s, newTrackId: %s]", oldTrack === null || oldTrack === void 0 ? void 0 : oldTrack.id, newTrack.id);
+            if (newTrack.readyState === "ended") {
+                throw new Error(`refusing to use ended track with id: ${newTrack.id}, kind: ${newTrack.kind}`);
             }
-            else if (args[0] === "customEvent" && args[2].type === "roomMode") {
-                roomMode = args;
+            const pc = this.pc;
+            if (oldTrack) {
+                const sender = pc.getSenders().find((s) => { var _a; return ((_a = s.track) === null || _a === void 0 ? void 0 : _a.id) === oldTrack.id; });
+                if (sender) {
+                    return yield sender.replaceTrack(newTrack);
+                }
             }
-            else if (args[0] === "customEvent" && args[2].type === "sfuServer") {
-                sfuServer = args;
+            const sender = pc.getSenders().find((s) => {
+                const track = s.track;
+                return (track === null || track === void 0 ? void 0 : track.kind) === newTrack.kind && !trackAnnotations(track).fromGetDisplayMedia;
+            });
+            if (sender) {
+                return yield sender.replaceTrack(newTrack);
             }
-            else if (args[0] === "customEvent" && args[2].type === "featureFlags") {
-                featureFlags = args;
+            let stream = this.streams.find((s) => s.getTracks().find((t) => t.id === newTrack.id));
+            if (!stream) {
+                rtcStats.sendEvent("P2PReplaceTrackNewTrackNotInStream", {
+                    oldTrackId: oldTrack === null || oldTrack === void 0 ? void 0 : oldTrack.id,
+                    oldTrackKind: oldTrack === null || oldTrack === void 0 ? void 0 : oldTrack.kind,
+                    oldTrackIsEffect: oldTrack && trackAnnotations(oldTrack).isEffectTrack,
+                    newTrackId: newTrack.id,
+                    newTrackKind: newTrack.kind,
+                    newTrackIsEffect: trackAnnotations(newTrack).isEffectTrack,
+                });
+                this._incrementAnalyticMetric("P2PReplaceTrackNewTrackNotInStream");
             }
-            if ((ws === null || ws === void 0 ? void 0 : ws.readyState) === WebSocket.OPEN) {
-                connectionAttempt = 0;
-                ws.send(JSON.stringify(args));
+            stream = this.streams[0];
+            if (!stream) {
+                rtcStats.sendEvent("P2PReplaceTrackNoStream", {});
+                this._incrementAnalyticMetric("P2PReplaceTrackNoStream");
+                throw new Error("replaceTrack: No stream?");
             }
-            else if (args[0] === "getstats") {
-                if (getStatsBufferUsed < GETSTATS_BUFFER_SIZE) {
-                    getStatsBufferUsed++;
-                    buffer.push(args);
+            pc.addTrack(newTrack, stream);
+        });
+    }
+    changeBandwidth(bandwidth) {
+        if (bandwidth === this.bandwidth) {
+            return;
+        }
+        if (!this.canModifyPeerConnection()) {
+            this.pending.push(() => this.changeBandwidth(bandwidth));
+            return;
+        }
+        this.bandwidth = bandwidth;
+        if (!this.pc.localDescription) {
+            return;
+        }
+        setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
+    }
+    setAudioOnly(enable, excludedTrackIds = []) {
+        var _a;
+        (_a = this.pc) === null || _a === void 0 ? void 0 : _a.getTransceivers().filter((videoTransceiver) => {
+            var _a, _b, _c, _d, _e, _f;
+            return (videoTransceiver === null || videoTransceiver === void 0 ? void 0 : videoTransceiver.direction) !== "recvonly" &&
+                ((_b = (_a = videoTransceiver === null || videoTransceiver === void 0 ? void 0 : videoTransceiver.receiver) === null || _a === void 0 ? void 0 : _a.track) === null || _b === void 0 ? void 0 : _b.kind) === "video" &&
+                !excludedTrackIds.includes((_d = (_c = videoTransceiver === null || videoTransceiver === void 0 ? void 0 : videoTransceiver.receiver) === null || _c === void 0 ? void 0 : _c.track) === null || _d === void 0 ? void 0 : _d.id) &&
+                !excludedTrackIds.includes((_f = (_e = videoTransceiver === null || videoTransceiver === void 0 ? void 0 : videoTransceiver.sender) === null || _e === void 0 ? void 0 : _e.track) === null || _f === void 0 ? void 0 : _f.id);
+        }).forEach((videoTransceiver) => {
+            videoTransceiver.direction = enable ? "sendonly" : "sendrecv";
+        });
+    }
+}
+
+const MEDIA_JITTER_BUFFER_TARGET = 400;
+
+var _a$4;
+const adapter$4 = (_a$4 = adapterRaw.default) !== null && _a$4 !== void 0 ? _a$4 : adapterRaw;
+function detectMicrophoneNotWorking(pc) {
+    var _a, _b;
+    if (((_a = adapter$4.browserDetails) === null || _a === void 0 ? void 0 : _a.browser) !== "chrome" ||
+        ((_b = adapter$4.browserDetails) === null || _b === void 0 ? void 0 : _b.browser) < 58 ||
+        pc.signalingState === "closed") {
+        return Promise.resolve("");
+    }
+    const sendingAudio = pc.getSenders().some((sender) => { var _a; return ((_a = sender.track) === null || _a === void 0 ? void 0 : _a.kind) === "audio"; });
+    const receivingAudio = pc.getReceivers().some((receiver) => { var _a; return ((_a = receiver.track) === null || _a === void 0 ? void 0 : _a.kind) === "audio"; });
+    return pc.getStats(null).then((result) => {
+        let microphoneFailed = "";
+        result.forEach((report) => {
+            if (report.type === "outbound-rtp" &&
+                (report.kind === "audio" || report.mediaType === "audio") &&
+                sendingAudio) {
+                if (report.bytesSent === 0) {
+                    microphoneFailed = "outbound";
                 }
             }
-            else if (args[0] === "customEvent" && args[2].type === "insightsStats") ;
-            else {
-                buffer.push(args);
-            }
-            if ((ws === null || ws === void 0 ? void 0 : ws.readyState) === WebSocket.CLOSED && connectionShouldBeOpen) {
-                setTimeout(() => {
-                    if (ws.readyState === WebSocket.CLOSED && connectionShouldBeOpen) {
-                        connection.connect();
-                    }
-                }, 1000 * connectionAttempt);
-            }
-        },
-        close: () => {
-            connectionShouldBeOpen = false;
-            ws === null || ws === void 0 ? void 0 : ws.close();
-        },
-        connect: () => {
-            connectionShouldBeOpen = true;
-            connectionAttempt += 1;
-            ws === null || ws === void 0 ? void 0 : ws.close();
-            connection.connected = true;
-            connection.attemptedConnectedAtLeastOnce = true;
-            ws = new WebSocket(wsURL + window.location.pathname, RTCSTATS_PROTOCOL_VERSION);
-            ws.onerror = (e) => {
-                connection.connected = false;
-                logger.warn(`[RTCSTATS] WebSocket error`, e);
-            };
-            ws.onclose = (e) => {
-                connection.connected = false;
-                logger.info(`[RTCSTATS] Closed ${e.code}`);
-                resetDelta();
-            };
-            ws.onopen = () => {
-                clientInfo.connectionNumber++;
-                ws.send(JSON.stringify(["clientInfo", null, clientInfo]));
-                if (organizationId) {
-                    ws.send(JSON.stringify(organizationId));
-                }
-                if (clientId) {
-                    ws.send(JSON.stringify(clientId));
-                }
-                if (roomSessionId) {
-                    ws.send(JSON.stringify(roomSessionId));
-                }
-                if (displayName) {
-                    ws.send(JSON.stringify(displayName));
-                }
-                if (userRole) {
-                    ws.send(JSON.stringify(userRole));
-                }
-                if (deviceId) {
-                    ws.send(JSON.stringify(deviceId));
+            else if (report.type === "inbound-rtp" &&
+                (report.kind === "audio" || report.mediaType === "audio") &&
+                receivingAudio) {
+                if (report.bytesReceived === 0) {
+                    microphoneFailed = "inbound";
                 }
-                if (roomMode) {
-                    ws.send(JSON.stringify(roomMode));
-                }
-                if (roomProduct) {
-                    ws.send(JSON.stringify(roomProduct));
-                }
-                if (sfuServer) {
-                    ws.send(JSON.stringify(sfuServer));
-                }
-                if (featureFlags) {
-                    ws.send(JSON.stringify(featureFlags));
-                }
-                while (buffer.length) {
-                    ws.send(JSON.stringify(buffer.shift()));
-                }
-                getStatsBufferUsed = 0;
-            };
-        },
-    };
-    return connection;
-}
-const RTCSTATS_URL = "wss://rtcstats.srv.whereby.com";
-const server = rtcStatsConnection(RTCSTATS_URL);
-const stats = rtcstats(server.trace, 10000, [""]);
-resetDelta = (stats === null || stats === void 0 ? void 0 : stats.resetDelta) || noop;
-const rtcStats = {
-    sendEvent: (type, value) => {
-        server.trace("customEvent", null, {
-            type,
-            value,
+            }
         });
+        return microphoneFailed;
+    });
+}
+
+const PROTOCOL_REQUESTS = {
+    BLOCK_CLIENT: "block_client",
+    CANCEL_ROOM_KNOCK: "cancel_room_knock",
+    CLAIM_ROOM: "claim_room",
+    CLEAR_CHAT_HISTORY: "clear_chat_history",
+    ENABLE_AUDIO: "enable_audio",
+    ENABLE_VIDEO: "enable_video",
+    END_STREAM: "end_stream",
+    FETCH_MEDIASERVER_CONFIG: "fetch_mediaserver_config",
+    HANDLE_KNOCK: "handle_knock",
+    IDENTIFY_DEVICE: "identify_device",
+    INVITE_CLIENT_AS_MEMBER: "invite_client_as_member",
+    JOIN_ROOM: "join_room",
+    KICK_CLIENT: "kick_client",
+    KNOCK_ROOM: "knock_room",
+    LEAVE_ROOM: "leave_room",
+    SEND_CLIENT_METADATA: "send_client_metadata",
+    SET_LOCK: "set_lock",
+    SHARE_MEDIA: "share_media",
+    START_NEW_STREAM: "start_new_stream",
+    START_SCREENSHARE: "start_screenshare",
+    STOP_SCREENSHARE: "stop_screenshare",
+    START_URL_EMBED: "start_url_embed",
+    STOP_URL_EMBED: "stop_url_embed",
+    START_RECORDING: "start_recording",
+    STOP_RECORDING: "stop_recording",
+};
+const PROTOCOL_RESPONSES = {
+    AUDIO_ENABLED: "audio_enabled",
+    BACKGROUND_IMAGE_CHANGED: "background_image_changed",
+    BLOCK_ADDED: "block_added",
+    BLOCK_REMOVED: "block_removed",
+    CHAT_HISTORY_CLEARED: "chat_history_cleared",
+    CLIENT_BLOCKED: "client_blocked",
+    CLIENT_INVITED_AS_MEMBER: "client_invited_as_member",
+    CLIENT_KICKED: "client_kicked",
+    CLIENT_LEFT: "client_left",
+    CLIENT_METADATA_RECEIVED: "client_metadata_received",
+    CLIENT_READY: "client_ready",
+    CLIENT_ROLE_CHANGED: "client_role_changed",
+    CLIENT_USER_ID_CHANGED: "client_user_id_changed",
+    CONTACTS_UPDATED: "contacts_updated",
+    DEVICE_IDENTIFIED: "device_identified",
+    ROOM_ROLES_UPDATED: "room_roles_updated",
+    KNOCK_HANDLED: "knock_handled",
+    KNOCK_PAGE_BACKGROUND_CHANGED: "knock_page_background_changed",
+    KNOCKER_LEFT: "knocker_left",
+    MEDIASERVER_CONFIG: "mediaserver_config",
+    MEDIA_SHARED: "media_shared",
+    MEMBER_INVITE: "member_invite",
+    NEW_CLIENT: "new_client",
+    NEW_STREAM_STARTED: "new_stream_started",
+    SCREENSHARE_STARTED: "screenshare_started",
+    SCREENSHARE_STOPPED: "screenshare_stopped",
+    OWNER_NOTIFIED: "owner_notified",
+    OWNERS_CHANGED: "owners_changed",
+    PLAY_CLIENT_STICKER: "play_client_sticker",
+    ROOM_INTEGRATION_ENABLED: "room_integration_enabled",
+    ROOM_INTEGRATION_DISABLED: "room_integration_disabled",
+    ROOM_JOINED: "room_joined",
+    ROOM_KNOCKED: "room_knocked",
+    ROOM_LEFT: "room_left",
+    ROOM_LOCKED: "room_locked",
+    ROOM_PERMISSIONS_CHANGED: "room_permissions_changed",
+    ROOM_LOGO_CHANGED: "room_logo_changed",
+    ROOM_TYPE_CHANGED: "room_type_changed",
+    ROOM_MODE_CHANGED: "room_mode_changed",
+    SOCKET_USER_ID_CHANGED: "socket_user_id_changed",
+    STICKERS_UNLOCKED: "stickers_unlocked",
+    STREAM_ENDED: "stream_ended",
+    URL_EMBED_STARTED: "url_embed_started",
+    URL_EMBED_STOPPED: "url_embed_stopped",
+    RECORDING_STARTED: "recording_started",
+    RECORDING_STOPPED: "recording_stopped",
+    USER_NOTIFIED: "user_notified",
+    VIDEO_ENABLED: "video_enabled",
+    CLIENT_UNABLE_TO_JOIN: "client_unable_to_join",
+    LIVE_TRANSCRIPTION_STARTED: "live_transcription_started",
+    LIVE_TRANSCRIPTION_STOPPED: "live_transcription_stopped",
+    LIVE_CAPTIONS_STARTED: "live_captions_started",
+    LIVE_CAPTIONS_STOPPED: "live_captions_stopped",
+};
+const PROTOCOL_ERRORS = {
+    CANNOT_INVITE_YOURSELF: "cannot_invite_yourself",
+    CLIENT_BLOCKED: "client_blocked",
+    CLIENT_MISSING_DEVICE_ID: "client_missing_device_id",
+    FORBIDDEN: "forbidden",
+    FREE_TIER_EXHAUSTED: "free_tier_exhausted",
+    INTERNAL_SERVER_ERROR: "internal_server_error",
+    INVALID_AVATAR: "invalid_avatar",
+    INVALID_PARAMETERS: "invalid_parameters",
+    INVALID_ROOM_NAME: "invalid_room_name",
+    MAX_VIEWER_LIMIT_REACHED: "max_viewer_limit_reached",
+    MISSING_PARAMETERS: "missing_parameters",
+    MISSING_ROOM_NAME: "missing_room_name",
+    NOT_AN_OWNER: "not_an_owner",
+    NOT_IN_A_ROOM: "not_in_a_room",
+    ROOM_ALREADY_CLAIMED: "room_already_claimed",
+    ROOM_CONCURRENCY_CONTROL_ERROR: "room_concurrency_control_error",
+    ROOM_EMAIL_MISSING: "room_email_missing",
+    ROOM_EMPTY: "room_empty",
+    ROOM_FULL: "room_full",
+    ROOM_JOIN_PERMISSION_DENIED: "room_join_permission_denied",
+    ROOM_LOCKED: "room_locked",
+    ROOM_MEETING_TIME_EXHAUSTED: "room_meeting_time_exhausted",
+    ROOM_UNCLAIMED: "room_unclaimed",
+    TOO_LONG_TEXT: "too_long_text",
+    UNIQUE_ROLE_ALREADY_IN_ROOM: "unique_role_already_in_room",
+    UNSUPPORTED_VIDEO_ENCODING: "unsupported_video_encoding",
+    VIDEO_STICKER_DOES_NOT_EXIST: "video_sticker_does_not_exist",
+    VIDEO_STICKER_FORMAT_ERROR: "video_sticker_format_error",
+};
+const RELAY_MESSAGES = {
+    CHAT_MESSAGE: "chat_message",
+    CHAT_READ_STATE: "chat_read_state",
+    CHAT_STATE: "chat_state",
+    ICE_CANDIDATE: "ice_candidate",
+    ICE_END_OF_CANDIDATES: "ice_endofcandidates",
+    READY_TO_RECEIVE_OFFER: "ready_to_receive_offer",
+    REMOTE_CLIENT_MEDIA_REQUEST: "remote_client_media_request",
+    SDP_ANSWER: "sdp_answer",
+    SDP_OFFER: "sdp_offer",
+    VIDEO_STICKER: "video_sticker",
+};
+const KNOCK_MESSAGES = {
+    actions: {
+        ACCEPT: "accept",
+        HOLD: "hold",
+        REJECT: "reject",
     },
-    sendAudioMuted: (muted) => {
-        rtcStats.sendEvent("audio_muted", { muted });
-    },
-    sendVideoMuted: (muted) => {
-        rtcStats.sendEvent("video_muted", { muted });
+    resolutions: {
+        ACCEPTED: "accepted",
+        ON_HOLD: "on_hold",
+        REJECTED: "rejected",
     },
-    server,
+};
+const PROTOCOL_EVENTS = {
+    PENDING_CLIENT_LEFT: "pending_client_left",
+    MEDIA_QUALITY_CHANGED: "media_quality_changed",
 };
 
-let peerConnections = [];
-let peerConnectionCounter = 0;
-const peerConnectionData = new WeakMap();
-const removePeerConnection = (pc) => {
-    peerConnections = peerConnections.filter((old) => old !== pc);
+const EVENTS = {
+    CLIENT_CONNECTION_STATUS_CHANGED: "client_connection_status_changed",
+    STREAM_ADDED: "stream_added",
+    RTC_MANAGER_CREATED: "rtc_manager_created",
+    RTC_MANAGER_DESTROYED: "rtc_manager_destroyed",
+    LOCAL_STREAM_TRACK_ADDED: "local_stream_track_added",
+    LOCAL_STREAM_TRACK_REMOVED: "local_stream_track_removed",
+    REMOTE_STREAM_TRACK_ADDED: "remote_stream_track_added",
+    REMOTE_STREAM_TRACK_REMOVED: "remote_stream_track_removed",
+};
+const TYPES = {
+    CONNECTING: "connecting",
+    CONNECTION_FAILED: "connection_failed",
+    CONNECTION_SUCCESSFUL: "connection_successful",
+    CONNECTION_DISCONNECTED: "connection_disconnected",
 };
-if (window.RTCPeerConnection) {
-    const OriginalRTCPeerConnection = window.RTCPeerConnection;
-    function PatchedRTCPeerConnection(rtcConfig) {
-        const pc = new OriginalRTCPeerConnection(rtcConfig);
-        peerConnections.push(pc);
-        peerConnectionData.set(pc, { index: peerConnectionCounter++ });
-        const onConnectionStateChange = () => {
-            if (pc.connectionState === "closed") {
-                removePeerConnection(pc);
-                pc.removeEventListener("connectionstatechange", onConnectionStateChange);
-            }
-        };
-        pc.addEventListener("connectionstatechange", onConnectionStateChange);
-        return pc;
-    }
-    PatchedRTCPeerConnection.prototype = OriginalRTCPeerConnection.prototype;
-    window.RTCPeerConnection = PatchedRTCPeerConnection;
-}
-const getCurrentPeerConnections = () => peerConnections;
-const getPeerConnectionIndex = (pc) => { var _a; return (_a = peerConnectionData.get(pc)) === null || _a === void 0 ? void 0 : _a.index; };
-const setPeerConnectionsForTests = (pcs) => (peerConnections = pcs);
 
-const PC_DATA_BY_PC = new WeakMap();
-let numMissingTrackSsrcLookups = 0;
-let numFailedTrackSsrcLookups = 0;
-const getPeerConnectionsWithStatsReports = (pcDataByPc = PC_DATA_BY_PC) => Promise.all(getCurrentPeerConnections().map((pc) => __awaiter(void 0, void 0, void 0, function* () {
-    let pcData = pcDataByPc.get(pc);
-    if (!pcData) {
-        pcData = { ssrcToTrackId: {} };
-        pcDataByPc.set(pc, pcData);
-    }
-    try {
-        const report = yield pc.getStats();
-        let missingSsrcs = null;
-        report.forEach((stats) => {
-            if (stats.type === "inbound-rtp" || stats.type === "outbound-rtp") {
-                if (!stats.trackIdentifier && !pcData.ssrcToTrackId[stats.ssrc]) {
-                    if (stats.mediaSourceId) {
-                        const mediaSourceStats = report.get(stats.mediaSourceId);
-                        if (mediaSourceStats) {
-                            if (mediaSourceStats.trackIdentifier) {
-                                pcData.ssrcToTrackId[stats.ssrc] = mediaSourceStats.trackIdentifier;
-                            }
-                        }
-                    }
-                    if (!pcData.ssrcToTrackId[stats.ssrc] && stats.trackId) {
-                        const deprecatedTrackStats = report.get(stats.trackId);
-                        if (deprecatedTrackStats) {
-                            if (deprecatedTrackStats.trackIdentifier) {
-                                pcData.ssrcToTrackId[stats.ssrc] = deprecatedTrackStats.trackIdentifier;
-                            }
-                        }
-                    }
-                    if (!pcData.ssrcToTrackId[stats.ssrc]) {
-                        if (!missingSsrcs)
-                            missingSsrcs = [];
-                        missingSsrcs.push(stats.ssrc);
-                    }
-                }
-            }
-        });
-        if (missingSsrcs) {
-            const sendersAndReceivers = [...pc.getSenders(), ...pc.getReceivers()];
-            const reports = yield Promise.all(sendersAndReceivers.map((o) => o.getStats()));
-            reports.forEach((tReport, index) => {
-                tReport.forEach((stats) => {
-                    if (stats.type === "inbound-rtp" || stats.type === "outbound-rtp") {
-                        pcData.ssrcToTrackId[stats.ssrc] = sendersAndReceivers[index].track.id;
-                    }
-                });
-            });
-            missingSsrcs.forEach((ssrc) => {
-                numMissingTrackSsrcLookups++;
-                if (!pcData.ssrcToTrackId[ssrc]) {
-                    pcData.ssrcToTrackId[ssrc] = "?" + ssrc;
-                }
-            });
-        }
-        return [pc, report, pcData];
-    }
-    catch (e) {
-        rtcStats.sendEvent("trackSsrcLookupFailed", {
-            name: e === null || e === void 0 ? void 0 : e.name,
-            cause: e === null || e === void 0 ? void 0 : e.cause,
-            message: e === null || e === void 0 ? void 0 : e.message,
-        });
-        numFailedTrackSsrcLookups++;
-        return [pc, [], pcData];
-    }
-})));
-
-const getOrCreateSsrcMetricsContainer = (statsByView, time, pcIndex, clientId, trackId, ssrc) => {
-    let viewStats = statsByView[clientId];
-    if (!viewStats) {
-        viewStats = { candidatePairs: {}, tracks: {}, startTime: time, updated: time };
-        statsByView[clientId] = viewStats;
-    }
-    viewStats.updated = time;
-    let trackStats = viewStats.tracks[trackId];
-    if (!trackStats) {
-        trackStats = { ssrcs: {}, startTime: time, updated: time };
-        viewStats.tracks[trackId] = trackStats;
-    }
-    trackStats.updated = time;
-    let ssrcStats = trackStats.ssrcs[ssrc];
-    if (!ssrcStats) {
-        ssrcStats = {
-            startTime: time,
-            updated: time,
-            pcIndex,
-        };
-        trackStats.ssrcs[ssrc] = ssrcStats;
-    }
-    ssrcStats.updated = time;
-    return ssrcStats;
-};
-const removeNonUpdatedStats = (statsByView, time) => {
-    Object.entries(statsByView).forEach(([viewId, viewStats]) => {
-        if (viewStats.updated !== undefined && viewStats.updated < time) {
-            delete statsByView[viewId];
-        }
-        else {
-            Object.entries(viewStats.tracks).forEach(([trackId, trackStats]) => {
-                if (trackStats.updated < time) {
-                    delete viewStats.tracks[trackId];
-                }
-                else {
-                    Object.entries(trackStats.ssrcs).forEach(([ssrc, ssrcStats]) => {
-                        if (ssrcStats.updated < time) {
-                            delete trackStats.ssrcs[ssrc];
-                        }
-                    });
-                }
-            });
-        }
-    });
-};
-const DEFAULT_CLIENT = {
-    id: "unknown",
-    clientId: "unknown",
-    audio: { enabled: false, track: undefined },
-    video: { enabled: false, track: undefined },
-    isAudioOnlyModeEnabled: false,
-    isLocalClient: true,
-    isPresentation: false,
-};
-function collectStats(state_1, _a, immediate_1) {
-    return __awaiter(this, arguments, void 0, function* (state, { logger, interval }, immediate) {
-        const collectStatsBound = collectStats.bind(null, state, { interval, logger });
-        try {
-            const clients = state.getClients();
-            const defaultClient = clients.find((c) => c.isLocalClient && !c.isPresentation) || DEFAULT_CLIENT;
-            let defaultViewStats = state.statsByView[defaultClient.id];
-            if (!defaultViewStats) {
-                defaultViewStats = { tracks: {}, candidatePairs: {}, pressure: null };
-                state.statsByView[defaultClient.id] = defaultViewStats;
-            }
-            defaultViewStats.pressure = state.lastPressureObserverRecord;
-            const timeSinceLastUpdate = Date.now() - state.lastUpdateTime;
-            if (timeSinceLastUpdate < 400) {
-                if (immediate)
-                    return state.statsByView;
-                state.subscriptions.forEach((subscription) => { var _a; return (_a = subscription.onUpdatedStats) === null || _a === void 0 ? void 0 : _a.call(subscription, state.statsByView, clients); });
-                state.nextTimeout = setTimeout(collectStatsBound, interval);
-                return;
-            }
-            state.lastUpdateTime = Date.now();
-            (yield getPeerConnectionsWithStatsReports()).forEach(([pc, report, pcData]) => {
-                const pcIndex = getPeerConnectionIndex(pc);
-                if (pcIndex === undefined) {
-                    logger.warn("Could not find index for PeerConnection");
-                }
-                if (pc.connectionState === "closed") {
-                    report = new Map();
-                    removePeerConnection(pc);
-                }
-                pcData.previousSSRCs = pcData.currentSSRCs || {};
-                pcData.currentSSRCs = {};
-                report.forEach((currentRtcStats) => {
-                    var _a, _b;
-                    if (currentRtcStats.type === "candidate-pair" && /inprogress|succeeded/.test(currentRtcStats.state)) {
-                        const prevRtcStats = (_a = pcData._oldReport) === null || _a === void 0 ? void 0 : _a.get(currentRtcStats.id);
-                        const timeDiff = prevRtcStats ? currentRtcStats.timestamp - prevRtcStats.timestamp : interval;
-                        const cpId = pcIndex + ":" + currentRtcStats.id;
-                        let cpMetrics = defaultViewStats.candidatePairs[cpId];
-                        if (!cpMetrics) {
-                            cpMetrics = { startTime: state.lastUpdateTime, id: cpId };
-                            defaultViewStats.candidatePairs[cpId] = cpMetrics;
-                        }
-                        captureCandidatePairInfoMetrics(cpMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
-                        cpMetrics.lastRtcStatsTime = state.lastUpdateTime;
-                    }
-                    if (currentRtcStats.type === "inbound-rtp" || currentRtcStats.type === "outbound-rtp") {
-                        const kind = (currentRtcStats.mediaType || currentRtcStats.kind);
-                        const ssrc = currentRtcStats.ssrc;
-                        let trackId = currentRtcStats.trackIdentifier || pcData.ssrcToTrackId[ssrc];
-                        let prevRtcStats = (_b = pcData._oldReport) === null || _b === void 0 ? void 0 : _b.get(currentRtcStats.id);
-                        if (prevRtcStats && prevRtcStats.mediaSourceId !== currentRtcStats.mediaSourceId) {
-                            const mediaSourceStats = report.get(currentRtcStats.mediaSourceId);
-                            if (mediaSourceStats && mediaSourceStats.trackIdentifier) {
-                                trackId = mediaSourceStats.trackIdentifier;
-                                pcData.ssrcToTrackId[ssrc] = trackId;
-                            }
-                        }
-                        const client = clients.find((c) => { var _a; return ((_a = c[kind].track) === null || _a === void 0 ? void 0 : _a.id) === trackId; }) || defaultClient;
-                        const clientTrack = client[kind].track;
-                        if (!currentRtcStats.trackIdentifier &&
-                            pcData.ssrcToTrackId[ssrc] &&
-                            (clientTrack === null || clientTrack === void 0 ? void 0 : clientTrack.id) &&
-                            clientTrack.id !== pcData.ssrcToTrackId[ssrc]) {
-                            trackId = clientTrack.id;
-                            pcData.ssrcToTrackId[ssrc] = clientTrack.id;
-                        }
-                        pcData.currentSSRCs[ssrc] = client.id;
-                        if (prevRtcStats) {
-                            const newTransport = report.get(currentRtcStats.transportId);
-                            const oldTransport = pcData._oldReport.get(prevRtcStats.transportId);
-                            if (oldTransport &&
-                                (newTransport === null || newTransport === void 0 ? void 0 : newTransport.selectedCandidatePairId) !== oldTransport.selectedCandidatePairId) {
-                                prevRtcStats = null;
-                            }
-                            else if (currentRtcStats.bytesReceived < prevRtcStats.bytesReceived ||
-                                currentRtcStats.bytesSent < prevRtcStats.bytesSent) {
-                                prevRtcStats = null;
-                            }
-                        }
-                        const timeDiff = prevRtcStats ? currentRtcStats.timestamp - prevRtcStats.timestamp : interval;
-                        const ssrcMetrics = getOrCreateSsrcMetricsContainer(state.statsByView, state.lastUpdateTime, pcIndex, client.id, trackId, ssrc);
-                        captureSsrcInfo(ssrcMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
-                        captureCommonSsrcMetrics(ssrcMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
-                        if (kind === "video") {
-                            captureVideoSsrcMetrics(ssrcMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
-                        }
-                        if (kind === "audio") {
-                            captureAudioSsrcMetrics(ssrcMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
-                        }
-                    }
-                });
-                pcData._oldReport = report;
-                Object.keys(pcData.previousSSRCs)
-                    .filter((ssrc) => !pcData.currentSSRCs[ssrc])
-                    .forEach((ssrc) => {
-                    const clientId = pcData.previousSSRCs[ssrc];
-                    if (clientId) {
-                        const clientView = state.statsByView[clientId];
-                        if (clientView) {
-                            Object.values(clientView.tracks).forEach((trackStats) => {
-                                if (trackStats.ssrcs[ssrc]) {
-                                    delete trackStats.ssrcs[ssrc];
-                                }
-                            });
-                        }
-                    }
-                });
-            });
-            removeNonUpdatedStats(state.statsByView, state.lastUpdateTime);
-            Object.entries((defaultViewStats === null || defaultViewStats === void 0 ? void 0 : defaultViewStats.candidatePairs) || {}).forEach(([cpKey, cp]) => {
-                const active = cp.lastRtcStatsTime === state.lastUpdateTime;
-                cp.active = active;
-                if (!active) {
-                    cp.state = "old/inactive";
-                    if (!cp.inactiveFromTime)
-                        cp.inactiveFromTime = state.lastUpdateTime;
-                    else {
-                        if (state.lastUpdateTime - cp.inactiveFromTime > 4000) {
-                            delete defaultViewStats.candidatePairs[cpKey];
-                        }
-                    }
-                }
-            });
-            if (immediate) {
-                return state.statsByView;
-            }
-            else {
-                state.subscriptions.forEach((subscription) => { var _a; return (_a = subscription.onUpdatedStats) === null || _a === void 0 ? void 0 : _a.call(subscription, state.statsByView, clients); });
-            }
-        }
-        catch (e) {
-            logger.warn(e);
-            state.numFailedStatsReports++;
-            rtcStats.sendEvent("collectStatsFailed", {
-                name: e === null || e === void 0 ? void 0 : e.name,
-                cause: e === null || e === void 0 ? void 0 : e.cause,
-                message: e === null || e === void 0 ? void 0 : e.message,
-            });
-        }
-        state.nextTimeout = setTimeout(collectStatsBound, interval);
-    });
-}
-
-const REGISTERED_TRIALS = {};
-function registerOriginTrials(trials, registeredTrials = REGISTERED_TRIALS, document = window.document) {
-    trials.forEach(({ hostnamePattern, token }) => {
-        const key = `${hostnamePattern}-${token}`;
-        if (registeredTrials[key]) {
-            return;
-        }
-        if (hostnamePattern.test(document.location.hostname)) {
-            const otMeta = document.createElement("meta");
-            otMeta.httpEquiv = "origin-trial";
-            otMeta.content = token;
-            document.head.append(otMeta);
-            registeredTrials[key] = true;
-        }
-    });
-}
-
-const CPU_OBSERVER_OPTIONS = {
-    sampleRate: 1,
-    originTrials: [
-        {
-            hostnamePattern: /hereby\.dev/,
-            token: "AkSNPHJw6EK08X0QU7kORnK9NABzRLAC7dqfXOwk5JwFAQG4Ey7WxLXxsnhieCgC1QHUdevE2EFICy7uBGDANwUAAABqeyJvcmlnaW4iOiJodHRwczovL2hlcmVieS5kZXY6NDQ0MyIsImZlYXR1cmUiOiJDb21wdXRlUHJlc3N1cmVfdjIiLCJleHBpcnkiOjE3MTY5NDA3OTksImlzU3ViZG9tYWluIjp0cnVlfQ==",
-        },
-        {
-            hostnamePattern: /whereby\.com/,
-            token: "Asc2wu8KpSx648i932NICteQDFcB05yl2QUUSHD7AQo8JGP2Fp6FF91TvYVJBsKGzLMH349rysPw5q9tqPC/PAUAAABqeyJvcmlnaW4iOiJodHRwczovL3doZXJlYnkuY29tOjQ0MyIsImZlYXR1cmUiOiJDb21wdXRlUHJlc3N1cmVfdjIiLCJleHBpcnkiOjE3MTY5NDA3OTksImlzU3ViZG9tYWluIjp0cnVlfQ==",
-        },
-    ],
-};
-function startCpuObserver(cb, { sampleRate, originTrials } = CPU_OBSERVER_OPTIONS, window = globalThis.window) {
-    registerOriginTrials(originTrials);
-    let pressureObserver;
-    if ("PressureObserver" in window) {
-        pressureObserver = new window.PressureObserver(cb, { sampleRate });
-        pressureObserver.observe("cpu", { sampleInterval: sampleRate * 1000 });
-        return {
-            stop: () => {
-                pressureObserver.unobserve("cpu");
-            },
-        };
-    }
-}
-
-const STATE = {
-    currentMonitor: null,
-    getClients: () => [],
-    lastUpdateTime: 0,
-    statsByView: {},
-    subscriptions: [],
-    numFailedStatsReports: 0,
-};
-const OPTIONS = {
-    interval: 2000,
-    logger: new Logger(),
-};
-const getStats = () => {
-    return Object.assign({}, STATE.statsByView);
-};
-const getNumFailedStatsReports = () => {
-    return STATE.numFailedStatsReports;
-};
-const getNumMissingTrackSsrcLookups = () => numMissingTrackSsrcLookups;
-const getNumFailedTrackSsrcLookups = () => numFailedTrackSsrcLookups;
-const getUpdatedStats = () => { var _a; return (_a = STATE.currentMonitor) === null || _a === void 0 ? void 0 : _a.getUpdatedStats(); };
-const setClientProvider = (provider) => (STATE.getClients = provider);
-function startStatsMonitor(state, { interval, logger }) {
-    const collectStatsBound = collectStats.bind(null, state, { interval, logger });
-    let cpuObserver;
-    try {
-        cpuObserver = startCpuObserver((records) => (state.lastPressureObserverRecord = records.pop()));
-    }
-    catch (ex) {
-        logger.warn("Failed to observe CPU pressure", ex);
-    }
-    setTimeout(collectStatsBound, interval);
-    return {
-        getUpdatedStats: () => {
-            return collectStatsBound(true);
-        },
-        stop: () => {
-            clearTimeout(state.nextTimeout);
-            cpuObserver === null || cpuObserver === void 0 ? void 0 : cpuObserver.stop();
-        },
-    };
-}
-function subscribeStats(subscription, options = OPTIONS, state = STATE) {
-    state.subscriptions.push(subscription);
-    if (!state.currentMonitor)
-        state.currentMonitor = startStatsMonitor(state, options);
-    return {
-        stop() {
-            var _a;
-            state.subscriptions = state.subscriptions.filter((s) => s !== subscription);
-            if (!state.subscriptions.length) {
-                (_a = state.currentMonitor) === null || _a === void 0 ? void 0 : _a.stop();
-                state.currentMonitor = null;
-            }
-        },
-    };
-}
-
-const PROTOCOL_REQUESTS = {
-    BLOCK_CLIENT: "block_client",
-    CANCEL_ROOM_KNOCK: "cancel_room_knock",
-    CLAIM_ROOM: "claim_room",
-    CLEAR_CHAT_HISTORY: "clear_chat_history",
-    ENABLE_AUDIO: "enable_audio",
-    ENABLE_VIDEO: "enable_video",
-    END_STREAM: "end_stream",
-    FETCH_MEDIASERVER_CONFIG: "fetch_mediaserver_config",
-    HANDLE_KNOCK: "handle_knock",
-    IDENTIFY_DEVICE: "identify_device",
-    INVITE_CLIENT_AS_MEMBER: "invite_client_as_member",
-    JOIN_ROOM: "join_room",
-    KICK_CLIENT: "kick_client",
-    KNOCK_ROOM: "knock_room",
-    LEAVE_ROOM: "leave_room",
-    SEND_CLIENT_METADATA: "send_client_metadata",
-    SET_LOCK: "set_lock",
-    SHARE_MEDIA: "share_media",
-    START_NEW_STREAM: "start_new_stream",
-    START_SCREENSHARE: "start_screenshare",
-    STOP_SCREENSHARE: "stop_screenshare",
-    START_URL_EMBED: "start_url_embed",
-    STOP_URL_EMBED: "stop_url_embed",
-    START_RECORDING: "start_recording",
-    STOP_RECORDING: "stop_recording",
-};
-const PROTOCOL_RESPONSES = {
-    AUDIO_ENABLED: "audio_enabled",
-    BACKGROUND_IMAGE_CHANGED: "background_image_changed",
-    BLOCK_ADDED: "block_added",
-    BLOCK_REMOVED: "block_removed",
-    CHAT_HISTORY_CLEARED: "chat_history_cleared",
-    CLIENT_BLOCKED: "client_blocked",
-    CLIENT_INVITED_AS_MEMBER: "client_invited_as_member",
-    CLIENT_KICKED: "client_kicked",
-    CLIENT_LEFT: "client_left",
-    CLIENT_METADATA_RECEIVED: "client_metadata_received",
-    CLIENT_READY: "client_ready",
-    CLIENT_ROLE_CHANGED: "client_role_changed",
-    CLIENT_USER_ID_CHANGED: "client_user_id_changed",
-    CONTACTS_UPDATED: "contacts_updated",
-    DEVICE_IDENTIFIED: "device_identified",
-    ROOM_ROLES_UPDATED: "room_roles_updated",
-    KNOCK_HANDLED: "knock_handled",
-    KNOCK_PAGE_BACKGROUND_CHANGED: "knock_page_background_changed",
-    KNOCKER_LEFT: "knocker_left",
-    MEDIASERVER_CONFIG: "mediaserver_config",
-    MEDIA_SHARED: "media_shared",
-    MEMBER_INVITE: "member_invite",
-    NEW_CLIENT: "new_client",
-    NEW_STREAM_STARTED: "new_stream_started",
-    SCREENSHARE_STARTED: "screenshare_started",
-    SCREENSHARE_STOPPED: "screenshare_stopped",
-    OWNER_NOTIFIED: "owner_notified",
-    OWNERS_CHANGED: "owners_changed",
-    PLAY_CLIENT_STICKER: "play_client_sticker",
-    ROOM_INTEGRATION_ENABLED: "room_integration_enabled",
-    ROOM_INTEGRATION_DISABLED: "room_integration_disabled",
-    ROOM_JOINED: "room_joined",
-    ROOM_KNOCKED: "room_knocked",
-    ROOM_LEFT: "room_left",
-    ROOM_LOCKED: "room_locked",
-    ROOM_PERMISSIONS_CHANGED: "room_permissions_changed",
-    ROOM_LOGO_CHANGED: "room_logo_changed",
-    ROOM_TYPE_CHANGED: "room_type_changed",
-    ROOM_MODE_CHANGED: "room_mode_changed",
-    SOCKET_USER_ID_CHANGED: "socket_user_id_changed",
-    STICKERS_UNLOCKED: "stickers_unlocked",
-    STREAM_ENDED: "stream_ended",
-    URL_EMBED_STARTED: "url_embed_started",
-    URL_EMBED_STOPPED: "url_embed_stopped",
-    RECORDING_STARTED: "recording_started",
-    RECORDING_STOPPED: "recording_stopped",
-    USER_NOTIFIED: "user_notified",
-    VIDEO_ENABLED: "video_enabled",
-    CLIENT_UNABLE_TO_JOIN: "client_unable_to_join",
-    LIVE_TRANSCRIPTION_STARTED: "live_transcription_started",
-    LIVE_TRANSCRIPTION_STOPPED: "live_transcription_stopped",
-    LIVE_CAPTIONS_STARTED: "live_captions_started",
-    LIVE_CAPTIONS_STOPPED: "live_captions_stopped",
-};
-const PROTOCOL_ERRORS = {
-    CANNOT_INVITE_YOURSELF: "cannot_invite_yourself",
-    CLIENT_BLOCKED: "client_blocked",
-    CLIENT_MISSING_DEVICE_ID: "client_missing_device_id",
-    FORBIDDEN: "forbidden",
-    FREE_TIER_EXHAUSTED: "free_tier_exhausted",
-    INTERNAL_SERVER_ERROR: "internal_server_error",
-    INVALID_AVATAR: "invalid_avatar",
-    INVALID_PARAMETERS: "invalid_parameters",
-    INVALID_ROOM_NAME: "invalid_room_name",
-    MAX_VIEWER_LIMIT_REACHED: "max_viewer_limit_reached",
-    MISSING_PARAMETERS: "missing_parameters",
-    MISSING_ROOM_NAME: "missing_room_name",
-    NOT_AN_OWNER: "not_an_owner",
-    NOT_IN_A_ROOM: "not_in_a_room",
-    ROOM_ALREADY_CLAIMED: "room_already_claimed",
-    ROOM_CONCURRENCY_CONTROL_ERROR: "room_concurrency_control_error",
-    ROOM_EMAIL_MISSING: "room_email_missing",
-    ROOM_EMPTY: "room_empty",
-    ROOM_FULL: "room_full",
-    ROOM_JOIN_PERMISSION_DENIED: "room_join_permission_denied",
-    ROOM_LOCKED: "room_locked",
-    ROOM_MEETING_TIME_EXHAUSTED: "room_meeting_time_exhausted",
-    ROOM_UNCLAIMED: "room_unclaimed",
-    TOO_LONG_TEXT: "too_long_text",
-    UNIQUE_ROLE_ALREADY_IN_ROOM: "unique_role_already_in_room",
-    UNSUPPORTED_VIDEO_ENCODING: "unsupported_video_encoding",
-    VIDEO_STICKER_DOES_NOT_EXIST: "video_sticker_does_not_exist",
-    VIDEO_STICKER_FORMAT_ERROR: "video_sticker_format_error",
-};
-const RELAY_MESSAGES = {
-    CHAT_MESSAGE: "chat_message",
-    CHAT_READ_STATE: "chat_read_state",
-    CHAT_STATE: "chat_state",
-    ICE_CANDIDATE: "ice_candidate",
-    ICE_END_OF_CANDIDATES: "ice_endofcandidates",
-    READY_TO_RECEIVE_OFFER: "ready_to_receive_offer",
-    REMOTE_CLIENT_MEDIA_REQUEST: "remote_client_media_request",
-    SDP_ANSWER: "sdp_answer",
-    SDP_OFFER: "sdp_offer",
-    VIDEO_STICKER: "video_sticker",
-};
-const KNOCK_MESSAGES = {
-    actions: {
-        ACCEPT: "accept",
-        HOLD: "hold",
-        REJECT: "reject",
-    },
-    resolutions: {
-        ACCEPTED: "accepted",
-        ON_HOLD: "on_hold",
-        REJECTED: "rejected",
-    },
-};
-const PROTOCOL_EVENTS = {
-    PENDING_CLIENT_LEFT: "pending_client_left",
-    MEDIA_QUALITY_CHANGED: "media_quality_changed",
+const word = "[a-fA-F\\d:]";
+const boundry = (options) => options && options.includeBoundaries ? `(?:(?<=\\s|^)(?=${word})|(?<=${word})(?=\\s|$))` : "";
+const v4 = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}";
+const v6segment = "[a-fA-F\\d]{1,4}";
+const v6 = `
+(?:
+(?:${v6segment}:){7}(?:${v6segment}|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8
+(?:${v6segment}:){6}(?:${v4}|:${v6segment}|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4
+(?:${v6segment}:){5}(?::${v4}|(?::${v6segment}){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4
+(?:${v6segment}:){4}(?:(?::${v6segment}){0,1}:${v4}|(?::${v6segment}){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4
+(?:${v6segment}:){3}(?:(?::${v6segment}){0,2}:${v4}|(?::${v6segment}){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4
+(?:${v6segment}:){2}(?:(?::${v6segment}){0,3}:${v4}|(?::${v6segment}){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4
+(?:${v6segment}:){1}(?:(?::${v6segment}){0,4}:${v4}|(?::${v6segment}){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4
+(?::(?:(?::${v6segment}){0,5}:${v4}|(?::${v6segment}){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4
+)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1
+`
+    .replace(/\s*\/\/.*$/gm, "")
+    .replace(/\n/g, "")
+    .trim();
+const v46Exact = new RegExp(`(?:^${v4}$)|(?:^${v6}$)`);
+const v4exact = new RegExp(`^${v4}$`);
+const v6exact = new RegExp(`^${v6}$`);
+const ipRegex = (options) => options && options.exact
+    ? v46Exact
+    : new RegExp(`(?:${boundry(options)}${v4}${boundry(options)})|(?:${boundry(options)}${v6}${boundry(options)})`, "g");
+ipRegex.v4 = (options) => options && options.exact ? v4exact : new RegExp(`${boundry(options)}${v4}${boundry(options)}`, "g");
+ipRegex.v6 = (options) => options && options.exact ? v6exact : new RegExp(`${boundry(options)}${v6}${boundry(options)}`, "g");
+
+var rtcManagerEvents = {
+    CAMERA_NOT_WORKING: "camera_not_working",
+    CONNECTION_BLOCKED_BY_NETWORK: "connection_blocked_by_network",
+    MICROPHONE_NOT_WORKING: "microphone_not_working",
+    MICROPHONE_STOPPED_WORKING: "microphone_stopped_working",
+    CAMERA_STOPPED_WORKING: "camera_stopped_working",
+    NEW_PC: "new_pc",
+    SFU_CONNECTION_OPEN: "sfu_connection_open",
+    SFU_CONNECTION_CLOSED: "sfu_connection_closed",
+    SFU_CONNECTION_INFO: "sfu_connection_info",
+    COLOCATION_SPEAKER: "colocation_speaker",
+    DOMINANT_SPEAKER: "dominant_speaker",
 };
 
-const logger$a = new Logger();
-class ReconnectManager extends EventEmitter {
-    constructor(socket) {
-        super();
-        this.reconnectThresholdInMs = 0;
-        this._socket = socket;
-        this._clients = {};
-        this._signalDisconnectTime = undefined;
-        this.rtcManager = undefined;
-        this.metrics = {
-            roomJoinedLate: 0,
-            pendingClientCanceled: 0,
-            evaluationFailed: 0,
-            roomJoined: 0,
-        };
-        socket.on("disconnect", () => {
-            this._signalDisconnectTime = Date.now();
-        });
-        socket.on(PROTOCOL_RESPONSES.ROOM_JOINED, (payload) => this._onRoomJoined(payload));
-        socket.on(PROTOCOL_RESPONSES.NEW_CLIENT, (payload) => this._onNewClient(payload));
-        socket.on(PROTOCOL_RESPONSES.CLIENT_LEFT, (payload) => this._onClientLeft(payload));
-        socket.on(PROTOCOL_EVENTS.PENDING_CLIENT_LEFT, (payload) => this._onPendingClientLeft(payload));
-        socket.on(PROTOCOL_RESPONSES.AUDIO_ENABLED, (payload) => this._onAudioEnabled(payload));
-        socket.on(PROTOCOL_RESPONSES.VIDEO_ENABLED, (payload) => this._onVideoEnabled(payload));
-        socket.on(PROTOCOL_RESPONSES.SCREENSHARE_STARTED, (payload) => this._onScreenshareChanged(payload, true));
-        socket.on(PROTOCOL_RESPONSES.SCREENSHARE_STOPPED, (payload) => this._onScreenshareChanged(payload, false));
-    }
-    _onRoomJoined(payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            this.reconnectThresholdInMs = (payload.disconnectTimeout || 0) * 0.8;
-            if (payload === null || payload === void 0 ? void 0 : payload.error) {
-                this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
-                return;
-            }
-            if (!payload.selfId) {
-                this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
-                return;
-            }
-            const myDeviceId = (_a = payload.room.clients.find((c) => payload.selfId === c.id)) === null || _a === void 0 ? void 0 : _a.deviceId;
-            if (!myDeviceId) {
-                this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
-                return;
-            }
-            if (!this._signalDisconnectTime) {
-                this._resetClientState(payload);
-                payload.room.clients = payload.room.clients.filter((c) => !(c.deviceId === myDeviceId && c.isPendingToLeave));
-                this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
-                return;
-            }
-            const RECONNECT_THRESHOLD = payload.disconnectTimeout * 0.8;
-            const timeSinceDisconnect = Date.now() - this._signalDisconnectTime;
-            if (timeSinceDisconnect > RECONNECT_THRESHOLD) {
-                this._resetClientState(payload);
-                this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
-                this.metrics.roomJoinedLate++;
-                return;
-            }
-            payload.room.clients = payload.room.clients.filter((c) => !(c.deviceId === myDeviceId && c.isPendingToLeave));
-            const allStats = yield getUpdatedStats();
-            payload.room.clients.forEach((client) => {
-                var _a;
-                try {
-                    if (client.id === payload.selfId)
-                        return;
-                    if (!this._clients[client.id]) {
-                        this._addClientToState(client);
-                        return;
-                    }
-                    if (!((_a = this.rtcManager) === null || _a === void 0 ? void 0 : _a.hasClient(client.id))) {
-                        return;
-                    }
-                    if (this._hasClientStateChanged({
-                        clientId: client.id,
-                        webcam: client.isVideoEnabled,
-                        mic: client.isAudioEnabled,
-                        screenShare: client.streams.length > 1,
-                    })) {
-                        return;
-                    }
-                    if (this._wasClientSendingMedia(client.id)) {
-                        if (!this._isClientMediaActive(allStats, client.id)) {
-                            return;
-                        }
-                    }
-                    client.mergeWithOldClientState = true;
-                }
-                catch (error) {
-                    logger$a.error("Failed to evaluate if we should merge client state %o", error);
-                    this.metrics.evaluationFailed++;
-                }
-            });
-            payload.room.clients.forEach((c) => {
-                if (c.isPendingToLeave) {
-                    this._onPendingClientLeft({ clientId: c.id });
-                }
-            });
-            this.metrics.roomJoined++;
-            this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
-        });
-    }
-    _onClientLeft(payload) {
-        var _a;
-        const { clientId } = payload;
-        const client = this._clients[clientId];
-        if (client) {
-            clearTimeout(client.timeout);
-            delete this._clients[clientId];
-        }
-        (_a = this.rtcManager) === null || _a === void 0 ? void 0 : _a.disconnect(clientId, payload.eventClaim);
-        this.emit(PROTOCOL_RESPONSES.CLIENT_LEFT, payload);
-    }
-    _onPendingClientLeft(payload) {
-        const { clientId } = payload;
-        const client = this._clients[clientId];
-        if (!client) {
-            logger$a.warn(`client ${clientId} not found`);
-            return;
-        }
-        if (client.isPendingToLeave) {
-            return;
-        }
-        client.isPendingToLeave = true;
-        if (this._wasClientSendingMedia(clientId)) {
-            client.checkActiveMediaAttempts = 0;
-            this._abortIfNotActive(payload);
-        }
-    }
-    _onNewClient(payload) {
-        const { client: { id: clientId, deviceId }, } = payload;
-        const client = this._clients[clientId];
-        if (client && client.isPendingToLeave) {
-            clearTimeout(client.timeoutHandler);
-            client.isPendingToLeave = false;
-            this.metrics.pendingClientCanceled++;
-            return;
-        }
-        this._getPendingClientsByDeviceId(deviceId).forEach((client) => {
-            clearTimeout(client.timeoutHandler);
-            client.isPendingToLeave = undefined;
-            this.emit(PROTOCOL_RESPONSES.CLIENT_LEFT, { clientId: client.clientId });
-        });
-        this._addClientToState(payload.client);
-        this.emit(PROTOCOL_RESPONSES.NEW_CLIENT, payload);
-    }
-    _abortIfNotActive(payload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { clientId } = payload;
-            let client = this._clients[clientId];
-            if (!(client === null || client === void 0 ? void 0 : client.isPendingToLeave))
-                return;
-            client.checkActiveMediaAttempts++;
-            if (client.checkActiveMediaAttempts > 3) {
-                return;
-            }
-            const stillActive = yield this._checkIsActive(clientId);
-            if (stillActive) {
-                client.timeoutHandler = setTimeout(() => this._abortIfNotActive(payload), 500);
-                return;
-            }
-            client = this._clients[clientId];
-            if (client === null || client === void 0 ? void 0 : client.isPendingToLeave) {
-                clearTimeout(client.timeoutHandler);
-                delete this._clients[clientId];
-                this.emit(PROTOCOL_RESPONSES.CLIENT_LEFT, payload);
-            }
-        });
-    }
-    _checkIsActive(clientId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const allStats = yield getUpdatedStats();
-            return this._isClientMediaActive(allStats, clientId);
-        });
-    }
-    _isClientMediaActive(stats, clientId) {
-        const clientStats = stats === null || stats === void 0 ? void 0 : stats[clientId];
-        let isActive = false;
-        if (clientStats) {
-            Object.entries(clientStats.tracks).forEach(([trackId, trackStats]) => {
-                if (trackId !== "probator")
-                    Object.values(trackStats.ssrcs).forEach((ssrcStats) => {
-                        if ((ssrcStats.bitrate || 0) > 0)
-                            isActive = true;
-                    });
-            });
+class AssertionError extends Error {
+    constructor(options) {
+        super(options.message);
+        this.name = "AssertionError";
+        this.code = "ERR_ASSERTION";
+        this.actual = options.actual;
+        this.expected = options.expected;
+        this.operator = options.operator;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, options.stackStartFn);
         }
-        return isActive;
-    }
-    _onAudioEnabled(payload) {
-        const { clientId, isAudioEnabled } = payload;
-        this._clients[clientId] = Object.assign(Object.assign({}, (this._clients[clientId] || {})), { isAudioEnabled });
-    }
-    _onVideoEnabled(payload) {
-        const { clientId, isVideoEnabled } = payload;
-        this._clients[clientId] = Object.assign(Object.assign({}, (this._clients[clientId] || {})), { isVideoEnabled });
-    }
-    _onScreenshareChanged(payload, action) {
-        const { clientId } = payload;
-        this._clients[clientId] = Object.assign(Object.assign({}, (this._clients[clientId] || {})), { isScreenshareEnabled: action });
     }
-    _hasClientStateChanged({ clientId, webcam, mic, screenShare, }) {
-        const state = this._clients[clientId];
-        if (!state) {
-            throw new Error(`Client ${clientId} not found in ReconnectManager state`);
-        }
-        if (webcam !== state.isVideoEnabled) {
-            return true;
-        }
-        if (mic !== state.isAudioEnabled) {
-            return true;
-        }
-        if (screenShare !== state.isScreenshareEnabled) {
-            return true;
+}
+function innerOk(fn, argLen, value, message) {
+    if (!value) {
+        let generatedMessage = false;
+        if (argLen === 0) {
+            generatedMessage = true;
+            message = "No value argument passed to `assert.ok()`";
         }
-        return false;
-    }
-    _addClientToState(newClient) {
-        this._clients[newClient.id] = Object.assign(Object.assign({}, (this._clients[newClient.id] || {})), { isAudioEnabled: newClient.isAudioEnabled, isVideoEnabled: newClient.isVideoEnabled, isScreenshareEnabled: newClient.streams.length > 1, deviceId: newClient.deviceId, isPendingToLeave: newClient.isPendingToLeave, clientId: newClient.id });
-    }
-    _wasClientSendingMedia(clientId) {
-        const client = this._clients[clientId];
-        if (!client) {
-            throw new Error(`Client ${clientId} not found in ReconnectManager state`);
+        else if (message instanceof Error) {
+            throw message;
         }
-        return client.isAudioEnabled || client.isVideoEnabled || client.isScreenshareEnabled;
+        const err = new AssertionError({
+            actual: value,
+            expected: true,
+            message,
+            operator: "==",
+            stackStartFn: fn,
+        });
+        err.generatedMessage = generatedMessage;
+        throw err;
     }
-    _getPendingClientsByDeviceId(deviceId) {
-        return Object.values(this._clients).filter((clientState) => {
-            return clientState.deviceId === deviceId && clientState.isPendingToLeave;
+}
+function innerFail(obj) {
+    if (obj.message instanceof Error)
+        throw obj.message;
+    throw new AssertionError(obj);
+}
+function ok(...args) {
+    innerOk(ok, args.length, ...args);
+}
+const assert = {
+    fail: (message) => {
+        innerFail({
+            actual: "fail()",
+            expected: "fail() should not be called",
+            message,
+            operator: "fail",
+            stackStartFn: assert.fail,
         });
+    },
+    ok,
+};
+assert.notEqual = function notEqual(actual, expected, message) {
+    if (arguments.length < 2) {
+        throw new Error("'actual' and 'expected' arguments are required");
     }
-    _resetClientState(payload) {
-        this._clients = {};
-        payload.room.clients.forEach((client) => {
-            if (client.id === payload.selfId) {
-                return;
-            }
-            else {
-                this._addClientToState(client);
-            }
+    if (actual == expected) {
+        innerFail({
+            actual,
+            expected,
+            message,
+            operator: "!=",
+            stackStartFn: notEqual,
         });
     }
-}
+};
+assert.ok = ok;
 
-const DISCONNECT_DURATION_LIMIT_MS$1 = 60000;
-const SIGNAL_PING_INTERVAL = 2000;
-const SIGNAL_PING_MAX_LATENCY = 1000;
-class KeepAliveManager {
-    constructor(serverSocket) {
-        this.lastPingTimestamp = Date.now();
-        this._disconnectDurationLimitEnabled = false;
-        this.disconnectDurationLimitExceeded = false;
-        this.serverSocket = serverSocket;
-        this.serverSocket.on("connect", () => this.onConnect());
-        this.serverSocket.onEngineEvent("ping", () => this.onPing());
-        this.serverSocket.on("disconnect", () => this.onDisconnect());
-        this.serverSocket.onEngineEvent("reconnect_attempt", () => this.onReconnectAttempt());
-    }
-    enableDisconnectDurationLimit() {
-        this._disconnectDurationLimitEnabled = true;
-    }
-    pingHeartbeat() {
-        clearTimeout(this.pingTimer);
-        this.pingTimer = setTimeout(() => {
-            this.serverSocket._socket.io.engine.close();
-        }, SIGNAL_PING_INTERVAL + SIGNAL_PING_MAX_LATENCY);
-        this.lastPingTimestamp = Date.now();
-    }
-    onConnect() {
-        this.pingHeartbeat();
+const createWorker = (fn) => {
+    return new Worker(URL.createObjectURL(new Blob(["self.onmessage = ", fn.toString()], { type: "text/javascript" })));
+};
+const generateByteString = (count) => {
+    if (count === 0) {
+        return "";
     }
-    onPing() {
-        this.pingHeartbeat();
+    const count2 = count / 2;
+    let result = "F";
+    while (result.length <= count2) {
+        result += result;
     }
-    onDisconnect() {
-        clearTimeout(this.pingTimer);
+    return result + result.substring(0, count - result.length);
+};
+
+const getMediasoupDeviceAsync = (features) => __awaiter(void 0, void 0, void 0, function* () {
+    if (features.isNodeSdk) {
+        return new Device({ handlerName: "Safari12" });
     }
-    onReconnectAttempt() {
-        if (this._disconnectDurationLimitEnabled) {
-            this.disconnectDurationLimitExceeded = Boolean(Date.now() - this.lastPingTimestamp > DISCONNECT_DURATION_LIMIT_MS$1);
-            if (this.disconnectDurationLimitExceeded) {
-                this.serverSocket.disconnect();
-            }
-        }
+    let handlerName = (yield detectDeviceAsync()) ||
+        (/applecoremedia|applewebkit|safari/i.test(navigator.userAgent) ? "Safari12" : undefined);
+    if (/iphone|ipad/i.test(navigator.userAgent)) {
+        handlerName = "Safari12";
     }
-}
+    if (!handlerName)
+        handlerName = "Chrome111";
+    return new Device({ handlerName });
+});
 
-var _a$6;
-const adapter$6 = (_a$6 = adapterRaw.default) !== null && _a$6 !== void 0 ? _a$6 : adapterRaw;
-const DEFAULT_SOCKET_PATH = "/protocol/socket.io/v4";
-const NOOP_KEEPALIVE_INTERVAL = 2000;
-const DISCONNECT_DURATION_LIMIT_MS = 60000;
-class ServerSocket {
-    constructor(hostName, optionsOverrides, glitchFree = false, disconnectDurationLimitOn = false, serverSideDisconnectDurationLimitOn = false) {
-        this._wasConnectedUsingWebsocket = false;
-        this._disconnectDurationLimitOn = disconnectDurationLimitOn && !serverSideDisconnectDurationLimitOn;
-        this._serverSideDisconnectDurationLimitOn = serverSideDisconnectDurationLimitOn;
-        this._disconnectDurationLimitExceeded = false;
-        this._reconnectManager = null;
-        this._socket = io(hostName, Object.assign({ path: DEFAULT_SOCKET_PATH, randomizationFactor: 0.5, reconnectionDelay: 250, reconnectionDelayMax: 5000, timeout: 5000, transports: ["websocket"], withCredentials: true }, optionsOverrides));
-        this._disconnectDurationLimitEnabled = false;
-        this.joinRoomFinished = false;
-        this._socket.io.on("reconnect", () => {
-            if (this._disconnectDurationLimitOn &&
-                this._didExceedDisconnectDurationLimit(this._disconnectDurationLimitLatestTimestamp)) {
-                this._socket.close();
-                this._disconnectDurationLimitExceeded = true;
-            }
-            this._socket.sendBuffer = [];
-        });
-        this._socket.io.on("reconnect_attempt", () => {
-            var _a;
-            if (this._disconnectDurationLimitOn &&
-                this._didExceedDisconnectDurationLimit(this._disconnectDurationLimitLatestTimestamp)) {
-                this._socket.close();
-                this._disconnectDurationLimitExceeded = true;
-            }
-            if (this._wasConnectedUsingWebsocket) {
-                this._socket.io.opts.transports = ["websocket"];
-                if (((_a = adapter$6.browserDetails) === null || _a === void 0 ? void 0 : _a.browser) !== "safari") {
-                    delete this._wasConnectedUsingWebsocket;
-                }
-            }
-            else {
-                this._socket.io.opts.transports = ["websocket", "polling"];
-            }
-        });
-        if (glitchFree)
-            this._reconnectManager = new ReconnectManager(this._socket);
-        if (this._serverSideDisconnectDurationLimitOn)
-            this._keepAliveManager = new KeepAliveManager(this);
-        this._socket.on("room_joined", (payload) => {
-            if (!("error" in payload)) {
-                this.joinRoomFinished = true;
-            }
-        });
-        this._socket.on("connect", () => {
-            const transport = this.getTransport();
-            if (transport === "websocket") {
-                this._wasConnectedUsingWebsocket = true;
-                if (this._serverSideDisconnectDurationLimitOn)
-                    return;
-                if (!this.noopKeepaliveInterval) {
-                    let disconnectDurationLimitTimestampCandidate = Date.now();
-                    this.noopKeepaliveInterval = setInterval(() => {
-                        try {
-                            if (this._socket.connected) {
-                                if (this._disconnectDurationLimitOn &&
-                                    !this._didExceedDisconnectDurationLimit(disconnectDurationLimitTimestampCandidate)) {
-                                    this._disconnectDurationLimitLatestTimestamp =
-                                        disconnectDurationLimitTimestampCandidate;
-                                    disconnectDurationLimitTimestampCandidate = Date.now();
-                                }
-                                this._socket.io.engine.sendPacket("noop");
-                            }
-                        }
-                        catch (ex) { }
-                    }, NOOP_KEEPALIVE_INTERVAL);
-                }
-            }
-        });
-        this._socket.on("disconnect", () => {
-            this.joinRoomFinished = false;
-            this.disconnectTimestamp = Date.now();
-            if (this._serverSideDisconnectDurationLimitOn)
-                return;
-            if (this._disconnectDurationLimitOn &&
-                this._didExceedDisconnectDurationLimit(this._disconnectDurationLimitLatestTimestamp)) {
-                this._socket.close();
-                this._disconnectDurationLimitExceeded = true;
-            }
-            if (this.noopKeepaliveInterval) {
-                clearInterval(this.noopKeepaliveInterval);
-                this.noopKeepaliveInterval = null;
-            }
+const logger$8 = new Logger();
+const AUDIO_SETTINGS = {
+    codecOptions: {
+        opusDtx: true,
+        opusFec: true,
+    },
+    encodings: [{ dtx: true }],
+};
+const VIDEO_SETTINGS_HD = {
+    codecOptions: {
+        videoGoogleStartBitrate: 500,
+    },
+    encodings: [
+        { scaleResolutionDownBy: 4, maxBitrate: 150000 },
+        { scaleResolutionDownBy: 2, maxBitrate: 500000 },
+        { scaleResolutionDownBy: 1, maxBitrate: 1000000 },
+    ],
+};
+const VIDEO_SETTINGS_SD = {
+    codecOptions: {
+        videoGoogleStartBitrate: 500,
+    },
+    encodings: [
+        { scaleResolutionDownBy: 2, maxBitrate: 150000 },
+        { scaleResolutionDownBy: 1, maxBitrate: 500000 },
+    ],
+};
+const VIDEO_SETTINGS_VP9 = {
+    codecOptions: {
+        videoGoogleStartBitrate: 500,
+    },
+    encodings: [{ scalabilityMode: "L3T2", maxBitrate: 1000000 }],
+};
+const VIDEO_SETTINGS_VP9_LOW_BANDWIDTH = {
+    codecOptions: {
+        videoGoogleStartBitrate: 500,
+    },
+    encodings: [{ scalabilityMode: "L2T2", maxBitrate: 500000 }],
+};
+const SCREEN_SHARE_SETTINGS = {
+    encodings: [{}],
+};
+const SCREEN_SHARE_SIMULCAST_SETTINGS = {
+    encodings: [
+        { scaleResolutionDownBy: 2, dtx: true, maxBitrate: 500000 },
+        { scaleResolutionDownBy: 1, dtx: true, maxBitrate: 1500000 },
+    ],
+};
+const ADDITIONAL_SCREEN_SHARE_SETTINGS = {
+    encodings: [
+        { scaleResolutionDownBy: 4, dtx: true, maxBitrate: 150000 },
+        { scaleResolutionDownBy: 2, dtx: true, maxBitrate: 500000 },
+        { scaleResolutionDownBy: 1, dtx: true, maxBitrate: 1500000 },
+    ],
+};
+const getMediaSettings = (kind, isScreenShare, features, areTooManyAlreadyPresenting = false) => {
+    var _a;
+    const { lowDataModeEnabled, simulcastScreenshareOn, vp9On } = features;
+    if (kind === "audio") {
+        return AUDIO_SETTINGS;
+    }
+    const isChrome = ((_a = adapterRaw.browserDetails) === null || _a === void 0 ? void 0 : _a.browser) === "chrome";
+    const isVp9Available = isChrome && vp9On;
+    if (isScreenShare) {
+        return getScreenShareMediaSettings({
+            areTooManyAlreadyPresenting,
+            simulcastScreenshareOn,
         });
     }
-    _didExceedDisconnectDurationLimit(timestamp) {
-        if (!timestamp || !this._disconnectDurationLimitOn || !this._disconnectDurationLimitEnabled)
-            return false;
-        const disconnectedDuration = Date.now() - timestamp;
-        if (disconnectedDuration > DISCONNECT_DURATION_LIMIT_MS) {
-            return true;
-        }
-        return false;
+    else {
+        return getCameraMediaSettings({
+            lowBandwidth: lowDataModeEnabled,
+            isVp9Available,
+        });
     }
-    get disconnectDurationLimitExceeded() {
-        var _a, _b;
-        if (this._serverSideDisconnectDurationLimitOn) {
-            return (_b = (_a = this._keepAliveManager) === null || _a === void 0 ? void 0 : _a.disconnectDurationLimitExceeded) !== null && _b !== void 0 ? _b : false;
-        }
-        else if (this._disconnectDurationLimitOn) {
-            return this._disconnectDurationLimitExceeded;
+};
+const getCameraMediaSettings = ({ lowBandwidth, isVp9Available, }) => {
+    if (lowBandwidth) {
+        if (isVp9Available) {
+            return VIDEO_SETTINGS_VP9_LOW_BANDWIDTH;
         }
-        return false;
+        return VIDEO_SETTINGS_SD;
     }
-    enableDisconnectDurationLimit() {
-        var _a;
-        if (this._serverSideDisconnectDurationLimitOn) {
-            (_a = this._keepAliveManager) === null || _a === void 0 ? void 0 : _a.enableDisconnectDurationLimit();
-        }
-        else if (this._disconnectDurationLimitOn) {
-            this._disconnectDurationLimitEnabled = true;
-        }
+    if (isVp9Available) {
+        return VIDEO_SETTINGS_VP9;
     }
-    setRtcManager(rtcManager) {
-        if (this._reconnectManager) {
-            this._reconnectManager.rtcManager = rtcManager;
-        }
+    return VIDEO_SETTINGS_HD;
+};
+const getScreenShareMediaSettings = ({ areTooManyAlreadyPresenting, simulcastScreenshareOn, }) => {
+    if (areTooManyAlreadyPresenting) {
+        return ADDITIONAL_SCREEN_SHARE_SETTINGS;
     }
-    connect() {
-        if (this.isConnected() || this.isConnecting()) {
-            return;
-        }
-        this._socket.open();
+    if (simulcastScreenshareOn)
+        return SCREEN_SHARE_SIMULCAST_SETTINGS;
+    return SCREEN_SHARE_SETTINGS;
+};
+var PrioritizableCodec;
+(function (PrioritizableCodec) {
+    PrioritizableCodec["H264"] = "video/h264";
+    PrioritizableCodec["VP9"] = "video/vp9";
+})(PrioritizableCodec || (PrioritizableCodec = {}));
+const modifyMediaCapabilities = (routerRtpCapabilities, features) => {
+    var _a;
+    const { vp9On, h264On } = features;
+    const isChrome = ((_a = adapterRaw.browserDetails) === null || _a === void 0 ? void 0 : _a.browser) === "chrome";
+    if (!(routerRtpCapabilities === null || routerRtpCapabilities === void 0 ? void 0 : routerRtpCapabilities.codecs)) {
+        return routerRtpCapabilities;
     }
-    disconnect() {
-        this._socket.disconnect();
+    if (vp9On && isChrome) {
+        const sorted = prioritizeRouterRtpCapabilitiesCodecs(routerRtpCapabilities.codecs, PrioritizableCodec.VP9);
+        return Object.assign(Object.assign({}, routerRtpCapabilities), { codecs: sorted });
     }
-    emit(eventName, ...args) {
-        this._socket.emit.apply(this._socket, arguments);
+    else if (h264On) {
+        const sorted = prioritizeRouterRtpCapabilitiesCodecs(routerRtpCapabilities.codecs, PrioritizableCodec.H264);
+        return Object.assign(Object.assign({}, routerRtpCapabilities), { codecs: sorted });
     }
-    getTransport() {
-        var _a, _b, _c, _d;
-        return (_d = (_c = (_b = (_a = this._socket) === null || _a === void 0 ? void 0 : _a.io) === null || _b === void 0 ? void 0 : _b.engine) === null || _c === void 0 ? void 0 : _c.transport) === null || _d === void 0 ? void 0 : _d.name;
+    return routerRtpCapabilities;
+};
+function prioritizeRouterRtpCapabilitiesCodecs(codecs, preferredCodec) {
+    const preferredCodecEntry = codecs.find(({ mimeType }) => mimeType.toLowerCase() === preferredCodec);
+    if (!preferredCodecEntry) {
+        return codecs;
     }
-    getManager() {
-        return this._socket.io;
+    return [...codecs].sort((left, right) => {
+        var _a;
+        if (left.mimeType.toLowerCase() === preferredCodec) {
+            return -1;
+        }
+        if (left.mimeType.toLowerCase() === "video/rtx" &&
+            ((_a = left.parameters) === null || _a === void 0 ? void 0 : _a.apt) === preferredCodecEntry.preferredPayloadType) {
+            if (right.mimeType.toLowerCase() === preferredCodec) {
+                return 1;
+            }
+            return -1;
+        }
+        return 0;
+    });
+}
+function getPreferredOrder(availableCodecs, { av1On }) {
+    availableCodecs.unshift("video/vp9");
+    if (av1On) {
+        availableCodecs.unshift("video/av1");
     }
-    isConnecting() {
-        return this._socket && this._socket.connecting;
+    return availableCodecs;
+}
+function sortCodecsByMimeType(codecs, features) {
+    const availableCodecs = codecs
+        .map(({ mimeType }) => mimeType)
+        .filter((value, index, array) => array.indexOf(value) === index);
+    const preferredOrder = getPreferredOrder(availableCodecs, features);
+    return codecs.sort((a, b) => {
+        const indexA = preferredOrder.indexOf(a.mimeType.toLowerCase());
+        const indexB = preferredOrder.indexOf(b.mimeType.toLowerCase());
+        const orderA = indexA >= 0 ? indexA : Number.MAX_VALUE;
+        const orderB = indexB >= 0 ? indexB : Number.MAX_VALUE;
+        return orderA - orderB;
+    });
+}
+function getIsCodecDecodingPowerEfficient(codec) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { powerEfficient } = yield navigator.mediaCapabilities.decodingInfo({
+            type: "webrtc",
+            video: {
+                width: 1280,
+                height: 720,
+                bitrate: 2580,
+                framerate: 24,
+                contentType: codec,
+            },
+        });
+        return powerEfficient;
+    });
+}
+function sortCodecsByPowerEfficiency(codecs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let codecPowerEfficiencyEntries;
+        try {
+            codecPowerEfficiencyEntries = yield Promise.all(codecs.map(({ mimeType }) => getIsCodecDecodingPowerEfficient(mimeType).then((val) => [mimeType, val])));
+        }
+        catch (error) {
+            logger$8.error(error);
+            return codecs;
+        }
+        const codecPowerEfficiencies = Object.fromEntries(codecPowerEfficiencyEntries);
+        const sorted = codecs.sort((a, b) => {
+            const aPowerEfficient = codecPowerEfficiencies[a.mimeType];
+            const bPowerEfficient = codecPowerEfficiencies[b.mimeType];
+            return aPowerEfficient === bPowerEfficient ? 0 : aPowerEfficient ? -1 : 1;
+        });
+        return sorted;
+    });
+}
+function sortCodecs(codecs, features) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let sortedCodecs = sortCodecsByMimeType(codecs, features);
+        sortedCodecs = yield sortCodecsByPowerEfficiency(codecs);
+        return sortedCodecs;
+    });
+}
+
+function captureCandidatePairInfoMetrics(cpMetrics, currentCptats, prevCptats, timeDiff, report) {
+    const bytesReceivedDiff = currentCptats.bytesReceived - ((prevCptats === null || prevCptats === void 0 ? void 0 : prevCptats.bytesReceived) || 0);
+    const bytesSentDiff = currentCptats.bytesSent - ((prevCptats === null || prevCptats === void 0 ? void 0 : prevCptats.bytesSent) || 0);
+    cpMetrics.bitrateIn = (8000 * bytesReceivedDiff) / timeDiff;
+    cpMetrics.bitrateOut = (8000 * bytesSentDiff) / timeDiff;
+    cpMetrics.state = currentCptats.state;
+    cpMetrics.roundTripTime = currentCptats.currentRoundTripTime;
+    cpMetrics.requestsSent = currentCptats.requestsSent;
+    cpMetrics.responsesReceived = currentCptats.responsesReceived;
+    cpMetrics.requestsReceived = currentCptats.requestsReceived;
+    cpMetrics.responsesSent = currentCptats.responsesSent;
+    cpMetrics.availableOutgoingBitrate = currentCptats.availableOutgoingBitrate;
+    cpMetrics.availableIncomingBitrate = currentCptats.availableIncomingBitrate;
+    const remote = report.get(currentCptats.remoteCandidateId);
+    const local = report.get(currentCptats.localCandidateId);
+    cpMetrics.usingTurn = false;
+    if (local) {
+        if (/relay/i.test(local.candidateType || "")) {
+            cpMetrics.usingTurn = true;
+            cpMetrics.turnProtocol = local.relayProtocol;
+        }
     }
-    isConnected() {
-        return this._socket && this._socket.connected;
+    if (remote && local) {
+        cpMetrics.localEp = `${local.protocol}:${local.address || local.ip}:${local.port} ${local.candidateType} (${local.networkType})`;
+        cpMetrics.remoteEp = `${remote.protocol}:${remote.address || remote.ip}:${remote.port} ${remote.candidateType}`;
     }
-    on(eventName, handler) {
-        const relayableEvents = [
-            PROTOCOL_RESPONSES.ROOM_JOINED,
-            PROTOCOL_RESPONSES.CLIENT_LEFT,
-            PROTOCOL_RESPONSES.NEW_CLIENT,
-        ];
-        if (this._reconnectManager && relayableEvents.includes(eventName)) {
-            return this._interceptEvent(eventName, handler);
+}
+function captureSsrcInfo(ssrcMetrics, currentSsrcStats, prevSsrcStats, timeDiff, report) {
+    if (ssrcMetrics.codec)
+        return;
+    ssrcMetrics.kind = currentSsrcStats.kind || currentSsrcStats.mediaType;
+    ssrcMetrics.ssrc = currentSsrcStats.ssrc;
+    ssrcMetrics.direction = currentSsrcStats.type === "inbound-rtp" ? "in" : "out";
+    const codecStats = currentSsrcStats.codecId && report.get(currentSsrcStats.codecId);
+    ssrcMetrics.codec =
+        codecStats &&
+            [
+                codecStats.mimeType,
+                codecStats.channels && `${codecStats.channels}ch`,
+                codecStats.clockRate,
+                codecStats.payloadType,
+                currentSsrcStats.encoderImplementation || currentSsrcStats.decoderImplementation,
+                codecStats.sdpFmtpLine,
+            ]
+                .filter(Boolean)
+                .join(" ");
+    ssrcMetrics.mid = currentSsrcStats.mid;
+    ssrcMetrics.rid = currentSsrcStats.rid;
+}
+function captureCommonSsrcMetrics(ssrcMetrics, currentSsrcStats, prevSsrcStats, timeDiff, report) {
+    const nackCountDiff = (currentSsrcStats.nackCount || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.nackCount) || 0);
+    ssrcMetrics.nackCount = (ssrcMetrics.nackCount || 0) + nackCountDiff;
+    ssrcMetrics.nackRate = (1000 * nackCountDiff) / timeDiff;
+    if (ssrcMetrics.direction === "in") {
+        const packetCountDiff = currentSsrcStats.packetsReceived - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.packetsReceived) || 0);
+        ssrcMetrics.packetCount = (ssrcMetrics.packetCount || 0) + packetCountDiff;
+        ssrcMetrics.packetRate = (1000 * packetCountDiff) / timeDiff;
+        const packetLossCountDiff = currentSsrcStats.packetsLost - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.packetsLost) || 0);
+        ssrcMetrics.packetLossCount = (ssrcMetrics.packetLossCount || 0) + packetLossCountDiff;
+        ssrcMetrics.packetLossRate = (1000 * packetLossCountDiff) / timeDiff;
+        ssrcMetrics.lossRatio = (1000 * (packetLossCountDiff / (packetLossCountDiff + packetCountDiff))) / timeDiff;
+        const byteCountDiff = currentSsrcStats.bytesReceived - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.bytesReceived) || 0);
+        ssrcMetrics.byteCount = (ssrcMetrics.byteCount || 0) + byteCountDiff;
+        let headerByteCountDiff = 0;
+        if (currentSsrcStats.headerBytesReceived) {
+            headerByteCountDiff = currentSsrcStats.headerBytesReceived - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.headerBytesReceived) || 0);
+            ssrcMetrics.headerByteCount = (ssrcMetrics.headerByteCount || 0) + headerByteCountDiff;
+        }
+        const totalBytesDiff = byteCountDiff + headerByteCountDiff;
+        ssrcMetrics.bitrate = (8000 * totalBytesDiff) / timeDiff;
+        ssrcMetrics.mediaRatio = byteCountDiff / totalBytesDiff;
+        if (currentSsrcStats.kind === "audio") {
+            const fecBytesDiff = (currentSsrcStats.fecBytesReceived || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.fecBytesReceived) || 0);
+            ssrcMetrics.fecRatio = fecBytesDiff / byteCountDiff;
         }
-        this._socket.on(eventName, handler);
-        return () => {
-            this._socket.off(eventName, handler);
-        };
-    }
-    onEngineEvent(eventName, handler) {
-        var _a;
-        (_a = this._socket.io) === null || _a === void 0 ? void 0 : _a.on(eventName, handler);
-        return () => {
-            var _a;
-            (_a = this._socket.io) === null || _a === void 0 ? void 0 : _a.off(eventName, handler);
-        };
-    }
-    once(eventName, handler) {
-        this._socket.once(eventName, handler);
-    }
-    off(eventName, handler) {
-        this._socket.off(eventName, handler);
+        const jitterBufferDelayDiff = (currentSsrcStats.jitterBufferDelay || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.jitterBufferDelay) || 0);
+        const jitterBufferEmittedDiff = (currentSsrcStats.jitterBufferEmittedCount || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.jitterBufferEmittedCount) || 0);
+        ssrcMetrics.jitter = jitterBufferEmittedDiff ? jitterBufferDelayDiff / jitterBufferEmittedDiff : 0;
     }
-    _interceptEvent(eventName, handler) {
-        if (this._reconnectManager) {
-            this._reconnectManager.on(eventName, handler);
+    else {
+        const packetCountDiff = currentSsrcStats.packetsSent - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.packetsSent) || 0);
+        ssrcMetrics.packetCount = (ssrcMetrics.packetCount || 0) + packetCountDiff;
+        ssrcMetrics.packetRate = (1000 * packetCountDiff) / timeDiff;
+        const byteCountDiff = currentSsrcStats.bytesSent - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.bytesSent) || 0);
+        ssrcMetrics.byteCount = (ssrcMetrics.byteCount || 0) + byteCountDiff;
+        let headerByteCountDiff = 0;
+        if (currentSsrcStats.headerBytesSent) {
+            headerByteCountDiff = currentSsrcStats.headerBytesSent - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.headerBytesSent) || 0);
+            ssrcMetrics.headerByteCount = (ssrcMetrics.headerByteCount || 0) + headerByteCountDiff;
         }
-        return () => {
-            if (this._reconnectManager)
-                this._reconnectManager.removeListener(eventName, handler);
-        };
-    }
-    getGlitchFreeMetrics() {
-        var _a;
-        return (_a = this._reconnectManager) === null || _a === void 0 ? void 0 : _a.metrics;
-    }
-    getReconnectThreshold() {
-        var _a;
-        return (_a = this._reconnectManager) === null || _a === void 0 ? void 0 : _a.reconnectThresholdInMs;
-    }
-}
-
-const maybeTurnOnly = (iceConfig, features) => {
-    if (!features.useOnlyTURN) {
-        return;
-    }
-    iceConfig.iceTransportPolicy = "relay";
-    const filter = {
-        onlyudp: /^turn:.*transport=udp$/,
-        onlytcp: /^turn:.*transport=tcp$/,
-        onlytls: /^turns:.*transport=tcp$/,
-    }[features.useOnlyTURN];
-    if (filter) {
-        iceConfig.iceServers = iceConfig.iceServers.filter((entry) => {
-            if (entry.url && entry.url.match(filter))
-                return entry;
-            if (entry.urls) {
-                entry.urls = (entry.urls.some ? entry.urls : [entry.urls]).filter((url) => url.match(filter));
-                if (entry.urls.length > 0)
-                    return entry;
+        const totalBytesDiff = byteCountDiff + headerByteCountDiff;
+        ssrcMetrics.bitrate = (8000 * totalBytesDiff) / timeDiff;
+        ssrcMetrics.mediaRatio = byteCountDiff / totalBytesDiff;
+        const sendDelayDiff = currentSsrcStats.totalPacketSendDelay - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.totalPacketSendDelay) || 0);
+        ssrcMetrics.sendDelay = sendDelayDiff / packetCountDiff;
+        const retransDiff = currentSsrcStats.retransmittedPacketsSent - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.retransmittedPacketsSent) || 0);
+        ssrcMetrics.retransRatio = (1000 * (retransDiff / packetCountDiff)) / timeDiff;
+        if (currentSsrcStats.remoteId) {
+            const remoteReport = report.get(currentSsrcStats.remoteId);
+            if (remoteReport) {
+                ssrcMetrics.roundTripTime = remoteReport.roundTripTime || 0;
+                ssrcMetrics.jitter = remoteReport.jitter || 0;
+                ssrcMetrics.fractionLost = remoteReport.fractionLost || 0;
             }
-        });
-    }
-};
-const external_stun_servers = (iceConfig, features) => {
-    if (features.addGoogleStunServers) {
-        iceConfig.iceServers = [
-            { urls: "stun:stun.l.google.com:19302" },
-            { urls: "stun:stun2.l.google.com:19302" },
-            ...iceConfig.iceServers,
-        ];
+        }
     }
-    if (features.addCloudflareStunServers) {
-        iceConfig.iceServers = [
-            { urls: "stun:stun.cloudflare.com:3478" },
-            { urls: "stun:stun.cloudflare.com:53" },
-            ...iceConfig.iceServers,
-        ];
+}
+function captureAudioSsrcMetrics(ssrcMetrics, currentSsrcStats, prevSsrcStats, timeDiff, report) {
+    const packetsDiscardedDiff = currentSsrcStats.packetsDiscarded - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.packetsDiscarded) || 0);
+    ssrcMetrics.packetsDiscarded = (ssrcMetrics.packetsDiscarded || 0) + packetsDiscardedDiff;
+    if (ssrcMetrics.direction === "in") {
+        const totalAudioEnergyDiff = currentSsrcStats.totalAudioEnergy - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.totalAudioEnergy) || 0);
+        const totalSamplesDurationDiff = currentSsrcStats.totalSamplesDuration - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.totalSamplesDuration) || 0);
+        ssrcMetrics.audioLevel = Math.sqrt(totalAudioEnergyDiff / totalSamplesDurationDiff);
+        const samples = currentSsrcStats.totalSamplesReceived || 0;
+        const concealmentEvents = currentSsrcStats.concealmentEvents || 0;
+        const samplesDiff = samples - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.totalSamplesReceived) || 0);
+        const concealedSamples = currentSsrcStats.concealedSamples || 0;
+        const concealedDiff = concealedSamples - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.concealedSamples) || 0);
+        const silentConcealedDiff = (currentSsrcStats.silentConcealedSamples || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.silentConcealedSamples) || 0);
+        const insDiff = (currentSsrcStats.insertedSamplesForDeceleration || 0) -
+            ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.insertedSamplesForDeceleration) || 0);
+        const remDiff = (currentSsrcStats.removedSamplesForAcceleration || 0) - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.removedSamplesForAcceleration) || 0);
+        ssrcMetrics.audioSamples = samples;
+        ssrcMetrics.audioConcealmentEvents = concealmentEvents;
+        ssrcMetrics.audioConcealedSamples = concealedSamples;
+        ssrcMetrics.audioConcealment = concealedDiff ? concealedDiff / samplesDiff : 0;
+        ssrcMetrics.audioSilentConcealment = silentConcealedDiff ? silentConcealedDiff / samplesDiff : 0;
+        ssrcMetrics.audioAcceleration = remDiff ? remDiff / samplesDiff : 0;
+        ssrcMetrics.audioDeceleration = insDiff ? insDiff / samplesDiff : 0;
     }
-};
-const turnServerOverride = (iceServers, overrideHost) => {
-    if (overrideHost && iceServers) {
-        const host = overrideHost;
-        const port = host.indexOf(":") > 0 ? "" : ":443";
-        const override = ":" + host + port;
-        return iceServers.map((original) => {
-            const entry = Object.assign({}, original);
-            if (entry.url) {
-                entry.url = entry.url.replace(/:[^?]*/, override);
-            }
-            if (entry.urls) {
-                entry.urls = entry.urls.map((url) => url.replace(/:[^?]*/, override));
-            }
-            return entry;
-        });
+}
+function captureVideoSsrcMetrics(ssrcMetrics, currentSsrcStats, prevSsrcStats, timeDiff, report) {
+    ssrcMetrics.width = currentSsrcStats.frameWidth;
+    ssrcMetrics.height = currentSsrcStats.frameHeight;
+    ssrcMetrics.qualityLimitationReason = currentSsrcStats.qualityLimitationReason || "";
+    const pliCountDiff = currentSsrcStats.pliCount - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.pliCount) || 0);
+    ssrcMetrics.pliCount = (ssrcMetrics.pliCount || 0) + pliCountDiff;
+    ssrcMetrics.pliRate = (1000 * pliCountDiff) / timeDiff;
+    const firCountDiff = currentSsrcStats.firCount - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.firCount) || 0);
+    ssrcMetrics.firCount = (ssrcMetrics.firCount || 0) + firCountDiff;
+    ssrcMetrics.firRate = (1000 * firCountDiff) / timeDiff;
+    if (ssrcMetrics.direction === "in") {
+        const kfCountDiff = currentSsrcStats.keyFramesDecoded - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.keyFramesDecoded) || 0);
+        ssrcMetrics.kfCount = (ssrcMetrics.kfCount || 0) + kfCountDiff;
+        ssrcMetrics.kfRate = (1000 * kfCountDiff) / timeDiff;
+        const frameCountDiff = currentSsrcStats.framesDecoded - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.framesDecoded) || 0);
+        ssrcMetrics.frameCount = (ssrcMetrics.frameCount || 0) + frameCountDiff;
+        const qpsumDiff = currentSsrcStats.qpSum - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.qpSum) || 0);
+        ssrcMetrics.qpf = qpsumDiff / frameCountDiff;
+        ssrcMetrics.fps = (frameCountDiff * 1000) / timeDiff;
     }
     else {
-        return iceServers;
-    }
-};
-
-const defaultSubdomainPattern = /^(?:([^.]+)[.])?((:?[^.]+[.]){1,}[^.]+)$/;
-const localstackPattern = /^(?:([^.]+)-)?(ip-[^.]*[.](?:hereby[.]dev|rfc1918[.]disappear[.]at)(?::\d+|))$/;
-const localhostPattern = /^(?:([^.]+)[.])?(localhost:?\d*)/;
-const serverPattern = /^(?:([^.]+)[.])?(server:?\d*)/;
-const ipv4Pattern = /^(?:([^.]+)[.])?((\d+[.]){3}:?\d*)$/;
-const subdomainPatterns = [
-    { pattern: serverPattern, separator: "." },
-    { pattern: localhostPattern, separator: "." },
-    { pattern: ipv4Pattern, separator: "." },
-    { pattern: localstackPattern, separator: "-" },
-    { pattern: defaultSubdomainPattern, separator: "." },
-];
-function fromLocation({ host = "whereby.com", protocol = "https:" } = {}) {
-    let subdomain = "";
-    let domain = host;
-    let subdomainSeparator = ".";
-    for (const { separator, pattern } of subdomainPatterns) {
-        const match = pattern.exec(host);
-        if (match) {
-            subdomain = match[1] || "";
-            domain = match[2];
-            subdomainSeparator = separator;
-            break;
+        const kfCountDiff = currentSsrcStats.keyFramesEncoded - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.keyFramesEncoded) || 0);
+        ssrcMetrics.kfCount = (ssrcMetrics.kfCount || 0) + kfCountDiff;
+        ssrcMetrics.kfRate = (1000 * kfCountDiff) / timeDiff;
+        const frameCountDiff = currentSsrcStats.framesEncoded - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.framesEncoded) || 0);
+        ssrcMetrics.frameCount = (ssrcMetrics.frameCount || 0) + frameCountDiff;
+        const qpsumDiff = currentSsrcStats.qpSum - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.qpSum) || 0);
+        ssrcMetrics.qpf = qpsumDiff / frameCountDiff;
+        ssrcMetrics.fps = (frameCountDiff * 1000) / timeDiff;
+        const encodeTimeDiff = currentSsrcStats.totalEncodeTime - ((prevSsrcStats === null || prevSsrcStats === void 0 ? void 0 : prevSsrcStats.totalEncodeTime) || 0);
+        ssrcMetrics.encodeTime = encodeTimeDiff / frameCountDiff;
+        if (currentSsrcStats.mediaSourceId) {
+            const mediaSourceReport = report.get(currentSsrcStats.mediaSourceId);
+            if (mediaSourceReport) {
+                ssrcMetrics.sourceWidth = mediaSourceReport.width || 0;
+                ssrcMetrics.sourceHeight = mediaSourceReport.height || 0;
+                ssrcMetrics.sourceFps = mediaSourceReport.framesPerSecond || 0;
+            }
         }
     }
-    const organizationDomain = !subdomain ? domain : `${subdomain}${subdomainSeparator}${domain}`;
-    return {
-        domain,
-        domainWithSeparator: `${subdomainSeparator}${domain}`,
-        organizationDomain,
-        organization: `${protocol}//${organizationDomain}`,
-        service: `${protocol}//${domain}`,
-        subdomain,
-    };
 }
-fromLocation(window && window.location);
 
-const _trackAnnotations = new WeakMap();
-function trackAnnotations(o) {
-    let props = _trackAnnotations.get(o);
-    if (!props) {
-        props = {};
-        _trackAnnotations.set(o, props);
+let peerConnections = [];
+let peerConnectionCounter = 0;
+const peerConnectionData = new WeakMap();
+const removePeerConnection = (pc) => {
+    peerConnections = peerConnections.filter((old) => old !== pc);
+};
+if (window.RTCPeerConnection) {
+    const OriginalRTCPeerConnection = window.RTCPeerConnection;
+    function PatchedRTCPeerConnection(rtcConfig) {
+        const pc = new OriginalRTCPeerConnection(rtcConfig);
+        peerConnections.push(pc);
+        peerConnectionData.set(pc, { index: peerConnectionCounter++ });
+        const onConnectionStateChange = () => {
+            if (pc.connectionState === "closed") {
+                removePeerConnection(pc);
+                pc.removeEventListener("connectionstatechange", onConnectionStateChange);
+            }
+        };
+        pc.addEventListener("connectionstatechange", onConnectionStateChange);
+        return pc;
     }
-    return props;
+    PatchedRTCPeerConnection.prototype = OriginalRTCPeerConnection.prototype;
+    window.RTCPeerConnection = PatchedRTCPeerConnection;
 }
+const getCurrentPeerConnections = () => peerConnections;
+const getPeerConnectionIndex = (pc) => { var _a; return (_a = peerConnectionData.get(pc)) === null || _a === void 0 ? void 0 : _a.index; };
+const setPeerConnectionsForTests = (pcs) => (peerConnections = pcs);
 
-const logger$9 = new Logger();
-const debugLogger = {
-    print: (...args) => console.debug(args[0], ...args.slice(1)),
-};
-logger$9.withDebugLogger(debugLogger);
-class PacketLossAnalyser {
-    constructor() {
-        this.BEGIN_PACKET_LOSS_PERIOD_THRESHOLD = 0.04;
-        this.END_PACKET_LOSS_PERIOD_THRESHOLD = 0.005;
-        this.INTERVAL_DIFF_THRESHOLD_MS = 4000;
-        this.STALE_MEASUREMENT_TIMEOUT_MS = 10000;
-        this.MINIMUM_INTERVAL_MS = 30000;
-        this.ssrcsHistory = new Map();
-        this.staleMeasurementTimeouts = new Map();
-    }
-    addPacketLossMeasurement(id, packetLoss, timestamp) {
-        this.handleStaleMeasurements(id);
-        const beginNewPacketLossPeriod = packetLoss > this.BEGIN_PACKET_LOSS_PERIOD_THRESHOLD;
-        let history = this.ssrcsHistory.get(id);
-        if (!history) {
-            history = {
-                id,
-                hasActivePacketLoss: beginNewPacketLossPeriod,
-                currPeriod: beginNewPacketLossPeriod ? { begin: timestamp } : undefined,
-                hasPeriodicPacketLoss: false,
-            };
-            this.ssrcsHistory.set(id, history);
-            return;
-        }
-        if (history.hasActivePacketLoss) {
-            if (packetLoss < this.END_PACKET_LOSS_PERIOD_THRESHOLD) {
-                this.endPacketLossPeriod(history, timestamp);
-                if (history.prevIntervalInMs && history.prevIntervalInMs < this.MINIMUM_INTERVAL_MS) {
-                    this.ssrcsHistory.delete(id);
+const PC_DATA_BY_PC = new WeakMap();
+let numMissingTrackSsrcLookups = 0;
+let numFailedTrackSsrcLookups = 0;
+const getPeerConnectionsWithStatsReports = (pcDataByPc = PC_DATA_BY_PC) => Promise.all(getCurrentPeerConnections().map((pc) => __awaiter(void 0, void 0, void 0, function* () {
+    let pcData = pcDataByPc.get(pc);
+    if (!pcData) {
+        pcData = { ssrcToTrackId: {} };
+        pcDataByPc.set(pc, pcData);
+    }
+    try {
+        const report = yield pc.getStats();
+        let missingSsrcs = null;
+        report.forEach((stats) => {
+            if (stats.type === "inbound-rtp" || stats.type === "outbound-rtp") {
+                if (!stats.trackIdentifier && !pcData.ssrcToTrackId[stats.ssrc]) {
+                    if (stats.mediaSourceId) {
+                        const mediaSourceStats = report.get(stats.mediaSourceId);
+                        if (mediaSourceStats) {
+                            if (mediaSourceStats.trackIdentifier) {
+                                pcData.ssrcToTrackId[stats.ssrc] = mediaSourceStats.trackIdentifier;
+                            }
+                        }
+                    }
+                    if (!pcData.ssrcToTrackId[stats.ssrc] && stats.trackId) {
+                        const deprecatedTrackStats = report.get(stats.trackId);
+                        if (deprecatedTrackStats) {
+                            if (deprecatedTrackStats.trackIdentifier) {
+                                pcData.ssrcToTrackId[stats.ssrc] = deprecatedTrackStats.trackIdentifier;
+                            }
+                        }
+                    }
+                    if (!pcData.ssrcToTrackId[stats.ssrc]) {
+                        if (!missingSsrcs)
+                            missingSsrcs = [];
+                        missingSsrcs.push(stats.ssrc);
+                    }
                 }
             }
-            return;
-        }
-        if (beginNewPacketLossPeriod) {
-            history.hasActivePacketLoss = true;
-            history.currPeriod = {
-                begin: timestamp,
-            };
+        });
+        if (missingSsrcs) {
+            const sendersAndReceivers = [...pc.getSenders(), ...pc.getReceivers()];
+            const reports = yield Promise.all(sendersAndReceivers.map((o) => o.getStats()));
+            reports.forEach((tReport, index) => {
+                tReport.forEach((stats) => {
+                    if (stats.type === "inbound-rtp" || stats.type === "outbound-rtp") {
+                        pcData.ssrcToTrackId[stats.ssrc] = sendersAndReceivers[index].track.id;
+                    }
+                });
+            });
+            missingSsrcs.forEach((ssrc) => {
+                numMissingTrackSsrcLookups++;
+                if (!pcData.ssrcToTrackId[ssrc]) {
+                    pcData.ssrcToTrackId[ssrc] = "?" + ssrc;
+                }
+            });
         }
+        return [pc, report, pcData];
     }
-    hasPeriodicPacketLoss(id, timestamp) {
-        const history = this.ssrcsHistory.get(id);
-        if (history && this.prevIntervalExceeded(history, timestamp)) {
-            this.ssrcsHistory.delete(history.id);
-            return false;
-        }
-        return (history === null || history === void 0 ? void 0 : history.hasPeriodicPacketLoss) || false;
+    catch (e) {
+        rtcStats.sendEvent("trackSsrcLookupFailed", {
+            name: e === null || e === void 0 ? void 0 : e.name,
+            cause: e === null || e === void 0 ? void 0 : e.cause,
+            message: e === null || e === void 0 ? void 0 : e.message,
+        });
+        numFailedTrackSsrcLookups++;
+        return [pc, [], pcData];
     }
-    prevIntervalExceeded(history, timestamp) {
-        if (history.prevPeriod && history.prevIntervalInMs) {
-            const intervalLimitTimestamp = this.calculatePeriodCenterTimestamp(history.prevPeriod) +
-                history.prevIntervalInMs +
-                this.INTERVAL_DIFF_THRESHOLD_MS;
-            return timestamp > intervalLimitTimestamp;
-        }
-        return false;
+})));
+
+const getOrCreateSsrcMetricsContainer = (statsByView, time, pcIndex, clientId, trackId, ssrc) => {
+    let viewStats = statsByView[clientId];
+    if (!viewStats) {
+        viewStats = { candidatePairs: {}, tracks: {}, startTime: time, updated: time };
+        statsByView[clientId] = viewStats;
     }
-    handleStaleMeasurements(id) {
-        const staleMeasurementTimeout = this.staleMeasurementTimeouts.get(id);
-        if (staleMeasurementTimeout) {
-            clearTimeout(staleMeasurementTimeout);
-        }
-        this.staleMeasurementTimeouts.set(id, setTimeout(() => {
-            logger$9.debug("handleStaleMeasurements() [measurements invalid for ssrc: %s]", id);
-            this.ssrcsHistory.delete(id);
-        }, this.STALE_MEASUREMENT_TIMEOUT_MS));
+    viewStats.updated = time;
+    let trackStats = viewStats.tracks[trackId];
+    if (!trackStats) {
+        trackStats = { ssrcs: {}, startTime: time, updated: time };
+        viewStats.tracks[trackId] = trackStats;
+    }
+    trackStats.updated = time;
+    let ssrcStats = trackStats.ssrcs[ssrc];
+    if (!ssrcStats) {
+        ssrcStats = {
+            startTime: time,
+            updated: time,
+            pcIndex,
+        };
+        trackStats.ssrcs[ssrc] = ssrcStats;
     }
-    endPacketLossPeriod(history, timestamp) {
-        logger$9.debug("endPacketLossPeriod() [ssrcId: %s, timestamp: %s]", history.id, timestamp);
-        if (!history.currPeriod)
-            throw new Error("No packet loss period for " + history.id);
-        if (!history.prevPeriod) {
-            history.prevPeriod = Object.assign(Object.assign({}, history.currPeriod), { end: timestamp });
+    ssrcStats.updated = time;
+    return ssrcStats;
+};
+const removeNonUpdatedStats = (statsByView, time) => {
+    Object.entries(statsByView).forEach(([viewId, viewStats]) => {
+        if (viewStats.updated !== undefined && viewStats.updated < time) {
+            delete statsByView[viewId];
         }
         else {
-            history.currPeriod.end = timestamp;
-            this.addNewPacketLossInterval(history);
-        }
-        delete history.currPeriod;
-        history.hasActivePacketLoss = false;
-    }
-    addNewPacketLossInterval(history) {
-        logger$9.debug("addNewPacketLossInterval() [ssrcId: %s, prevIntervalInMs: %s]", history.id, history.prevIntervalInMs);
-        if (!history.currPeriod || !history.prevPeriod)
-            throw new Error("missing period timestamps");
-        const prevPeriodCenter = this.calculatePeriodCenterTimestamp(history.prevPeriod);
-        const currPeriodCenter = this.calculatePeriodCenterTimestamp(history.currPeriod);
-        const currIntervalInMs = currPeriodCenter - prevPeriodCenter;
-        if (history.prevIntervalInMs) {
-            const intervalDiffInMs = Math.abs(history.prevIntervalInMs - currIntervalInMs);
-            history.hasPeriodicPacketLoss = intervalDiffInMs < this.INTERVAL_DIFF_THRESHOLD_MS;
-            logger$9.debug("addNewPacketLossInterval() [hasPeriodicPacketLoss: %s, intervalDiffInMs: %s]", intervalDiffInMs < this.INTERVAL_DIFF_THRESHOLD_MS, intervalDiffInMs);
-        }
-        history.prevIntervalInMs = currIntervalInMs;
-        history.prevPeriod = history.currPeriod;
-    }
-    calculatePeriodCenterTimestamp(period) {
-        if (!period.end)
-            throw new Error("Missing period end timestamp");
-        return period.begin + (period.end - period.begin) / 2;
-    }
-}
-
-var _a$5, _b$2;
-const adapter$5 = (_a$5 = adapterRaw.default) !== null && _a$5 !== void 0 ? _a$5 : adapterRaw;
-const logger$8 = new Logger();
-const browserName$2 = (_b$2 = adapter$5.browserDetails) === null || _b$2 === void 0 ? void 0 : _b$2.browser;
-const browserVersion$1 = adapter$5.browserDetails.version;
-function setCodecPreferenceSDP({ sdp, redOn, incrementAnalyticMetric }) {
-    var _a, _b;
-    try {
-        const sdpObject = sdpTransform.parse(sdp);
-        if (Array.isArray(sdpObject === null || sdpObject === void 0 ? void 0 : sdpObject.media)) {
-            const mediaAudio = sdpObject.media.find((m) => m.type === "audio");
-            if (Array.isArray(mediaAudio === null || mediaAudio === void 0 ? void 0 : mediaAudio.rtp)) {
-                const rtp = mediaAudio.rtp;
-                for (let i = 0; i < rtp.length; i++) {
-                    if (redOn && rtp[i].codec === "red") {
-                        const payloads = (_a = mediaAudio.payloads) === null || _a === void 0 ? void 0 : _a.split(" ");
-                        const pt = payloads === null || payloads === void 0 ? void 0 : payloads.indexOf("" + rtp[i].payload);
-                        if (pt && pt !== -1 && pt >= 0) {
-                            payloads === null || payloads === void 0 ? void 0 : payloads.unshift(payloads.splice(pt, 1)[0]);
-                            mediaAudio.payloads = payloads === null || payloads === void 0 ? void 0 : payloads.join(" ");
+            Object.entries(viewStats.tracks).forEach(([trackId, trackStats]) => {
+                if (trackStats.updated < time) {
+                    delete viewStats.tracks[trackId];
+                }
+                else {
+                    Object.entries(trackStats.ssrcs).forEach(([ssrc, ssrcStats]) => {
+                        if (ssrcStats.updated < time) {
+                            delete trackStats.ssrcs[ssrc];
                         }
-                    }
+                    });
                 }
+            });
+        }
+    });
+};
+const DEFAULT_CLIENT = {
+    id: "unknown",
+    clientId: "unknown",
+    audio: { enabled: false, track: undefined },
+    video: { enabled: false, track: undefined },
+    isAudioOnlyModeEnabled: false,
+    isLocalClient: true,
+    isPresentation: false,
+};
+function collectStats(state_1, _a, immediate_1) {
+    return __awaiter(this, arguments, void 0, function* (state, { logger, interval }, immediate) {
+        const collectStatsBound = collectStats.bind(null, state, { interval, logger });
+        try {
+            const clients = state.getClients();
+            const defaultClient = clients.find((c) => c.isLocalClient && !c.isPresentation) || DEFAULT_CLIENT;
+            let defaultViewStats = state.statsByView[defaultClient.id];
+            if (!defaultViewStats) {
+                defaultViewStats = { tracks: {}, candidatePairs: {}, pressure: null };
+                state.statsByView[defaultClient.id] = defaultViewStats;
             }
-            const mediaVideo = sdpObject.media.find((m) => m.type === "video");
-            if (Array.isArray(mediaVideo === null || mediaVideo === void 0 ? void 0 : mediaVideo.rtp)) {
-                const rtp = mediaVideo.rtp;
-                for (let i = 0; i < rtp.length; i++) {
-                    if (rtp[i].codec === "VP9") {
-                        const payloads = (_b = mediaVideo.payloads) === null || _b === void 0 ? void 0 : _b.split(" ");
-                        const pt = payloads === null || payloads === void 0 ? void 0 : payloads.indexOf("" + rtp[i].payload);
-                        if (pt && pt !== -1 && pt >= 0) {
-                            payloads === null || payloads === void 0 ? void 0 : payloads.unshift(payloads.splice(pt, 1)[0]);
-                            mediaVideo.payloads = payloads === null || payloads === void 0 ? void 0 : payloads.join(" ");
+            defaultViewStats.pressure = state.lastPressureObserverRecord;
+            const timeSinceLastUpdate = Date.now() - state.lastUpdateTime;
+            if (timeSinceLastUpdate < 400) {
+                if (immediate)
+                    return state.statsByView;
+                state.subscriptions.forEach((subscription) => { var _a; return (_a = subscription.onUpdatedStats) === null || _a === void 0 ? void 0 : _a.call(subscription, state.statsByView, clients); });
+                state.nextTimeout = setTimeout(collectStatsBound, interval);
+                return;
+            }
+            state.lastUpdateTime = Date.now();
+            (yield getPeerConnectionsWithStatsReports()).forEach(([pc, report, pcData]) => {
+                const pcIndex = getPeerConnectionIndex(pc);
+                if (pcIndex === undefined) {
+                    logger.warn("Could not find index for PeerConnection");
+                }
+                if (pc.connectionState === "closed") {
+                    report = new Map();
+                    removePeerConnection(pc);
+                }
+                pcData.previousSSRCs = pcData.currentSSRCs || {};
+                pcData.currentSSRCs = {};
+                report.forEach((currentRtcStats) => {
+                    var _a, _b;
+                    if (currentRtcStats.type === "candidate-pair" && /inprogress|succeeded/.test(currentRtcStats.state)) {
+                        const prevRtcStats = (_a = pcData._oldReport) === null || _a === void 0 ? void 0 : _a.get(currentRtcStats.id);
+                        const timeDiff = prevRtcStats ? currentRtcStats.timestamp - prevRtcStats.timestamp : interval;
+                        const cpId = pcIndex + ":" + currentRtcStats.id;
+                        let cpMetrics = defaultViewStats.candidatePairs[cpId];
+                        if (!cpMetrics) {
+                            cpMetrics = { startTime: state.lastUpdateTime, id: cpId };
+                            defaultViewStats.candidatePairs[cpId] = cpMetrics;
+                        }
+                        captureCandidatePairInfoMetrics(cpMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
+                        cpMetrics.lastRtcStatsTime = state.lastUpdateTime;
+                    }
+                    if (currentRtcStats.type === "inbound-rtp" || currentRtcStats.type === "outbound-rtp") {
+                        const kind = (currentRtcStats.mediaType || currentRtcStats.kind);
+                        const ssrc = currentRtcStats.ssrc;
+                        let trackId = currentRtcStats.trackIdentifier || pcData.ssrcToTrackId[ssrc];
+                        let prevRtcStats = (_b = pcData._oldReport) === null || _b === void 0 ? void 0 : _b.get(currentRtcStats.id);
+                        if (prevRtcStats && prevRtcStats.mediaSourceId !== currentRtcStats.mediaSourceId) {
+                            const mediaSourceStats = report.get(currentRtcStats.mediaSourceId);
+                            if (mediaSourceStats && mediaSourceStats.trackIdentifier) {
+                                trackId = mediaSourceStats.trackIdentifier;
+                                pcData.ssrcToTrackId[ssrc] = trackId;
+                            }
+                        }
+                        const client = clients.find((c) => { var _a; return ((_a = c[kind].track) === null || _a === void 0 ? void 0 : _a.id) === trackId; }) || defaultClient;
+                        const clientTrack = client[kind].track;
+                        if (!currentRtcStats.trackIdentifier &&
+                            pcData.ssrcToTrackId[ssrc] &&
+                            (clientTrack === null || clientTrack === void 0 ? void 0 : clientTrack.id) &&
+                            clientTrack.id !== pcData.ssrcToTrackId[ssrc]) {
+                            trackId = clientTrack.id;
+                            pcData.ssrcToTrackId[ssrc] = clientTrack.id;
+                        }
+                        pcData.currentSSRCs[ssrc] = client.id;
+                        if (prevRtcStats) {
+                            const newTransport = report.get(currentRtcStats.transportId);
+                            const oldTransport = pcData._oldReport.get(prevRtcStats.transportId);
+                            if (oldTransport &&
+                                (newTransport === null || newTransport === void 0 ? void 0 : newTransport.selectedCandidatePairId) !== oldTransport.selectedCandidatePairId) {
+                                prevRtcStats = null;
+                            }
+                            else if (currentRtcStats.bytesReceived < prevRtcStats.bytesReceived ||
+                                currentRtcStats.bytesSent < prevRtcStats.bytesSent) {
+                                prevRtcStats = null;
+                            }
+                        }
+                        const timeDiff = prevRtcStats ? currentRtcStats.timestamp - prevRtcStats.timestamp : interval;
+                        const ssrcMetrics = getOrCreateSsrcMetricsContainer(state.statsByView, state.lastUpdateTime, pcIndex, client.id, trackId, ssrc);
+                        captureSsrcInfo(ssrcMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
+                        captureCommonSsrcMetrics(ssrcMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
+                        if (kind === "video") {
+                            captureVideoSsrcMetrics(ssrcMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
+                        }
+                        if (kind === "audio") {
+                            captureAudioSsrcMetrics(ssrcMetrics, currentRtcStats, prevRtcStats, timeDiff, report);
+                        }
+                    }
+                });
+                pcData._oldReport = report;
+                Object.keys(pcData.previousSSRCs)
+                    .filter((ssrc) => !pcData.currentSSRCs[ssrc])
+                    .forEach((ssrc) => {
+                    const clientId = pcData.previousSSRCs[ssrc];
+                    if (clientId) {
+                        const clientView = state.statsByView[clientId];
+                        if (clientView) {
+                            Object.values(clientView.tracks).forEach((trackStats) => {
+                                if (trackStats.ssrcs[ssrc]) {
+                                    delete trackStats.ssrcs[ssrc];
+                                }
+                            });
+                        }
+                    }
+                });
+            });
+            removeNonUpdatedStats(state.statsByView, state.lastUpdateTime);
+            Object.entries((defaultViewStats === null || defaultViewStats === void 0 ? void 0 : defaultViewStats.candidatePairs) || {}).forEach(([cpKey, cp]) => {
+                const active = cp.lastRtcStatsTime === state.lastUpdateTime;
+                cp.active = active;
+                if (!active) {
+                    cp.state = "old/inactive";
+                    if (!cp.inactiveFromTime)
+                        cp.inactiveFromTime = state.lastUpdateTime;
+                    else {
+                        if (state.lastUpdateTime - cp.inactiveFromTime > 4000) {
+                            delete defaultViewStats.candidatePairs[cpKey];
                         }
                     }
                 }
+            });
+            if (immediate) {
+                return state.statsByView;
+            }
+            else {
+                state.subscriptions.forEach((subscription) => { var _a; return (_a = subscription.onUpdatedStats) === null || _a === void 0 ? void 0 : _a.call(subscription, state.statsByView, clients); });
             }
         }
-        const newSdp = sdpTransform.write(sdpObject);
-        return newSdp;
-    }
-    catch (error) {
-        incrementAnalyticMetric("P2PSetCodecPreferenceError");
-        rtcStats.sendEvent("P2PSetCodecPreferenceError", { error });
-        logger$8.error("setCodecPreferenceSDP error:", error);
-        return sdp;
+        catch (e) {
+            logger.warn(e);
+            state.numFailedStatsReports++;
+            rtcStats.sendEvent("collectStatsFailed", {
+                name: e === null || e === void 0 ? void 0 : e.name,
+                cause: e === null || e === void 0 ? void 0 : e.cause,
+                message: e === null || e === void 0 ? void 0 : e.message,
+            });
+        }
+        state.nextTimeout = setTimeout(collectStatsBound, interval);
+    });
+}
+
+const REGISTERED_TRIALS = {};
+function registerOriginTrials(trials, registeredTrials = REGISTERED_TRIALS, document = window.document) {
+    trials.forEach(({ hostnamePattern, token }) => {
+        const key = `${hostnamePattern}-${token}`;
+        if (registeredTrials[key]) {
+            return;
+        }
+        if (hostnamePattern.test(document.location.hostname)) {
+            const otMeta = document.createElement("meta");
+            otMeta.httpEquiv = "origin-trial";
+            otMeta.content = token;
+            document.head.append(otMeta);
+            registeredTrials[key] = true;
+        }
+    });
+}
+
+const CPU_OBSERVER_OPTIONS = {
+    sampleRate: 1,
+    originTrials: [
+        {
+            hostnamePattern: /hereby\.dev/,
+            token: "AkSNPHJw6EK08X0QU7kORnK9NABzRLAC7dqfXOwk5JwFAQG4Ey7WxLXxsnhieCgC1QHUdevE2EFICy7uBGDANwUAAABqeyJvcmlnaW4iOiJodHRwczovL2hlcmVieS5kZXY6NDQ0MyIsImZlYXR1cmUiOiJDb21wdXRlUHJlc3N1cmVfdjIiLCJleHBpcnkiOjE3MTY5NDA3OTksImlzU3ViZG9tYWluIjp0cnVlfQ==",
+        },
+        {
+            hostnamePattern: /whereby\.com/,
+            token: "Asc2wu8KpSx648i932NICteQDFcB05yl2QUUSHD7AQo8JGP2Fp6FF91TvYVJBsKGzLMH349rysPw5q9tqPC/PAUAAABqeyJvcmlnaW4iOiJodHRwczovL3doZXJlYnkuY29tOjQ0MyIsImZlYXR1cmUiOiJDb21wdXRlUHJlc3N1cmVfdjIiLCJleHBpcnkiOjE3MTY5NDA3OTksImlzU3ViZG9tYWluIjp0cnVlfQ==",
+        },
+    ],
+};
+function startCpuObserver(cb, { sampleRate, originTrials } = CPU_OBSERVER_OPTIONS, window = globalThis.window) {
+    registerOriginTrials(originTrials);
+    let pressureObserver;
+    if ("PressureObserver" in window) {
+        pressureObserver = new window.PressureObserver(cb, { sampleRate });
+        pressureObserver.observe("cpu", { sampleInterval: sampleRate * 1000 });
+        return {
+            stop: () => {
+                pressureObserver.unobserve("cpu");
+            },
+        };
     }
 }
-function cleanSdp(sdp) {
+
+const STATE = {
+    currentMonitor: null,
+    getClients: () => [],
+    lastUpdateTime: 0,
+    statsByView: {},
+    subscriptions: [],
+    numFailedStatsReports: 0,
+};
+const OPTIONS = {
+    interval: 2000,
+    logger: new Logger(),
+};
+const getStats = () => {
+    return Object.assign({}, STATE.statsByView);
+};
+const getNumFailedStatsReports = () => {
+    return STATE.numFailedStatsReports;
+};
+const getNumMissingTrackSsrcLookups = () => numMissingTrackSsrcLookups;
+const getNumFailedTrackSsrcLookups = () => numFailedTrackSsrcLookups;
+const getUpdatedStats = () => { var _a; return (_a = STATE.currentMonitor) === null || _a === void 0 ? void 0 : _a.getUpdatedStats(); };
+const setClientProvider = (provider) => (STATE.getClients = provider);
+function startStatsMonitor(state, { interval, logger }) {
+    const collectStatsBound = collectStats.bind(null, state, { interval, logger });
+    let cpuObserver;
     try {
-        const sdpObject = sdpTransform.parse(sdp);
-        sdpObject.media.forEach((mediaObject) => {
-            const usedPayloads = {};
-            if (mediaObject.payloads)
-                mediaObject.payloads = ("" + mediaObject.payloads)
-                    .split(" ")
-                    .filter((p) => !usedPayloads[p] && (usedPayloads[p] = true))
-                    .join(" ");
-            const usedRtps = {};
-            mediaObject.rtp = mediaObject.rtp.filter((p) => !p.payload || (usedPayloads[p.payload] && !usedRtps[p.payload] && (usedRtps[p.payload] = true)));
-            const usedFmtps = {};
-            if (mediaObject.fmtp)
-                mediaObject.fmtp = mediaObject.fmtp.filter((p) => !p.payload ||
-                    (usedPayloads[p.payload] && !usedFmtps[p.payload] && (usedFmtps[p.payload] = true)));
-            const usedRtcpFb = {};
-            if (mediaObject.rtcpFb)
-                mediaObject.rtcpFb = mediaObject.rtcpFb.filter((p) => !p.payload ||
-                    (usedPayloads[p.payload] &&
-                        !usedRtcpFb[p.payload + p.type + p.subtype] &&
-                        (usedRtcpFb[p.payload + p.type + p.subtype] = true)));
-        });
-        return sdpTransform.write(sdpObject);
+        cpuObserver = startCpuObserver((records) => (state.lastPressureObserverRecord = records.pop()));
     }
-    catch (_) { }
-    return sdp;
-}
-function deprioritizeH264(sdp) {
-    return SDPUtils.splitSections(sdp)
-        .map((section) => {
-        if (SDPUtils.getKind(section) !== "video")
-            return section;
-        const h264payloadTypes = SDPUtils.matchPrefix(section, "a=rtpmap:")
-            .map((line) => SDPUtils.parseRtpMap(line))
-            .filter((codec) => /h264/i.test(codec.name))
-            .map((codec) => "" + codec.payloadType);
-        if (!h264payloadTypes.length)
-            return section;
-        const mline = SDPUtils.matchPrefix(section, "m=video")[0];
-        const mlinePayloadsSectionExec = /(\s\d+)+$/i.exec(mline);
-        const mlinePayloadsSection = mlinePayloadsSectionExec ? mlinePayloadsSectionExec[0] : "";
-        const mlinePayloadsNonH264 = mlinePayloadsSection
-            .split(" ")
-            .filter((payloadType) => payloadType && !h264payloadTypes.includes(payloadType));
-        const reorderedPayloads = [...mlinePayloadsNonH264, ...h264payloadTypes].join(" ");
-        const newmline = mline.replace(mlinePayloadsSection, " " + reorderedPayloads);
-        return section.replace(mline, newmline);
-    })
-        .join("");
-}
-function filterMidExtension(sdp) {
-    if (browserName$2 !== "firefox" || (browserVersion$1 && browserVersion$1 >= 63) || browserVersion$1 === 60) {
-        return sdp;
+    catch (ex) {
+        logger.warn("Failed to observe CPU pressure", ex);
     }
-    return (SDPUtils.splitLines(sdp.trim())
-        .filter((line) => {
-        if (!line.startsWith("a=extmap:")) {
-            return true;
-        }
-        const extmap = SDPUtils.parseExtmap(line);
-        return extmap.uri !== "urn:ietf:params:rtp-hdrext:sdes:mid";
-    })
-        .join("\r\n") + "\r\n");
+    setTimeout(collectStatsBound, interval);
+    return {
+        getUpdatedStats: () => {
+            return collectStatsBound(true);
+        },
+        stop: () => {
+            clearTimeout(state.nextTimeout);
+            cpuObserver === null || cpuObserver === void 0 ? void 0 : cpuObserver.stop();
+        },
+    };
 }
-function filterMsidSemantic(sdp) {
-    if (browserName$2 !== "firefox" && browserVersion$1 < 68) {
-        return sdp;
-    }
-    return (SDPUtils.splitLines(sdp.trim())
-        .map((line) => (line.startsWith("a=msid-semantic:") ? "a=msid-semantic: WMS *" : line))
-        .join("\r\n") + "\r\n");
+function subscribeStats(subscription, options = OPTIONS, state = STATE) {
+    state.subscriptions.push(subscription);
+    if (!state.currentMonitor)
+        state.currentMonitor = startStatsMonitor(state, options);
+    return {
+        stop() {
+            var _a;
+            state.subscriptions = state.subscriptions.filter((s) => s !== subscription);
+            if (!state.subscriptions.length) {
+                (_a = state.currentMonitor) === null || _a === void 0 ? void 0 : _a.stop();
+                state.currentMonitor = null;
+            }
+        },
+    };
 }
-function addExtMap(sdp, extmapUri, modifyAudio = false, modifyVideo = false) {
-    var _a, _b;
-    try {
-        const sdpObj = sdpTransform.parse(sdp);
-        if (((_a = sdpObj === null || sdpObj === void 0 ? void 0 : sdpObj.ext) === null || _a === void 0 ? void 0 : _a.length) && sdpObj.ext.length > 0) {
-            return sdp;
-        }
-        if ((sdpObj === null || sdpObj === void 0 ? void 0 : sdpObj.media.length) < 1)
-            return sdp;
-        const allHeaderExtensions = sdpObj === null || sdpObj === void 0 ? void 0 : sdpObj.media.flatMap((section) => section.ext || []);
-        const extmapId = ((_b = allHeaderExtensions.find((ext) => ext.uri === extmapUri)) === null || _b === void 0 ? void 0 : _b.value) ||
-            [...new Set([0, 15, ...allHeaderExtensions.map((ext) => ext.value)])]
-                .sort((a, b) => a - b)
-                .find((n, i, arr) => n + 1 !== arr[i + 1]) + 1;
-        sdpObj.media.forEach((mediaSection) => {
+
+const logger$7 = new Logger();
+class ReconnectManager extends EventEmitter {
+    constructor(socket) {
+        super();
+        this.reconnectThresholdInMs = 0;
+        this._socket = socket;
+        this._clients = {};
+        this._signalDisconnectTime = undefined;
+        this.rtcManager = undefined;
+        this.metrics = {
+            roomJoinedLate: 0,
+            pendingClientCanceled: 0,
+            evaluationFailed: 0,
+            roomJoined: 0,
+        };
+        socket.on("disconnect", () => {
+            this._signalDisconnectTime = Date.now();
+        });
+        socket.on(PROTOCOL_RESPONSES.ROOM_JOINED, (payload) => this._onRoomJoined(payload));
+        socket.on(PROTOCOL_RESPONSES.NEW_CLIENT, (payload) => this._onNewClient(payload));
+        socket.on(PROTOCOL_RESPONSES.CLIENT_LEFT, (payload) => this._onClientLeft(payload));
+        socket.on(PROTOCOL_EVENTS.PENDING_CLIENT_LEFT, (payload) => this._onPendingClientLeft(payload));
+        socket.on(PROTOCOL_RESPONSES.AUDIO_ENABLED, (payload) => this._onAudioEnabled(payload));
+        socket.on(PROTOCOL_RESPONSES.VIDEO_ENABLED, (payload) => this._onVideoEnabled(payload));
+        socket.on(PROTOCOL_RESPONSES.SCREENSHARE_STARTED, (payload) => this._onScreenshareChanged(payload, true));
+        socket.on(PROTOCOL_RESPONSES.SCREENSHARE_STOPPED, (payload) => this._onScreenshareChanged(payload, false));
+    }
+    _onRoomJoined(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if ((modifyAudio && mediaSection.type === "audio") || (modifyVideo && mediaSection.type === "video")) {
-                if (!((_a = mediaSection.ext) === null || _a === void 0 ? void 0 : _a.find((e) => e.uri === extmapUri))) {
-                    if (Array.isArray(mediaSection.ext)) {
-                        mediaSection["ext"].push({ value: extmapId, uri: extmapUri });
+            this.reconnectThresholdInMs = (payload.disconnectTimeout || 0) * 0.8;
+            if (payload === null || payload === void 0 ? void 0 : payload.error) {
+                this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
+                return;
+            }
+            if (!payload.selfId) {
+                this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
+                return;
+            }
+            const myDeviceId = (_a = payload.room.clients.find((c) => payload.selfId === c.id)) === null || _a === void 0 ? void 0 : _a.deviceId;
+            if (!myDeviceId) {
+                this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
+                return;
+            }
+            if (!this._signalDisconnectTime) {
+                this._resetClientState(payload);
+                payload.room.clients = payload.room.clients.filter((c) => !(c.deviceId === myDeviceId && c.isPendingToLeave));
+                this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
+                return;
+            }
+            const RECONNECT_THRESHOLD = payload.disconnectTimeout * 0.8;
+            const timeSinceDisconnect = Date.now() - this._signalDisconnectTime;
+            if (timeSinceDisconnect > RECONNECT_THRESHOLD) {
+                this._resetClientState(payload);
+                this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
+                this.metrics.roomJoinedLate++;
+                return;
+            }
+            payload.room.clients = payload.room.clients.filter((c) => !(c.deviceId === myDeviceId && c.isPendingToLeave));
+            const allStats = yield getUpdatedStats();
+            payload.room.clients.forEach((client) => {
+                var _a;
+                try {
+                    if (client.id === payload.selfId)
+                        return;
+                    if (!this._clients[client.id]) {
+                        this._addClientToState(client);
+                        return;
                     }
-                    else {
-                        mediaSection["ext"] = [{ value: extmapId, uri: extmapUri }];
+                    if (!((_a = this.rtcManager) === null || _a === void 0 ? void 0 : _a.hasClient(client.id))) {
+                        return;
+                    }
+                    if (this._hasClientStateChanged({
+                        clientId: client.id,
+                        webcam: client.isVideoEnabled,
+                        mic: client.isAudioEnabled,
+                        screenShare: client.streams.length > 1,
+                    })) {
+                        return;
+                    }
+                    if (this._wasClientSendingMedia(client.id)) {
+                        if (!this._isClientMediaActive(allStats, client.id)) {
+                            return;
+                        }
                     }
+                    client.mergeWithOldClientState = true;
                 }
-            }
+                catch (error) {
+                    logger$7.error("Failed to evaluate if we should merge client state %o", error);
+                    this.metrics.evaluationFailed++;
+                }
+            });
+            payload.room.clients.forEach((c) => {
+                if (c.isPendingToLeave) {
+                    this._onPendingClientLeft({ clientId: c.id });
+                }
+            });
+            this.metrics.roomJoined++;
+            this.emit(PROTOCOL_RESPONSES.ROOM_JOINED, payload);
         });
-        return sdpTransform.write(sdpObj);
-    }
-    catch (error) {
-        console.error("Error during addAbsCaptureTimeExtMap: ", error);
-    }
-    return sdp;
-}
-function addAbsCaptureTimeExtMap(sdp) {
-    const absCaptureTimeUri = "http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time";
-    return addExtMap(sdp, absCaptureTimeUri, true, true);
-}
-
-function setVideoBandwidthUsingSetParameters(pc, bandwidth, logger = console) {
-    const sender = pc.getSenders().find((s) => s.track && s.track.kind === "video");
-    if (!sender) {
-        return Promise.resolve();
-    }
-    const parameters = sender.getParameters();
-    if (parameters.encodings && parameters.encodings.length === 0) {
-        return Promise.resolve();
     }
-    if (!parameters.encodings) {
-        parameters.encodings = [{}];
+    _onClientLeft(payload) {
+        var _a;
+        const { clientId } = payload;
+        const client = this._clients[clientId];
+        if (client) {
+            clearTimeout(client.timeout);
+            delete this._clients[clientId];
+        }
+        (_a = this.rtcManager) === null || _a === void 0 ? void 0 : _a.disconnect(clientId, payload.eventClaim);
+        this.emit(PROTOCOL_RESPONSES.CLIENT_LEFT, payload);
     }
-    if (bandwidth === 0) {
-        delete parameters.encodings[0].maxBitrate;
+    _onPendingClientLeft(payload) {
+        const { clientId } = payload;
+        const client = this._clients[clientId];
+        if (!client) {
+            logger$7.warn(`client ${clientId} not found`);
+            return;
+        }
+        if (client.isPendingToLeave) {
+            return;
+        }
+        client.isPendingToLeave = true;
+        if (this._wasClientSendingMedia(clientId)) {
+            client.checkActiveMediaAttempts = 0;
+            this._abortIfNotActive(payload);
+        }
     }
-    else {
-        parameters.encodings[0].maxBitrate = bandwidth * 1000;
+    _onNewClient(payload) {
+        const { client: { id: clientId, deviceId }, } = payload;
+        const client = this._clients[clientId];
+        if (client && client.isPendingToLeave) {
+            clearTimeout(client.timeoutHandler);
+            client.isPendingToLeave = false;
+            this.metrics.pendingClientCanceled++;
+            return;
+        }
+        this._getPendingClientsByDeviceId(deviceId).forEach((client) => {
+            clearTimeout(client.timeoutHandler);
+            client.isPendingToLeave = undefined;
+            this.emit(PROTOCOL_RESPONSES.CLIENT_LEFT, { clientId: client.clientId });
+        });
+        this._addClientToState(payload.client);
+        this.emit(PROTOCOL_RESPONSES.NEW_CLIENT, payload);
     }
-    return sender.setParameters(parameters).catch((err) => {
-        logger.error("setParameters err: ", err);
-    });
-}
-
-var _a$4;
-const adapter$4 = (_a$4 = adapterRaw.default) !== null && _a$4 !== void 0 ? _a$4 : adapterRaw;
-const logger$7 = new Logger();
-class Session {
-    constructor({ clientId, bandwidth, peerConnectionConfig, deprioritizeH264Encoding, incrementAnalyticMetric, }) {
-        this.relayCandidateSeen = false;
-        this.serverReflexiveCandidateSeen = false;
-        this.publicHostCandidateSeen = false;
-        this.ipv6HostCandidateSeen = false;
-        this.ipv6HostCandidateTeredoSeen = false;
-        this.ipv6HostCandidate6to4Seen = false;
-        this.mdnsHostCandidateSeen = false;
-        this.pendingReplaceTrackActions = [];
-        this.peerConnectionConfig = peerConnectionConfig;
-        this.clientId = clientId;
-        this.pc = new RTCPeerConnection(this.peerConnectionConfig);
-        this.signalingState = this.pc.signalingState;
-        this.pc.addEventListener("signalingstatechange", () => {
-            if (this.signalingState === this.pc.signalingState) {
+    _abortIfNotActive(payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { clientId } = payload;
+            let client = this._clients[clientId];
+            if (!(client === null || client === void 0 ? void 0 : client.isPendingToLeave))
+                return;
+            client.checkActiveMediaAttempts++;
+            if (client.checkActiveMediaAttempts > 3) {
                 return;
             }
-            this.signalingState = this.pc.signalingState;
-            if (this.pc.signalingState === "stable") {
-                this.isOperationPending = false;
-                const action = this.pending.shift();
-                if (action) {
-                    action.apply();
-                }
+            const stillActive = yield this._checkIsActive(clientId);
+            if (stillActive) {
+                client.timeoutHandler = setTimeout(() => this._abortIfNotActive(payload), 500);
+                return;
+            }
+            client = this._clients[clientId];
+            if (client === null || client === void 0 ? void 0 : client.isPendingToLeave) {
+                clearTimeout(client.timeoutHandler);
+                delete this._clients[clientId];
+                this.emit(PROTOCOL_RESPONSES.CLIENT_LEFT, payload);
             }
         });
-        this.wasEverConnected = false;
-        this.connectionStatus = null;
-        this.bandwidth = bandwidth || 0;
-        this.pending = [];
-        this.isOperationPending = false;
-        this.streamIds = [];
-        this.streams = [];
-        this.earlyIceCandidates = [];
-        this.afterConnected = new Promise((resolve) => {
-            this.registerConnected = resolve;
-        });
-        this._deprioritizeH264Encoding = deprioritizeH264Encoding;
-        this._incrementAnalyticMetric = incrementAnalyticMetric;
     }
-    addStream(stream) {
-        this.streamIds.push(stream.id);
-        this.streams.push(stream);
-        stream.getAudioTracks().forEach((track) => {
-            this.pc.addTrack(track, stream);
-        });
-        stream.getVideoTracks().forEach((track) => {
-            this.pc.addTrack(track, stream);
+    _checkIsActive(clientId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allStats = yield getUpdatedStats();
+            return this._isClientMediaActive(allStats, clientId);
         });
     }
-    addTrack(track, stream) {
-        if (!stream) {
-            stream = this.streams[0];
+    _isClientMediaActive(stats, clientId) {
+        const clientStats = stats === null || stats === void 0 ? void 0 : stats[clientId];
+        let isActive = false;
+        if (clientStats) {
+            Object.entries(clientStats.tracks).forEach(([trackId, trackStats]) => {
+                if (trackId !== "probator")
+                    Object.values(trackStats.ssrcs).forEach((ssrcStats) => {
+                        if ((ssrcStats.bitrate || 0) > 0)
+                            isActive = true;
+                    });
+            });
         }
-        stream === null || stream === void 0 ? void 0 : stream.addTrack(track);
-        this.pc.addTrack(track, stream);
+        return isActive;
     }
-    removeTrack(track) {
-        const stream = this.streams[0];
-        stream.removeTrack(track);
-        const sender = this.pc.getSenders().find((sender) => sender.track === track);
-        if (sender) {
-            this.pc.removeTrack(sender);
-        }
+    _onAudioEnabled(payload) {
+        const { clientId, isAudioEnabled } = payload;
+        this._clients[clientId] = Object.assign(Object.assign({}, (this._clients[clientId] || {})), { isAudioEnabled });
     }
-    removeStream(stream) {
-        const streamIdIndex = this.streamIds.indexOf(stream.id);
-        if (streamIdIndex !== -1) {
-            this.streamIds.splice(streamIdIndex, 1);
+    _onVideoEnabled(payload) {
+        const { clientId, isVideoEnabled } = payload;
+        this._clients[clientId] = Object.assign(Object.assign({}, (this._clients[clientId] || {})), { isVideoEnabled });
+    }
+    _onScreenshareChanged(payload, action) {
+        const { clientId } = payload;
+        this._clients[clientId] = Object.assign(Object.assign({}, (this._clients[clientId] || {})), { isScreenshareEnabled: action });
+    }
+    _hasClientStateChanged({ clientId, webcam, mic, screenShare, }) {
+        const state = this._clients[clientId];
+        if (!state) {
+            throw new Error(`Client ${clientId} not found in ReconnectManager state`);
         }
-        const streamIndex = this.streams.indexOf(stream);
-        if (streamIndex !== -1) {
-            this.streams.splice(streamIndex, 1);
+        if (webcam !== state.isVideoEnabled) {
+            return true;
         }
-        stream.getTracks().forEach((track) => {
-            const sender = this.pc.getSenders().find((sender) => sender.track === track);
-            if (sender) {
-                this.pc.removeTrack(sender);
-            }
-        });
+        if (mic !== state.isAudioEnabled) {
+            return true;
+        }
+        if (screenShare !== state.isScreenshareEnabled) {
+            return true;
+        }
+        return false;
     }
-    _setRemoteDescription(desc) {
-        if (this._deprioritizeH264Encoding)
-            desc.sdp = deprioritizeH264(desc.sdp);
-        this.srdComplete = this.pc.setRemoteDescription(desc);
-        return this.srdComplete.then(() => {
-            this.earlyIceCandidates.forEach((candidate) => this.pc.addIceCandidate(candidate));
-            this.earlyIceCandidates = [];
-        });
+    _addClientToState(newClient) {
+        this._clients[newClient.id] = Object.assign(Object.assign({}, (this._clients[newClient.id] || {})), { isAudioEnabled: newClient.isAudioEnabled, isVideoEnabled: newClient.isVideoEnabled, isScreenshareEnabled: newClient.streams.length > 1, deviceId: newClient.deviceId, isPendingToLeave: newClient.isPendingToLeave, clientId: newClient.id });
     }
-    handleOffer(offer) {
-        if (!this.canModifyPeerConnection()) {
-            return new Promise((resolve) => {
-                this.pending.push(() => this.handleOffer(offer).then(resolve));
-            });
+    _wasClientSendingMedia(clientId) {
+        const client = this._clients[clientId];
+        if (!client) {
+            throw new Error(`Client ${clientId} not found in ReconnectManager state`);
         }
-        this.isOperationPending = true;
-        let sdp = offer.sdp;
-        sdp = filterMidExtension(sdp);
-        sdp = filterMsidSemantic(sdp);
-        const desc = { type: offer.type, sdp };
-        let answerToSignal;
-        return this._setRemoteDescription(desc)
-            .then(() => {
-            return this.pc.createAnswer();
-        })
-            .then((answer) => {
-            if (!answer.sdp) {
-                this._incrementAnalyticMetric("P2PCreateAnswerNoSDP");
-                rtcStats.sendEvent("P2PCreateAnswerNoSDP", {});
-                throw new Error("SDP undefined while creating answer");
-            }
-            else {
-                answerToSignal = {
-                    sdp: answer.sdp,
-                    sdpU: answer.sdp,
-                    type: answer.type,
-                };
-                return this.pc.setLocalDescription(answer);
-            }
-        })
-            .then(() => {
-            return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
-        })
-            .then(() => {
-            return answerToSignal;
-        });
+        return client.isAudioEnabled || client.isVideoEnabled || client.isScreenshareEnabled;
     }
-    handleAnswer(message) {
-        const sdp = filterMsidSemantic(message.sdp);
-        const desc = { type: message.type, sdp };
-        return this._setRemoteDescription(desc).then(() => {
-            return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
+    _getPendingClientsByDeviceId(deviceId) {
+        return Object.values(this._clients).filter((clientState) => {
+            return clientState.deviceId === deviceId && clientState.isPendingToLeave;
         });
     }
-    addIceCandidate(candidate) {
-        if (!this.srdComplete) {
-            this.earlyIceCandidates.push(candidate);
-            return;
-        }
-        this.srdComplete.then(() => {
-            var _a;
-            if (this.pc.signalingState === "closed") {
+    _resetClientState(payload) {
+        this._clients = {};
+        payload.room.clients.forEach((client) => {
+            if (client.id === payload.selfId) {
                 return;
             }
-            if (((_a = adapter$4.browserDetails) === null || _a === void 0 ? void 0 : _a.browser) === "safari" && candidate && candidate.candidate === "") {
-                return;
+            else {
+                this._addClientToState(client);
             }
-            this.pc.addIceCandidate(candidate).catch((e) => {
-                logger$7.warn("Failed to add ICE candidate ('%s'): %s", candidate ? candidate.candidate : null, e);
-            });
         });
     }
-    canModifyPeerConnection() {
-        return this.pc.signalingState === "stable" && !this.isOperationPending;
+}
+
+const DISCONNECT_DURATION_LIMIT_MS$1 = 60000;
+const SIGNAL_PING_INTERVAL = 2000;
+const SIGNAL_PING_MAX_LATENCY = 1000;
+class KeepAliveManager {
+    constructor(serverSocket) {
+        this.lastPingTimestamp = Date.now();
+        this._disconnectDurationLimitEnabled = false;
+        this.disconnectDurationLimitExceeded = false;
+        this.serverSocket = serverSocket;
+        this.serverSocket.on("connect", () => this.onConnect());
+        this.serverSocket.onEngineEvent("ping", () => this.onPing());
+        this.serverSocket.on("disconnect", () => this.onDisconnect());
+        this.serverSocket.onEngineEvent("reconnect_attempt", () => this.onReconnectAttempt());
     }
-    close() {
-        const pc = this.pc;
-        if (!pc) {
-            return;
-        }
-        pc.oniceconnectionstatechange = null;
-        pc.onicecandidate = null;
-        pc.ontrack = null;
-        try {
-            pc.close();
-        }
-        catch (e) {
-            logger$7.warn("failures during close of session", e);
-        }
+    enableDisconnectDurationLimit() {
+        this._disconnectDurationLimitEnabled = true;
     }
-    hasConnectedPeerConnection() {
-        return this.pc.connectionState === "connected";
+    pingHeartbeat() {
+        clearTimeout(this.pingTimer);
+        this.pingTimer = setTimeout(() => {
+            this.serverSocket._socket.io.engine.close();
+        }, SIGNAL_PING_INTERVAL + SIGNAL_PING_MAX_LATENCY);
+        this.lastPingTimestamp = Date.now();
     }
-    replaceTrack(oldTrack, newTrack) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger$7.info("replacetrack() [oldTrackId: %s, newTrackId: %s]", oldTrack === null || oldTrack === void 0 ? void 0 : oldTrack.id, newTrack.id);
-            if (newTrack.readyState === "ended") {
-                throw new Error(`refusing to use ended track with id: ${newTrack.id}, kind: ${newTrack.kind}`);
+    onConnect() {
+        this.pingHeartbeat();
+    }
+    onPing() {
+        this.pingHeartbeat();
+    }
+    onDisconnect() {
+        clearTimeout(this.pingTimer);
+    }
+    onReconnectAttempt() {
+        if (this._disconnectDurationLimitEnabled) {
+            this.disconnectDurationLimitExceeded = Boolean(Date.now() - this.lastPingTimestamp > DISCONNECT_DURATION_LIMIT_MS$1);
+            if (this.disconnectDurationLimitExceeded) {
+                this.serverSocket.disconnect();
             }
-            const pc = this.pc;
-            if (oldTrack) {
-                const sender = pc.getSenders().find((s) => { var _a; return ((_a = s.track) === null || _a === void 0 ? void 0 : _a.id) === oldTrack.id; });
-                if (sender) {
-                    return yield sender.replaceTrack(newTrack);
+        }
+    }
+}
+
+var _a$3;
+const adapter$3 = (_a$3 = adapterRaw.default) !== null && _a$3 !== void 0 ? _a$3 : adapterRaw;
+const DEFAULT_SOCKET_PATH = "/protocol/socket.io/v4";
+const NOOP_KEEPALIVE_INTERVAL = 2000;
+const DISCONNECT_DURATION_LIMIT_MS = 60000;
+class ServerSocket {
+    constructor(hostName, optionsOverrides, glitchFree = false, disconnectDurationLimitOn = false, serverSideDisconnectDurationLimitOn = false) {
+        this._wasConnectedUsingWebsocket = false;
+        this._disconnectDurationLimitOn = disconnectDurationLimitOn && !serverSideDisconnectDurationLimitOn;
+        this._serverSideDisconnectDurationLimitOn = serverSideDisconnectDurationLimitOn;
+        this._disconnectDurationLimitExceeded = false;
+        this._reconnectManager = null;
+        this._socket = io(hostName, Object.assign({ path: DEFAULT_SOCKET_PATH, randomizationFactor: 0.5, reconnectionDelay: 250, reconnectionDelayMax: 5000, timeout: 5000, transports: ["websocket"], withCredentials: true }, optionsOverrides));
+        this._disconnectDurationLimitEnabled = false;
+        this.joinRoomFinished = false;
+        this._socket.io.on("reconnect", () => {
+            if (this._disconnectDurationLimitOn &&
+                this._didExceedDisconnectDurationLimit(this._disconnectDurationLimitLatestTimestamp)) {
+                this._socket.close();
+                this._disconnectDurationLimitExceeded = true;
+            }
+            this._socket.sendBuffer = [];
+        });
+        this._socket.io.on("reconnect_attempt", () => {
+            var _a;
+            if (this._disconnectDurationLimitOn &&
+                this._didExceedDisconnectDurationLimit(this._disconnectDurationLimitLatestTimestamp)) {
+                this._socket.close();
+                this._disconnectDurationLimitExceeded = true;
+            }
+            if (this._wasConnectedUsingWebsocket) {
+                this._socket.io.opts.transports = ["websocket"];
+                if (((_a = adapter$3.browserDetails) === null || _a === void 0 ? void 0 : _a.browser) !== "safari") {
+                    delete this._wasConnectedUsingWebsocket;
                 }
             }
-            const sender = pc.getSenders().find((s) => {
-                const track = s.track;
-                return (track === null || track === void 0 ? void 0 : track.kind) === newTrack.kind && !trackAnnotations(track).fromGetDisplayMedia;
-            });
-            if (sender) {
-                return yield sender.replaceTrack(newTrack);
+            else {
+                this._socket.io.opts.transports = ["websocket", "polling"];
             }
-            let stream = this.streams.find((s) => s.getTracks().find((t) => t.id === newTrack.id));
-            if (!stream) {
-                rtcStats.sendEvent("P2PReplaceTrackNewTrackNotInStream", {
-                    oldTrackId: oldTrack === null || oldTrack === void 0 ? void 0 : oldTrack.id,
-                    oldTrackKind: oldTrack === null || oldTrack === void 0 ? void 0 : oldTrack.kind,
-                    oldTrackIsEffect: oldTrack && trackAnnotations(oldTrack).isEffectTrack,
-                    newTrackId: newTrack.id,
-                    newTrackKind: newTrack.kind,
-                    newTrackIsEffect: trackAnnotations(newTrack).isEffectTrack,
-                });
-                this._incrementAnalyticMetric("P2PReplaceTrackNewTrackNotInStream");
+        });
+        if (glitchFree)
+            this._reconnectManager = new ReconnectManager(this._socket);
+        if (this._serverSideDisconnectDurationLimitOn)
+            this._keepAliveManager = new KeepAliveManager(this);
+        this._socket.on("room_joined", (payload) => {
+            if (!("error" in payload)) {
+                this.joinRoomFinished = true;
             }
-            stream = this.streams[0];
-            if (!stream) {
-                rtcStats.sendEvent("P2PReplaceTrackNoStream", {});
-                this._incrementAnalyticMetric("P2PReplaceTrackNoStream");
-                throw new Error("replaceTrack: No stream?");
+        });
+        this._socket.on("connect", () => {
+            const transport = this.getTransport();
+            if (transport === "websocket") {
+                this._wasConnectedUsingWebsocket = true;
+                if (this._serverSideDisconnectDurationLimitOn)
+                    return;
+                if (!this.noopKeepaliveInterval) {
+                    let disconnectDurationLimitTimestampCandidate = Date.now();
+                    this.noopKeepaliveInterval = setInterval(() => {
+                        try {
+                            if (this._socket.connected) {
+                                if (this._disconnectDurationLimitOn &&
+                                    !this._didExceedDisconnectDurationLimit(disconnectDurationLimitTimestampCandidate)) {
+                                    this._disconnectDurationLimitLatestTimestamp =
+                                        disconnectDurationLimitTimestampCandidate;
+                                    disconnectDurationLimitTimestampCandidate = Date.now();
+                                }
+                                this._socket.io.engine.sendPacket("noop");
+                            }
+                        }
+                        catch (ex) { }
+                    }, NOOP_KEEPALIVE_INTERVAL);
+                }
+            }
+        });
+        this._socket.on("disconnect", () => {
+            this.joinRoomFinished = false;
+            this.disconnectTimestamp = Date.now();
+            if (this._serverSideDisconnectDurationLimitOn)
+                return;
+            if (this._disconnectDurationLimitOn &&
+                this._didExceedDisconnectDurationLimit(this._disconnectDurationLimitLatestTimestamp)) {
+                this._socket.close();
+                this._disconnectDurationLimitExceeded = true;
+            }
+            if (this.noopKeepaliveInterval) {
+                clearInterval(this.noopKeepaliveInterval);
+                this.noopKeepaliveInterval = null;
             }
-            pc.addTrack(newTrack, stream);
         });
     }
-    changeBandwidth(bandwidth) {
+    _didExceedDisconnectDurationLimit(timestamp) {
+        if (!timestamp || !this._disconnectDurationLimitOn || !this._disconnectDurationLimitEnabled)
+            return false;
+        const disconnectedDuration = Date.now() - timestamp;
+        if (disconnectedDuration > DISCONNECT_DURATION_LIMIT_MS) {
+            return true;
+        }
+        return false;
+    }
+    get disconnectDurationLimitExceeded() {
+        var _a, _b;
+        if (this._serverSideDisconnectDurationLimitOn) {
+            return (_b = (_a = this._keepAliveManager) === null || _a === void 0 ? void 0 : _a.disconnectDurationLimitExceeded) !== null && _b !== void 0 ? _b : false;
+        }
+        else if (this._disconnectDurationLimitOn) {
+            return this._disconnectDurationLimitExceeded;
+        }
+        return false;
+    }
+    enableDisconnectDurationLimit() {
         var _a;
-        if (bandwidth === this.bandwidth) {
-            return;
+        if (this._serverSideDisconnectDurationLimitOn) {
+            (_a = this._keepAliveManager) === null || _a === void 0 ? void 0 : _a.enableDisconnectDurationLimit();
         }
-        if (!this.canModifyPeerConnection()) {
-            this.pending.push(() => this.changeBandwidth(bandwidth));
-            return;
+        else if (this._disconnectDurationLimitOn) {
+            this._disconnectDurationLimitEnabled = true;
         }
-        this.bandwidth = bandwidth;
-        if (((_a = this.pc.localDescription) === null || _a === void 0 ? void 0 : _a.type) === "") {
-            this._incrementAnalyticMetric("P2PChangeBandwidthEmptySDPType");
-            return;
+    }
+    setRtcManager(rtcManager) {
+        if (this._reconnectManager) {
+            this._reconnectManager.rtcManager = rtcManager;
         }
-        if (!this.pc.localDescription) {
+    }
+    connect() {
+        if (this.isConnected() || this.isConnecting()) {
             return;
         }
-        setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
+        this._socket.open();
     }
-    setAudioOnly(enable, excludedTrackIds = []) {
+    disconnect() {
+        this._socket.disconnect();
+    }
+    emit(eventName, ...args) {
+        this._socket.emit.apply(this._socket, arguments);
+    }
+    getTransport() {
+        var _a, _b, _c, _d;
+        return (_d = (_c = (_b = (_a = this._socket) === null || _a === void 0 ? void 0 : _a.io) === null || _b === void 0 ? void 0 : _b.engine) === null || _c === void 0 ? void 0 : _c.transport) === null || _d === void 0 ? void 0 : _d.name;
+    }
+    getManager() {
+        return this._socket.io;
+    }
+    isConnecting() {
+        return this._socket && this._socket.connecting;
+    }
+    isConnected() {
+        return this._socket && this._socket.connected;
+    }
+    on(eventName, handler) {
+        const relayableEvents = [
+            PROTOCOL_RESPONSES.ROOM_JOINED,
+            PROTOCOL_RESPONSES.CLIENT_LEFT,
+            PROTOCOL_RESPONSES.NEW_CLIENT,
+        ];
+        if (this._reconnectManager && relayableEvents.includes(eventName)) {
+            return this._interceptEvent(eventName, handler);
+        }
+        this._socket.on(eventName, handler);
+        return () => {
+            this._socket.off(eventName, handler);
+        };
+    }
+    onEngineEvent(eventName, handler) {
         var _a;
-        (_a = this.pc) === null || _a === void 0 ? void 0 : _a.getTransceivers().filter((videoTransceiver) => {
-            var _a, _b, _c, _d, _e, _f;
-            return (videoTransceiver === null || videoTransceiver === void 0 ? void 0 : videoTransceiver.direction) !== "recvonly" &&
-                ((_b = (_a = videoTransceiver === null || videoTransceiver === void 0 ? void 0 : videoTransceiver.receiver) === null || _a === void 0 ? void 0 : _a.track) === null || _b === void 0 ? void 0 : _b.kind) === "video" &&
-                !excludedTrackIds.includes((_d = (_c = videoTransceiver === null || videoTransceiver === void 0 ? void 0 : videoTransceiver.receiver) === null || _c === void 0 ? void 0 : _c.track) === null || _d === void 0 ? void 0 : _d.id) &&
-                !excludedTrackIds.includes((_f = (_e = videoTransceiver === null || videoTransceiver === void 0 ? void 0 : videoTransceiver.sender) === null || _e === void 0 ? void 0 : _e.track) === null || _f === void 0 ? void 0 : _f.id);
-        }).forEach((videoTransceiver) => {
-            videoTransceiver.direction = enable ? "sendonly" : "sendrecv";
-        });
+        (_a = this._socket.io) === null || _a === void 0 ? void 0 : _a.on(eventName, handler);
+        return () => {
+            var _a;
+            (_a = this._socket.io) === null || _a === void 0 ? void 0 : _a.off(eventName, handler);
+        };
+    }
+    once(eventName, handler) {
+        this._socket.once(eventName, handler);
+    }
+    off(eventName, handler) {
+        this._socket.off(eventName, handler);
+    }
+    _interceptEvent(eventName, handler) {
+        if (this._reconnectManager) {
+            this._reconnectManager.on(eventName, handler);
+        }
+        return () => {
+            if (this._reconnectManager)
+                this._reconnectManager.removeListener(eventName, handler);
+        };
+    }
+    getGlitchFreeMetrics() {
+        var _a;
+        return (_a = this._reconnectManager) === null || _a === void 0 ? void 0 : _a.metrics;
+    }
+    getReconnectThreshold() {
+        var _a;
+        return (_a = this._reconnectManager) === null || _a === void 0 ? void 0 : _a.reconnectThresholdInMs;
     }
 }
 
-const MEDIA_JITTER_BUFFER_TARGET = 400;
-
-var _a$3;
-const adapter$3 = (_a$3 = adapterRaw.default) !== null && _a$3 !== void 0 ? _a$3 : adapterRaw;
-function detectMicrophoneNotWorking(pc) {
-    var _a, _b;
-    if (((_a = adapter$3.browserDetails) === null || _a === void 0 ? void 0 : _a.browser) !== "chrome" ||
-        ((_b = adapter$3.browserDetails) === null || _b === void 0 ? void 0 : _b.browser) < 58 ||
-        pc.signalingState === "closed") {
-        return Promise.resolve("");
+const maybeTurnOnly = (iceConfig, features) => {
+    if (!features.useOnlyTURN) {
+        return;
     }
-    const sendingAudio = pc.getSenders().some((sender) => { var _a; return ((_a = sender.track) === null || _a === void 0 ? void 0 : _a.kind) === "audio"; });
-    const receivingAudio = pc.getReceivers().some((receiver) => { var _a; return ((_a = receiver.track) === null || _a === void 0 ? void 0 : _a.kind) === "audio"; });
-    return pc.getStats(null).then((result) => {
-        let microphoneFailed = "";
-        result.forEach((report) => {
-            if (report.type === "outbound-rtp" &&
-                (report.kind === "audio" || report.mediaType === "audio") &&
-                sendingAudio) {
-                if (report.bytesSent === 0) {
-                    microphoneFailed = "outbound";
-                }
-            }
-            else if (report.type === "inbound-rtp" &&
-                (report.kind === "audio" || report.mediaType === "audio") &&
-                receivingAudio) {
-                if (report.bytesReceived === 0) {
-                    microphoneFailed = "inbound";
-                }
+    iceConfig.iceTransportPolicy = "relay";
+    const filter = {
+        onlyudp: /^turn:.*transport=udp$/,
+        onlytcp: /^turn:.*transport=tcp$/,
+        onlytls: /^turns:.*transport=tcp$/,
+    }[features.useOnlyTURN];
+    if (filter) {
+        iceConfig.iceServers = iceConfig.iceServers.filter((entry) => {
+            if (entry.url && entry.url.match(filter))
+                return entry;
+            if (entry.urls) {
+                entry.urls = (entry.urls.some ? entry.urls : [entry.urls]).filter((url) => url.match(filter));
+                if (entry.urls.length > 0)
+                    return entry;
             }
         });
-        return microphoneFailed;
-    });
-}
-
-const EVENTS = {
-    CLIENT_CONNECTION_STATUS_CHANGED: "client_connection_status_changed",
-    STREAM_ADDED: "stream_added",
-    RTC_MANAGER_CREATED: "rtc_manager_created",
-    RTC_MANAGER_DESTROYED: "rtc_manager_destroyed",
-    LOCAL_STREAM_TRACK_ADDED: "local_stream_track_added",
-    LOCAL_STREAM_TRACK_REMOVED: "local_stream_track_removed",
-    REMOTE_STREAM_TRACK_ADDED: "remote_stream_track_added",
-    REMOTE_STREAM_TRACK_REMOVED: "remote_stream_track_removed",
+    }
 };
-const TYPES = {
-    CONNECTING: "connecting",
-    CONNECTION_FAILED: "connection_failed",
-    CONNECTION_SUCCESSFUL: "connection_successful",
-    CONNECTION_DISCONNECTED: "connection_disconnected",
+const external_stun_servers = (iceConfig, features) => {
+    if (features.addGoogleStunServers) {
+        iceConfig.iceServers = [
+            { urls: "stun:stun.l.google.com:19302" },
+            { urls: "stun:stun2.l.google.com:19302" },
+            ...iceConfig.iceServers,
+        ];
+    }
+    if (features.addCloudflareStunServers) {
+        iceConfig.iceServers = [
+            { urls: "stun:stun.cloudflare.com:3478" },
+            { urls: "stun:stun.cloudflare.com:53" },
+            ...iceConfig.iceServers,
+        ];
+    }
 };
-
-var rtcManagerEvents = {
-    CAMERA_NOT_WORKING: "camera_not_working",
-    CONNECTION_BLOCKED_BY_NETWORK: "connection_blocked_by_network",
-    MICROPHONE_NOT_WORKING: "microphone_not_working",
-    MICROPHONE_STOPPED_WORKING: "microphone_stopped_working",
-    CAMERA_STOPPED_WORKING: "camera_stopped_working",
-    NEW_PC: "new_pc",
-    SFU_CONNECTION_OPEN: "sfu_connection_open",
-    SFU_CONNECTION_CLOSED: "sfu_connection_closed",
-    SFU_CONNECTION_INFO: "sfu_connection_info",
-    COLOCATION_SPEAKER: "colocation_speaker",
-    DOMINANT_SPEAKER: "dominant_speaker",
+const turnServerOverride = (iceServers, overrideHost) => {
+    if (overrideHost && iceServers) {
+        const host = overrideHost;
+        const port = host.indexOf(":") > 0 ? "" : ":443";
+        const override = ":" + host + port;
+        return iceServers.map((original) => {
+            const entry = Object.assign({}, original);
+            if (entry.url) {
+                entry.url = entry.url.replace(/:[^?]*/, override);
+            }
+            if (entry.urls) {
+                entry.urls = entry.urls.map((url) => url.replace(/:[^?]*/, override));
+            }
+            return entry;
+        });
+    }
+    else {
+        return iceServers;
+    }
 };
 
+const defaultSubdomainPattern = /^(?:([^.]+)[.])?((:?[^.]+[.]){1,}[^.]+)$/;
+const localstackPattern = /^(?:([^.]+)-)?(ip-[^.]*[.](?:hereby[.]dev|rfc1918[.]disappear[.]at)(?::\d+|))$/;
+const localhostPattern = /^(?:([^.]+)[.])?(localhost:?\d*)/;
+const serverPattern = /^(?:([^.]+)[.])?(server:?\d*)/;
+const ipv4Pattern = /^(?:([^.]+)[.])?((\d+[.]){3}:?\d*)$/;
+const subdomainPatterns = [
+    { pattern: serverPattern, separator: "." },
+    { pattern: localhostPattern, separator: "." },
+    { pattern: ipv4Pattern, separator: "." },
+    { pattern: localstackPattern, separator: "-" },
+    { pattern: defaultSubdomainPattern, separator: "." },
+];
+function fromLocation({ host = "whereby.com", protocol = "https:" } = {}) {
+    let subdomain = "";
+    let domain = host;
+    let subdomainSeparator = ".";
+    for (const { separator, pattern } of subdomainPatterns) {
+        const match = pattern.exec(host);
+        if (match) {
+            subdomain = match[1] || "";
+            domain = match[2];
+            subdomainSeparator = separator;
+            break;
+        }
+    }
+    const organizationDomain = !subdomain ? domain : `${subdomain}${subdomainSeparator}${domain}`;
+    return {
+        domain,
+        domainWithSeparator: `${subdomainSeparator}${domain}`,
+        organizationDomain,
+        organization: `${protocol}//${organizationDomain}`,
+        service: `${protocol}//${domain}`,
+        subdomain,
+    };
+}
+fromLocation(window && window.location);
+
 var _a$2, _b$1;
 const adapter$2 = (_a$2 = adapterRaw.default) !== null && _a$2 !== void 0 ? _a$2 : adapterRaw;
 const isSafari = ((_b$1 = adapter$2.browserDetails) === null || _b$1 === void 0 ? void 0 : _b$1.browser) === "safari";
@@ -2642,17 +2525,12 @@ class P2pRtcManager {
             numPcSldFailure: 0,
             numPcOnAnswerFailure: 0,
             numPcOnOfferFailure: 0,
-            P2PChangeBandwidthEmptySDPType: 0,
             P2PReplaceTrackNoStream: 0,
             P2PReplaceTrackNewTrackNotInStream: 0,
             P2POnTrackNoStream: 0,
-            P2PSetCodecPreferenceError: 0,
-            P2PCreateOfferNoSDP: 0,
-            P2PCreateAnswerNoSDP: 0,
             P2PMicNotWorking: 0,
             P2PLocalNetworkFailed: 0,
             P2PRelayedIceCandidate: 0,
-            P2PStartScreenshareNoStream: 0,
         };
     }
     numberOfPeerconnections() {
@@ -3193,10 +3071,6 @@ class P2pRtcManager {
                         if (this._localScreenshareStream) {
                             session.addStream(this._localScreenshareStream);
                         }
-                        else {
-                            this.analytics.P2PStartScreenshareNoStream++;
-                            rtcStats.sendEvent("P2PStartScreenshareNoStream", {});
-                        }
                     });
                 });
             }
@@ -3404,8 +3278,6 @@ class P2pRtcManager {
             .createOffer(constraints || this.offerOptions)
             .then((offer) => {
             if (!offer.sdp) {
-                this.analytics.P2PCreateOfferNoSDP++;
-                rtcStats.sendEvent("P2PCreateOfferNoSDP", {});
                 throw new Error("SDP undefined while creating offer");
             }
             if (rtpAbsCaptureTimeOn)
@@ -3414,7 +3286,6 @@ class P2pRtcManager {
                 offer.sdp = setCodecPreferenceSDP({
                     sdp: offer.sdp,
                     redOn,
-                    incrementAnalyticMetric: (metric) => this.analytics[metric]++,
                 });
             }
             if (cleanSdpOn)
@@ -5995,23 +5866,6 @@ const getRoomMode = () => {
     return roomMode;
 };
 
-const packetLossAnalyser = new PacketLossAnalyser();
-const periodicPacketLossDetector = {
-    id: "periodic-packet-loss",
-    enabled: ({ client, hasLiveTrack, ssrc0 }) => {
-        return (!!client.isLocalClient &&
-            hasLiveTrack &&
-            !!(ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.ssrc) &&
-            (ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.direction) === "out" &&
-            ((ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.bitrate) || 0) > 0);
-    },
-    check: ({ ssrc0 }) => {
-        if (!ssrc0 || !ssrc0.ssrc)
-            return false;
-        packetLossAnalyser.addPacketLossMeasurement(ssrc0.ssrc, ssrc0.fractionLost || 0, Date.now());
-        return packetLossAnalyser.hasPeriodicPacketLoss(ssrc0.ssrc, Date.now());
-    },
-};
 const badNetworkIssueDetector = {
     id: "bad-network",
     enabled: ({ hasLiveTrack, ssrcs }) => hasLiveTrack && ssrcs.length > 0,
@@ -6199,7 +6053,6 @@ const issueDetectors = [
         check: ({ ssrc0 }) => ((ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.fps) || 0) < 10,
     },
     badNetworkIssueDetector,
-    periodicPacketLossDetector,
     {
         id: "cpu-pressure-serious",
         global: true,