@whereby.com/media 2.0.0 → 2.1.1

package/dist/index.cjs

@@ -1,16 +1,16 @@
 'use strict';
 
+var mediasoupClient = require('mediasoup-client');
 var adapterRaw = require('webrtc-adapter');
+var EventEmitter = require('events');
 var rtcstats = require('rtcstats');
 var uuid = require('uuid');
+var socket_ioClient = require('socket.io-client');
 var SDPUtils = require('sdp');
 var sdpTransform = require('sdp-transform');
 var ipAddress = require('ip-address');
 var checkIp = require('check-ip');
 var validate = require('uuid-validate');
-var mediasoupClient = require('mediasoup-client');
-var EventEmitter = require('events');
-var socket_ioClient = require('socket.io-client');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -31,7 +31,164 @@ function _interopNamespaceDefault(e) {
 
 var sdpTransform__namespace = /*#__PURE__*/_interopNamespaceDefault(sdpTransform);
 
-const debugOn = process.env.NODE_ENV === "development" || new URLSearchParams(window.location.search).has("debug");
+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);
+};
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    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 mediasoupClient.Device({ handlerName: "Safari12" });
+    }
+    let handlerName = (yield mediasoupClient.detectDeviceAsync()) ||
+        (/applecoremedia|applewebkit|safari/i.test(navigator.userAgent) ? "Safari12" : undefined);
+    if (/iphone|ipad/i.test(navigator.userAgent)) {
+        handlerName = "Safari12";
+    }
+    return new mediasoupClient.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;
@@ -86,209 +243,195 @@ class Logger {
     }
 }
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+const AUDIO_SETTINGS = {
+    codecOptions: {
+        opusDtx: true,
+        opusFec: true,
+    },
+    encodings: [{ dtx: true }],
 };
-
-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: uuid.v4(),
-    connectionNumber: 0,
+const VIDEO_SETTINGS_HD = {
+    codecOptions: {
+        videoGoogleStartBitrate: 500,
+    },
+    encodings: [
+        { scaleResolutionDownBy: 4, maxBitrate: 150000 },
+        { scaleResolutionDownBy: 2, maxBitrate: 500000 },
+        { scaleResolutionDownBy: 1, maxBitrate: 1000000 },
+    ],
 };
-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,
-        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;
-            }
-            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;
-            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 server = rtcStatsConnection(process.env.RTCSTATS_URL || "wss://rtcstats.srv.whereby.com");
-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,
-        });
+const VIDEO_SETTINGS_SD = {
+    codecOptions: {
+        videoGoogleStartBitrate: 500,
     },
-    sendAudioMuted: (muted) => {
-        rtcStats.sendEvent("audio_muted", { muted });
+    encodings: [
+        { scaleResolutionDownBy: 2, maxBitrate: 150000 },
+        { scaleResolutionDownBy: 1, maxBitrate: 500000 },
+    ],
+};
+const VIDEO_SETTINGS_VP9 = {
+    codecOptions: {
+        videoGoogleStartBitrate: 500,
     },
-    sendVideoMuted: (muted) => {
-        rtcStats.sendEvent("video_muted", { muted });
+    encodings: [{ scalabilityMode: "L3T2", maxBitrate: 1000000 }],
+};
+const VIDEO_SETTINGS_VP9_LOW_BANDWIDTH = {
+    codecOptions: {
+        videoGoogleStartBitrate: 500,
     },
-    server,
+    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, isSomeoneAlreadyPresenting = false) => {
+    const { lowDataModeEnabled, simulcastScreenshareOn, vp9On } = features;
+    if (kind === "audio") {
+        return AUDIO_SETTINGS;
+    }
+    const isChrome = adapterRaw.browserDetails.browser === "chrome";
+    const isVp9Available = isChrome && vp9On;
+    if (isScreenShare) {
+        return getScreenShareMediaSettings({
+            isSomeoneAlreadyPresenting,
+            simulcastScreenshareOn,
+        });
+    }
+    else {
+        return getCameraMediaSettings({
+            lowBandwidth: lowDataModeEnabled,
+            isVp9Available,
+        });
+    }
+};
+const getCameraMediaSettings = ({ lowBandwidth, isVp9Available, }) => {
+    if (lowBandwidth) {
+        if (isVp9Available) {
+            return VIDEO_SETTINGS_VP9_LOW_BANDWIDTH;
+        }
+        return VIDEO_SETTINGS_SD;
+    }
+    if (isVp9Available) {
+        return VIDEO_SETTINGS_VP9;
+    }
+    return VIDEO_SETTINGS_HD;
+};
+const getScreenShareMediaSettings = ({ isSomeoneAlreadyPresenting, simulcastScreenshareOn, }) => {
+    if (isSomeoneAlreadyPresenting) {
+        return ADDITIONAL_SCREEN_SHARE_SETTINGS;
+    }
+    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) => {
+    const { vp9On, h264On } = features;
+    const isChrome = adapterRaw.browserDetails.browser === "chrome";
+    if (!(routerRtpCapabilities === null || routerRtpCapabilities === void 0 ? void 0 : routerRtpCapabilities.codecs)) {
+        return routerRtpCapabilities;
+    }
+    if (vp9On && isChrome) {
+        const sorted = prioritizeRouterRtpCapabilitiesCodecs(routerRtpCapabilities.codecs, PrioritizableCodec.VP9);
+        return Object.assign(Object.assign({}, routerRtpCapabilities), { codecs: sorted });
+    }
+    else if (h264On) {
+        const sorted = prioritizeRouterRtpCapabilitiesCodecs(routerRtpCapabilities.codecs, PrioritizableCodec.H264);
+        return Object.assign(Object.assign({}, routerRtpCapabilities), { codecs: sorted });
+    }
+    return routerRtpCapabilities;
 };
+function prioritizeRouterRtpCapabilitiesCodecs(codecs, preferredCodec) {
+    const preferredCodecEntry = codecs.find(({ mimeType }) => mimeType.toLowerCase() === preferredCodec);
+    if (!preferredCodecEntry) {
+        return codecs;
+    }
+    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");
+    }
+    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* () {
+        const codecPowerEfficiencyEntries = yield Promise.all(codecs.map(({ mimeType }) => getIsCodecDecodingPowerEfficient(mimeType).then((val) => [mimeType, val])));
+        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);
@@ -307,7 +450,7 @@ function captureCandidatePairInfoMetrics(cpMetrics, currentCptats, prevCptats, t
     const local = report.get(currentCptats.localCandidateId);
     cpMetrics.usingTurn = false;
     if (local) {
-        if (/relay/i.test(local.candidateType || '')) {
+        if (/relay/i.test(local.candidateType || "")) {
             cpMetrics.usingTurn = true;
             cpMetrics.turnProtocol = local.relayProtocol;
         }
@@ -464,6 +607,179 @@ function captureVideoSsrcMetrics(ssrcMetrics, currentSsrcStats, prevSsrcStats, t
     }
 }
 
+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: uuid.v4(),
+    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,
+        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;
+            }
+            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;
+            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,
+        });
+    },
+    sendAudioMuted: (muted) => {
+        rtcStats.sendEvent("audio_muted", { muted });
+    },
+    sendVideoMuted: (muted) => {
+        rtcStats.sendEvent("video_muted", { muted });
+    },
+    server,
+};
+
 let peerConnections = [];
 let peerConnectionCounter = 0;
 const peerConnectionData = new WeakMap();
@@ -492,10 +808,10 @@ 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 pcDataByPc = new WeakMap();
+const PC_DATA_BY_PC = new WeakMap();
 let numMissingTrackSsrcLookups = 0;
 let numFailedTrackSsrcLookups = 0;
-const getPeerConnectionsWithStatsReports = () => Promise.all(getCurrentPeerConnections().map((pc) => __awaiter(void 0, void 0, void 0, function* () {
+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: {} };
@@ -564,7 +880,7 @@ const getPeerConnectionsWithStatsReports = () => Promise.all(getCurrentPeerConne
 const getOrCreateSsrcMetricsContainer = (statsByView, time, pcIndex, clientId, trackId, ssrc) => {
     let viewStats = statsByView[clientId];
     if (!viewStats) {
-        viewStats = { tracks: {}, startTime: time, updated: time };
+        viewStats = { candidatePairs: {}, tracks: {}, startTime: time, updated: time };
         statsByView[clientId] = viewStats;
     }
     viewStats.updated = time;
@@ -588,7 +904,7 @@ const getOrCreateSsrcMetricsContainer = (statsByView, time, pcIndex, clientId, t
 };
 const removeNonUpdatedStats = (statsByView, time) => {
     Object.entries(statsByView).forEach(([viewId, viewStats]) => {
-        if (viewStats.updated < time) {
+        if (viewStats.updated !== undefined && viewStats.updated < time) {
             delete statsByView[viewId];
         }
         else {
@@ -607,12 +923,21 @@ const removeNonUpdatedStats = (statsByView, time) => {
         }
     });
 };
+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) || { id: "unknown" };
+            const defaultClient = clients.find((c) => c.isLocalClient && !c.isPresentation) || DEFAULT_CLIENT;
             let defaultViewStats = state.statsByView[defaultClient.id];
             if (!defaultViewStats) {
                 defaultViewStats = { tracks: {}, candidatePairs: {}, pressure: null };
@@ -630,6 +955,9 @@ function collectStats(state_1, _a, immediate_1) {
             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);
@@ -637,7 +965,7 @@ function collectStats(state_1, _a, immediate_1) {
                 pcData.previousSSRCs = pcData.currentSSRCs || {};
                 pcData.currentSSRCs = {};
                 report.forEach((currentRtcStats) => {
-                    var _a, _b, _c;
+                    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;
@@ -651,7 +979,7 @@ function collectStats(state_1, _a, immediate_1) {
                         cpMetrics.lastRtcStatsTime = state.lastUpdateTime;
                     }
                     if (currentRtcStats.type === "inbound-rtp" || currentRtcStats.type === "outbound-rtp") {
-                        const kind = currentRtcStats.mediaType || currentRtcStats.kind;
+                        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);
@@ -663,12 +991,13 @@ function collectStats(state_1, _a, immediate_1) {
                             }
                         }
                         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] &&
-                            ((_c = client[kind].track) === null || _c === void 0 ? void 0 : _c.id) &&
-                            client[kind].track.id !== pcData.ssrcToTrackId[ssrc]) {
-                            trackId = client[kind].track.id;
-                            pcData.ssrcToTrackId[ssrc] = client[kind].track.id;
+                            (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) {
@@ -829,8 +1158,7 @@ function startStatsMonitor(state, { interval, logger }) {
         },
         stop: () => {
             clearTimeout(state.nextTimeout);
-            if (cpuObserver)
-                cpuObserver.stop();
+            cpuObserver === null || cpuObserver === void 0 ? void 0 : cpuObserver.stop();
         },
     };
 }
@@ -850,1598 +1178,1391 @@ function subscribeStats(subscription, options = OPTIONS, state = STATE) {
     };
 }
 
-var _a$6;
-const adapter$6 = (_a$6 = adapterRaw.default) !== null && _a$6 !== void 0 ? _a$6 : adapterRaw;
+const PROTOCOL_REQUESTS = {
+    BLOCK_CLIENT: "block_client",
+    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",
+};
+const PROTOCOL_ERRORS = {
+    CANNOT_INVITE_YOURSELF: "cannot_invite_yourself",
+    CLIENT_MISSING_DEVICE_ID: "client_missing_device_id",
+    FORBIDDEN: "forbidden",
+    INTERNAL_SERVER_ERROR: "internal_server_error",
+    INVALID_AVATAR: "invalid_avatar",
+    INVALID_PARAMETERS: "invalid_parameters",
+    INVALID_ROOM_NAME: "invalid_room_name",
+    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_EMAIL_MISSING: "room_email_missing",
+    ROOM_FULL: "room_full",
+    ROOM_UNCLAIMED: "room_unclaimed",
+    CLIENT_BLOCKED: "client_blocked",
+    ROOM_LOCKED: "room_locked",
+    TOO_LONG_TEXT: "too_long_text",
+    VIDEO_STICKER_DOES_NOT_EXIST: "video_sticker_does_not_exist",
+    VIDEO_STICKER_FORMAT_ERROR: "video_sticker_format_error",
+    UNSUPPORTED_VIDEO_ENCODING: "unsupported_video_encoding",
+};
+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 logger$a = new Logger();
-const browserName$2 = adapter$6.browserDetails.browser;
-const browserVersion$1 = adapter$6.browserDetails.version;
-function setCodecPreferenceSDP(sdp, redOn) {
-    var _a, _b;
-    try {
-        const sdpObject = sdpTransform__namespace.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(" ");
-                        }
-                    }
-                }
+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;
             }
-            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(" ");
+            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;
                 }
-            }
-        }
-        const newSdp = sdpTransform__namespace.write(sdpObject);
-        return newSdp;
-    }
-    catch (error) {
-        logger$a.error("setCodecPreferenceSDP error:", error);
-    }
-}
-function cleanSdp(sdp) {
-    try {
-        const sdpObject = sdpTransform__namespace.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)));
+                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);
         });
-        return sdpTransform__namespace.write(sdpObject);
     }
-    catch (_) { }
-    return sdp;
-}
-function maybeRejectNoH264(sdp) {
-    if (browserName$2 !== "safari") {
-        return sdp;
+    _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, null, payload.eventClaim);
+        this.emit(PROTOCOL_RESPONSES.CLIENT_LEFT, payload);
     }
-    const sections = SDPUtils.splitSections(sdp);
-    for (let i = 1; i < sections.length; i++) {
-        if (SDPUtils.getKind(sections[i]) !== "video") {
-            continue;
+    _onPendingClientLeft(payload) {
+        const { clientId } = payload;
+        const client = this._clients[clientId];
+        if (!client) {
+            logger$a.warn(`client ${clientId} not found`);
+            return;
         }
-        const codecs = SDPUtils.matchPrefix(sections[i], "a=rtpmap:")
-            .map((line) => {
-            return SDPUtils.parseRtpMap(line);
-        })
-            .map((codec) => {
-            return codec.name.toUpperCase();
-        });
-        if (codecs.indexOf("H264") === -1 &&
-            sections[i][8] === "9") {
-            sections[i] = sections[i].replace("m=video 9 ", "m=video 0 ");
+        if (client.isPendingToLeave) {
+            return;
         }
-    }
-    return sections.join("");
-}
-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 replaceSSRCs(currentDescription, newDescription) {
-    let ssrcs = currentDescription.match(/a=ssrc-group:FID (\d+) (\d+)\r\n/);
-    let newssrcs = newDescription.match(/a=ssrc-group:FID (\d+) (\d+)\r\n/);
-    if (!ssrcs) {
-        ssrcs = currentDescription.match(/a=ssrc:(\d+) cname:(.*)\r\n/g)[1].match(/a=ssrc:(\d+)/);
-        newssrcs = newDescription.match(/a=ssrc:(\d+) cname:(.*)\r\n/g)[1].match(/a=ssrc:(\d+)/);
-    }
-    for (let i = 1; i < ssrcs.length; i++) {
-        newDescription = newDescription.replace(new RegExp(newssrcs[i], "g"), ssrcs[i]);
-    }
-    return newDescription;
-}
-function filterMidExtension(sdp) {
-    if (browserName$2 !== "safari" &&
-        (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;
+        client.isPendingToLeave = true;
+        if (this._wasClientSendingMedia(clientId)) {
+            client.checkActiveMediaAttempts = 0;
+            this._abortIfNotActive(payload);
         }
-        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") {
-        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 changeMediaDirection(sdp, active) {
-    const sections = SDPUtils.splitSections(sdp);
-    return (sections.shift() +
-        sections
-            .map((section) => {
-            const currentDirection = SDPUtils.getDirection(section, SDPUtils.getKind(section));
-            return section.replace("a=" + currentDirection, "a=" + (active ? "recvonly" : "inactive"));
-        })
-            .join(""));
-}
-function addExtMap(sdp, extmapUri, modifyAudio = false, modifyVideo = false) {
-    var _a, _b;
-    try {
-        const sdpObj = sdpTransform__namespace.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;
+    _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;
         }
-        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 }];
-                    }
-                }
+        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);
         });
-        return sdpTransform__namespace.write(sdpObj);
     }
-    catch (error) {
-        console.error("Error during addAbsCaptureTimeExtMap: ", error);
+    _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;
+                    });
+            });
+        }
+        return isActive;
     }
-    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();
+    _onAudioEnabled(payload) {
+        const { clientId, isAudioEnabled } = payload;
+        this._clients[clientId] = Object.assign(Object.assign({}, (this._clients[clientId] || {})), { isAudioEnabled });
     }
-    const parameters = sender.getParameters();
-    if (parameters.encodings && parameters.encodings.length === 0) {
-        return Promise.resolve();
+    _onVideoEnabled(payload) {
+        const { clientId, isVideoEnabled } = payload;
+        this._clients[clientId] = Object.assign(Object.assign({}, (this._clients[clientId] || {})), { isVideoEnabled });
     }
-    if (!parameters.encodings) {
-        parameters.encodings = [{}];
+    _onScreenshareChanged(payload, action) {
+        const { clientId } = payload;
+        this._clients[clientId] = Object.assign(Object.assign({}, (this._clients[clientId] || {})), { isScreenshareEnabled: action });
     }
-    if (bandwidth === 0) {
-        delete parameters.encodings[0].maxBitrate;
+    _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;
+        }
+        return false;
     }
-    else {
-        parameters.encodings[0].maxBitrate = bandwidth * 1000;
+    _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 });
     }
-    return sender.setParameters(parameters).catch((err) => {
-        logger.error("setParameters err: ", err);
-    });
-}
-
-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({ peerConnectionId, bandwidth, deprioritizeH264Encoding, }) {
-        this.peerConnectionId = peerConnectionId;
-        this.relayCandidateSeen = false;
-        this.serverReflexiveCandidateSeen = false;
-        this.publicHostCandidateSeen = false;
-        this.ipv6HostCandidateSeen = false;
-        this.ipv6HostCandidateTeredoSeen = false;
-        this.ipv6HostCandidate6to4Seen = false;
-        this.mdnsHostCandidateSeen = false;
-        this.pc = null;
-        this.wasEverConnected = false;
-        this.connectionStatus = null;
-        this.stats = {
-            totalSent: 0,
-            totalRecv: 0,
-        };
-        this.bandwidth = bandwidth || 0;
-        this.pending = [];
-        this.isOperationPending = false;
-        this.streamIds = [];
-        this.streams = [];
-        this.earlyIceCandidates = [];
-        this.afterConnected = new Promise((resolve) => {
-            this.registerConnected = resolve;
+    _wasClientSendingMedia(clientId) {
+        const client = this._clients[clientId];
+        if (!client) {
+            throw new Error(`Client ${clientId} not found in ReconnectManager state`);
+        }
+        return client.isAudioEnabled || client.isVideoEnabled || client.isScreenshareEnabled;
+    }
+    _getPendingClientsByDeviceId(deviceId) {
+        return Object.values(this._clients).filter((clientState) => {
+            return clientState.deviceId === deviceId && clientState.isPendingToLeave;
         });
-        this.offerOptions = { offerToReceiveAudio: true, offerToReceiveVideo: true };
-        this._deprioritizeH264Encoding = deprioritizeH264Encoding;
     }
-    setAndGetPeerConnection({ clientId, constraints, peerConnectionConfig, shouldAddLocalVideo, }) {
-        this.peerConnectionConfig = peerConnectionConfig;
-        this.shouldAddLocalVideo = shouldAddLocalVideo;
-        this.clientId = clientId;
-        this.pc = new RTCPeerConnection(peerConnectionConfig);
-        this.signalingState = this.pc.signalingState;
-        this.pc.addEventListener("signalingstatechange", () => {
-            if (this.signalingState === this.pc.signalingState) {
+    _resetClientState(payload) {
+        this._clients = {};
+        payload.room.clients.forEach((client) => {
+            if (client.id === payload.selfId) {
                 return;
             }
-            this.signalingState = this.pc.signalingState;
-            if (this.pc.signalingState === "stable") {
-                this.isOperationPending = false;
-                const action = this.pending.shift();
-                if (action) {
-                    action.apply();
-                }
+            else {
+                this._addClientToState(client);
             }
         });
-        return this.pc;
-    }
-    addStream(stream) {
-        this.streamIds.push(stream.id);
-        this.streams.push(stream);
-        if (RTCPeerConnection.prototype.addTrack) {
-            stream.getAudioTracks().forEach((track) => {
-                this.pc.addTrack(track, stream);
-            });
-            stream.getVideoTracks().forEach((track) => {
-                this.pc.addTrack(track, stream);
-            });
-        }
-        else {
-            this.pc.addStream(stream);
-        }
-    }
-    addTrack(track, stream) {
-        if (!stream) {
-            stream = this.streams[0];
-        }
-        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);
-        }
     }
-    removeStream(stream) {
-        for (let i = 0; i < this.streamIds.length; i++) {
-            if (this.streamIds[i] === stream.id) {
-                this.streamIds.splice(i, 1);
-                this.streams.splice(i, 1);
+}
+
+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;
+class ServerSocket {
+    constructor(hostName, optionsOverrides, glitchFree = false) {
+        this._wasConnectedUsingWebsocket = false;
+        this._reconnectManager = null;
+        this._socket = socket_ioClient.io(hostName, Object.assign({ path: DEFAULT_SOCKET_PATH, randomizationFactor: 0.5, reconnectionDelay: 250, reconnectionDelayMax: 5000, timeout: 5000, transports: ["websocket"], withCredentials: true }, optionsOverrides));
+        this._socket.io.on("reconnect", () => {
+            this._socket.sendBuffer = [];
+        });
+        this._socket.io.on("reconnect_attempt", () => {
+            if (this._wasConnectedUsingWebsocket) {
+                this._socket.io.opts.transports = ["websocket"];
+                if (adapter$6.browserDetails.browser !== "safari")
+                    delete this._wasConnectedUsingWebsocket;
             }
-        }
-        if (this.pc) {
-            if (this.pc.removeTrack) {
-                stream.getTracks().forEach((track) => {
-                    const sender = this.pc.getSenders().find((sender) => sender.track === track);
-                    if (sender) {
-                        this.pc.removeTrack(sender);
-                    }
-                });
+            else {
+                this._socket.io.opts.transports = ["websocket", "polling"];
             }
-            else if (this.pc.removeStream) {
-                this.pc.removeStream(stream);
+        });
+        if (glitchFree)
+            this._reconnectManager = new ReconnectManager(this._socket);
+        this._socket.on("connect", () => {
+            const transport = this.getTransport();
+            if (transport === "websocket") {
+                this._wasConnectedUsingWebsocket = true;
+                if (!this.noopKeepaliveInterval)
+                    this.noopKeepaliveInterval = setInterval(() => {
+                        try {
+                            if (this._socket.connected) {
+                                this._socket.io.engine.sendPacket("noop");
+                            }
+                        }
+                        catch (ex) { }
+                    }, NOOP_KEEPALIVE_INTERVAL);
             }
-        }
-    }
-    _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 = [];
         });
-    }
-    handleOffer(message) {
-        if (!this.canModifyPeerConnection()) {
-            return new Promise((resolve) => {
-                this.pending.push(() => this.handleOffer(message).then(resolve));
-            });
-        }
-        this.isOperationPending = true;
-        let sdp = message.sdp;
-        sdp = filterMidExtension(sdp);
-        sdp = filterMsidSemantic(sdp);
-        const desc = { type: message.type, sdp };
-        let answerToSignal;
-        return this._setRemoteDescription(desc)
-            .then(() => {
-            return this.pc.createAnswer();
-        })
-            .then((answer) => {
-            answerToSignal = answer;
-            return this.pc.setLocalDescription(answer);
-        })
-            .then(() => {
-            return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
-        })
-            .then(() => {
-            return answerToSignal;
+        this._socket.on("disconnect", () => {
+            this.disconnectTimestamp = Date.now();
+            if (this.noopKeepaliveInterval) {
+                clearInterval(this.noopKeepaliveInterval);
+                this.noopKeepaliveInterval = null;
+            }
         });
     }
-    handleAnswer(message) {
-        const sdp = filterMsidSemantic(message.sdp);
-        const desc = { type: message.type, sdp };
-        return this._setRemoteDescription(desc).then(() => {
-            return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
-        }, (e) => {
-            logger$9.warn("Could not set remote description from remote answer: ", e);
-        });
+    setRtcManager(rtcManager) {
+        if (this._reconnectManager) {
+            this._reconnectManager.rtcManager = rtcManager;
+        }
     }
-    addIceCandidate(candidate) {
-        if (!this.srdComplete) {
-            this.earlyIceCandidates.push(candidate);
+    connect() {
+        if (this.isConnected() || this.isConnecting()) {
             return;
         }
-        this.srdComplete.then(() => {
-            if (this.pc.signalingState === "closed") {
-                return;
-            }
-            if (adapter$5.browserDetails.browser === "safari" && candidate && candidate.candidate === "") {
-                return;
-            }
-            this.pc.addIceCandidate(candidate).catch((e) => {
-                logger$9.warn("Failed to add ICE candidate ('%s'): %s", candidate ? candidate.candidate : null, e);
-            });
+        this._socket.open();
+    }
+    disconnect() {
+        this._socket.disconnect();
+    }
+    disconnectOnConnect() {
+        this._socket.once("connect", () => {
+            this._socket.disconnect();
         });
     }
-    canModifyPeerConnection() {
-        return this.pc.signalingState === "stable" && !this.isOperationPending;
+    emit(eventName, ...args) {
+        this._socket.emit.apply(this._socket, arguments);
     }
-    close() {
-        const pc = this.pc;
-        if (!pc) {
+    emitIfConnected(eventName, data) {
+        if (!this.isConnected()) {
             return;
         }
-        pc.oniceconnectionstatechange = null;
-        pc.onicecandidate = null;
-        pc.ontrack = null;
-        try {
-            pc.close();
-        }
-        catch (e) {
-            logger$9.warn("failures during close of session", e);
-        }
+        this.emit(eventName, data);
     }
-    hasConnectedPeerConnection() {
-        return this.pc && this.pc.connectionState === "connected";
+    getTransport() {
+        return (this._socket &&
+            this._socket.io &&
+            this._socket.io.engine &&
+            this._socket.io.engine.transport &&
+            this._socket.io.engine.transport.name);
     }
-    replaceTrack(oldTrack, newTrack) {
-        const pc = this.pc;
-        if (!pc)
-            return false;
-        const senders = pc.getSenders();
-        if (!oldTrack) {
-            oldTrack = (senders.find((s) => s.track && s.track.kind === newTrack.kind) || {}).track;
-        }
-        if (window.RTCRtpSender && window.RTCRtpSender.prototype.replaceTrack) {
-            if (oldTrack) {
-                const process = () => {
-                    for (let i = 0; i < senders.length; i++) {
-                        const sender = senders[i];
-                        const track = sender.track;
-                        if ((track === null || track === void 0 ? void 0 : track.id) === newTrack.id) {
-                            return Promise.resolve(newTrack);
-                        }
-                        if ((track === null || track === void 0 ? void 0 : track.id) === oldTrack.id) {
-                            return senders[i].replaceTrack(newTrack);
-                        }
-                    }
-                    return null;
-                };
-                let result = process();
-                if (result) {
-                    return result;
-                }
-                let resolve = null;
-                let reject = null;
-                result = new Promise((_resolve, _reject) => {
-                    resolve = _resolve;
-                    reject = _reject;
-                });
-                let retried = 0;
-                let timer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                    const trackReplacedPromise = process();
-                    if (!trackReplacedPromise) {
-                        if (3 < ++retried) {
-                            clearInterval(timer);
-                            timer = null;
-                            reject("No sender track to replace");
-                        }
-                        return;
-                    }
-                    clearInterval(timer);
-                    timer = null;
-                    const trackReplaced = yield trackReplacedPromise;
-                    resolve(trackReplaced);
-                }), 1000);
-                return result;
-            }
-            const stream = this.streams.find((s) => s.getTracks().find((t) => t.id === newTrack.id)) || this.streams[0];
-            if (!stream) {
-                return Promise.reject(new Error("replaceTrack: No stream?"));
-            }
-            return pc.addTrack(newTrack, stream);
-        }
-        if (!this.canModifyPeerConnection()) {
-            this.pending.push(() => {
-                this.replaceTrack(oldTrack, newTrack);
-            });
-            return;
-        }
-        this.isOperationPending = true;
-        const onn = pc.onnegotiationneeded;
-        pc.onnegotiationneeded = null;
-        this.removeTrack(oldTrack);
-        this.addTrack(newTrack);
-        setTimeout(() => {
-            pc.onnegotiationneeded = onn;
-        }, 0);
-        if (pc.localDescription.type === "offer") {
-            return pc
-                .createOffer()
-                .then((offer) => {
-                offer.sdp = replaceSSRCs(pc.localDescription.sdp, offer.sdp);
-                return pc.setLocalDescription(offer);
-            })
-                .then(() => {
-                return this._setRemoteDescription(pc.remoteDescription);
-            });
-        }
-        else {
-            return this._setRemoteDescription(pc.remoteDescription)
-                .then(() => {
-                return pc.createAnswer();
-            })
-                .then((answer) => {
-                answer.sdp = replaceSSRCs(pc.localDescription.sdp, answer.sdp);
-                return pc.setLocalDescription(answer);
-            });
-        }
+    getManager() {
+        return this._socket.io;
     }
-    changeBandwidth(bandwidth) {
-        if (bandwidth === this.bandwidth) {
-            return;
-        }
-        if (!this.canModifyPeerConnection()) {
-            this.pending.push(() => this.changeBandwidth(bandwidth));
-            return;
+    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.bandwidth = bandwidth;
-        if (!this.pc.localDescription || this.pc.localDescription.type === "") {
-            return;
+        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);
+    }
+    _interceptEvent(eventName, handler) {
+        if (this._reconnectManager) {
+            this._reconnectManager.on(eventName, handler);
         }
-        setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
+        return () => {
+            if (this._reconnectManager)
+                this._reconnectManager.removeListener(eventName, handler);
+        };
     }
-    setAudioOnly(enable, excludedTrackIds = []) {
-        this.pc
-            .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";
-        });
+    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$4;
-const adapter$4 = (_a$4 = adapterRaw.default) !== null && _a$4 !== void 0 ? _a$4 : adapterRaw;
-function detectMicrophoneNotWorking(pc) {
-    if (adapter$4.browserDetails.browser !== "chrome" ||
-        adapter$4.browserDetails.browser < 58 ||
-        pc.signalingState === "closed") {
-        return Promise.resolve(false);
+const maybeTurnOnly = (iceConfig, features) => {
+    if (!features.useOnlyTURN) {
+        return;
     }
-    const sendingAudio = pc.getSenders().some((sender) => sender.track && sender.track.kind === "audio");
-    const receivingAudio = pc.getReceivers().some((receiver) => receiver.track && receiver.track.kind === "audio");
-    return pc.getStats(null).then((result) => {
-        let microphoneFailed = false;
-        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 PROTOCOL_REQUESTS = {
-    BLOCK_CLIENT: "block_client",
-    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",
-};
-const PROTOCOL_ERRORS = {
-    CANNOT_INVITE_YOURSELF: "cannot_invite_yourself",
-    CLIENT_MISSING_DEVICE_ID: "client_missing_device_id",
-    FORBIDDEN: "forbidden",
-    INTERNAL_SERVER_ERROR: "internal_server_error",
-    INVALID_AVATAR: "invalid_avatar",
-    INVALID_PARAMETERS: "invalid_parameters",
-    INVALID_ROOM_NAME: "invalid_room_name",
-    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_EMAIL_MISSING: "room_email_missing",
-    ROOM_FULL: "room_full",
-    ROOM_UNCLAIMED: "room_unclaimed",
-    CLIENT_BLOCKED: "client_blocked",
-    ROOM_LOCKED: "room_locked",
-    TOO_LONG_TEXT: "too_long_text",
-    VIDEO_STICKER_DOES_NOT_EXIST: "video_sticker_does_not_exist",
-    VIDEO_STICKER_FORMAT_ERROR: "video_sticker_format_error",
-    UNSUPPORTED_VIDEO_ENCODING: "unsupported_video_encoding",
-};
-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 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,
+        ];
+    }
 };
-const PROTOCOL_EVENTS = {
-    PENDING_CLIENT_LEFT: "pending_client_left",
-    MEDIA_QUALITY_CHANGED: "media_quality_changed",
+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 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 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);
 
-const CAMERA_STREAM_ID$1 = "0";
-const STREAM_TYPES = {
-    CAMERA: "camera",
-    SCREEN_SHARE: "screen_share",
+const logger$9 = new Logger();
+const debugLogger = {
+    print: (...args) => console.debug(args[0], ...args.slice(1)),
 };
-class RtcStream {
-    constructor(id, type) {
-        this.id = "" + id;
-        this.type = type;
-        this.isEnabled = true;
-        this.hasSupportForAutoSuperSize = false;
-        this.isAudioEnabled = true;
-        this.isVideoEnabled = true;
-        this.status = TYPES.CONNECTING;
-        this.stream = null;
-        this.streamId = null;
+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);
+                }
+            }
+            return;
+        }
+        if (beginNewPacketLossPeriod) {
+            history.hasActivePacketLoss = true;
+            history.currPeriod = {
+                begin: timestamp,
+            };
+        }
     }
-    setup(stream) {
-        this.stream = stream;
-        this.streamId = stream.id;
-        this.setVideoEnabled(this.isVideoEnabled && stream.getVideoTracks().length > 0);
-        this.setAudioEnabled(this.isAudioEnabled && stream.getAudioTracks().length > 0);
-        return this;
+    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;
     }
-    setStatus(status) {
-        this.status = status;
-        return this;
+    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;
     }
-    setVideoEnabled(isEnabled) {
-        this.isVideoEnabled = isEnabled;
-        if (!this.stream) {
-            return;
+    handleStaleMeasurements(id) {
+        const staleMeasurementTimeout = this.staleMeasurementTimeouts.get(id);
+        if (staleMeasurementTimeout) {
+            clearTimeout(staleMeasurementTimeout);
         }
-        this.stream.getVideoTracks().forEach((track) => {
-            track.enabled = isEnabled;
-        });
+        this.staleMeasurementTimeouts.set(id, setTimeout(() => {
+            logger$9.debug("handleStaleMeasurements() [measurements invalid for ssrc: %s]", id);
+            this.ssrcsHistory.delete(id);
+        }, this.STALE_MEASUREMENT_TIMEOUT_MS));
     }
-    setAudioEnabled(isEnabled) {
-        this.isAudioEnabled = isEnabled;
-        if (!this.stream) {
-            return;
+    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 });
         }
-        this.stream.getAudioTracks().forEach((track) => {
-            track.enabled = isEnabled;
-        });
+        else {
+            history.currPeriod.end = timestamp;
+            this.addNewPacketLossInterval(history);
+        }
+        delete history.currPeriod;
+        history.hasActivePacketLoss = false;
     }
-    static getCameraId() {
-        return CAMERA_STREAM_ID$1;
+    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;
     }
-    static getTypeFromId(id) {
-        const streamId = "" + id;
-        return streamId === CAMERA_STREAM_ID$1 ? STREAM_TYPES.CAMERA : STREAM_TYPES.SCREEN_SHARE;
+    calculatePeriodCenterTimestamp(period) {
+        if (!period.end)
+            throw new Error("Missing period end timestamp");
+        return period.begin + (period.end - period.begin) / 2;
     }
 }
 
-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",
-    ICE_IPV6_SEEN: "ice_ipv6_seen",
-    ICE_MDNS_SEEN: "ice_mdns_seen",
-    ICE_NO_PUBLIC_IP_GATHERED: "ice_no_public_ip_gathered",
-    ICE_NO_PUBLIC_IP_GATHERED_3SEC: "ice_no_public_ip_gathered_3sec",
-    ICE_RESTART: "ice_restart",
-    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",
-    PC_SLD_FAILURE: "pc_sld_failure",
-    PC_ON_ANSWER_FAILURE: "pc_on_answer_failure",
-    PC_ON_OFFER_FAILURE: "pc_on_offer_failure",
-};
-
-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);
+var _a$5;
+const adapter$5 = (_a$5 = adapterRaw.default) !== null && _a$5 !== void 0 ? _a$5 : adapterRaw;
+const logger$8 = new Logger();
+const browserName$2 = adapter$5.browserDetails.browser;
+const browserVersion$1 = adapter$5.browserDetails.version;
+function setCodecPreferenceSDP(sdp, redOn) {
+    var _a, _b;
+    try {
+        const sdpObject = sdpTransform__namespace.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__namespace.write(sdpObject);
+        return newSdp;
+    }
+    catch (error) {
+        logger$8.error("setCodecPreferenceSDP error:", error);
+    }
+}
+function cleanSdp(sdp) {
+    try {
+        const sdpObject = sdpTransform__namespace.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__namespace.write(sdpObject);
+    }
+    catch (_) { }
+    return sdp;
+}
+function maybeRejectNoH264(sdp) {
+    if (browserName$2 !== "safari") {
+        return sdp;
+    }
+    const sections = SDPUtils.splitSections(sdp);
+    for (let i = 1; i < sections.length; i++) {
+        if (SDPUtils.getKind(sections[i]) !== "video") {
+            continue;
+        }
+        const codecs = SDPUtils.matchPrefix(sections[i], "a=rtpmap:")
+            .map((line) => {
+            return SDPUtils.parseRtpMap(line);
+        })
+            .map((codec) => {
+            return codec.name.toUpperCase();
+        });
+        if (codecs.indexOf("H264") === -1 &&
+            sections[i][8] === "9") {
+            sections[i] = sections[i].replace("m=video 9 ", "m=video 0 ");
         }
     }
+    return sections.join("");
+}
+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 replaceSSRCs(currentDescription, newDescription) {
+    let ssrcs = currentDescription.match(/a=ssrc-group:FID (\d+) (\d+)\r\n/);
+    let newssrcs = newDescription.match(/a=ssrc-group:FID (\d+) (\d+)\r\n/);
+    if (!ssrcs) {
+        ssrcs = currentDescription.match(/a=ssrc:(\d+) cname:(.*)\r\n/g)[1].match(/a=ssrc:(\d+)/);
+        newssrcs = newDescription.match(/a=ssrc:(\d+) cname:(.*)\r\n/g)[1].match(/a=ssrc:(\d+)/);
+    }
+    for (let i = 1; i < ssrcs.length; i++) {
+        newDescription = newDescription.replace(new RegExp(newssrcs[i], "g"), ssrcs[i]);
+    }
+    return newDescription;
 }
-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 filterMidExtension(sdp) {
+    if (browserName$2 !== "safari" &&
+        (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;
+        }
+        const extmap = SDPUtils.parseExtmap(line);
+        return extmap.uri !== "urn:ietf:params:rtp-hdrext:sdes:mid";
+    })
+        .join("\r\n") + "\r\n");
 }
-function innerFail(obj) {
-    if (obj.message instanceof Error)
-        throw obj.message;
-    throw new AssertionError(obj);
+function filterMsidSemantic(sdp) {
+    if (browserName$2 !== "firefox") {
+        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 ok(...args) {
-    innerOk(ok, args.length, ...args);
+function changeMediaDirection(sdp, active) {
+    const sections = SDPUtils.splitSections(sdp);
+    return (sections.shift() +
+        sections
+            .map((section) => {
+            const currentDirection = SDPUtils.getDirection(section, SDPUtils.getKind(section));
+            return section.replace("a=" + currentDirection, "a=" + (active ? "recvonly" : "inactive"));
+        })
+            .join(""));
 }
-const assert = {
-    fail: (message) => {
-        innerFail({
-            actual: "fail()",
-            expected: "fail() should not be called",
-            message,
-            operator: "fail",
-            stackStartFn: assert.fail,
+function addExtMap(sdp, extmapUri, modifyAudio = false, modifyVideo = false) {
+    var _a, _b;
+    try {
+        const sdpObj = sdpTransform__namespace.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) => {
+            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 }];
+                    }
+                }
+            }
         });
-    },
-    ok,
-};
-assert.notEqual = function notEqual(actual, expected, message) {
-    if (arguments.length < 2) {
-        throw new Error("'actual' and 'expected' arguments are required");
+        return sdpTransform__namespace.write(sdpObj);
     }
-    if (actual == expected) {
-        innerFail({
-            actual,
-            expected,
-            message,
-            operator: "!=",
-            stackStartFn: notEqual,
-        });
+    catch (error) {
+        console.error("Error during addAbsCaptureTimeExtMap: ", error);
     }
-};
-assert.ok = ok;
+    return sdp;
+}
+function addAbsCaptureTimeExtMap(sdp) {
+    const absCaptureTimeUri = "http://www.webrtc.org/experiments/rtp-hdrext/abs-capture-time";
+    return addExtMap(sdp, absCaptureTimeUri, true, true);
+}
 
-const createWorker = (fn) => {
-    return new Worker(URL.createObjectURL(new Blob(["self.onmessage = ", fn.toString()], { type: "text/javascript" })));
-};
-const generateByteString = (count) => {
-    if (count === 0) {
-        return "";
+function setVideoBandwidthUsingSetParameters(pc, bandwidth, logger = console) {
+    const sender = pc.getSenders().find((s) => s.track && s.track.kind === "video");
+    if (!sender) {
+        return Promise.resolve();
     }
-    const count2 = count / 2;
-    let result = "F";
-    while (result.length <= count2) {
-        result += result;
+    const parameters = sender.getParameters();
+    if (parameters.encodings && parameters.encodings.length === 0) {
+        return Promise.resolve();
     }
-    return result + result.substring(0, count - result.length);
-};
-
-const getMediasoupDeviceAsync = (features) => __awaiter(void 0, void 0, void 0, function* () {
-    if (features.isNodeSdk) {
-        return new mediasoupClient.Device({ handlerName: "Safari12" });
+    if (!parameters.encodings) {
+        parameters.encodings = [{}];
     }
-    let handlerName = (yield mediasoupClient.detectDeviceAsync()) ||
-        (/applecoremedia|applewebkit|safari/i.test(navigator.userAgent) ? "Safari12" : undefined);
-    if (/iphone|ipad/i.test(navigator.userAgent)) {
-        handlerName = "Safari12";
+    if (bandwidth === 0) {
+        delete parameters.encodings[0].maxBitrate;
     }
-    return new mediasoupClient.Device({ handlerName });
-});
-
-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, isSomeoneAlreadyPresenting = false) => {
-    const { lowDataModeEnabled, simulcastScreenshareOn, vp9On } = features;
-    if (kind === "audio") {
-        return AUDIO_SETTINGS;
+    else {
+        parameters.encodings[0].maxBitrate = bandwidth * 1000;
     }
-    const isChrome = adapterRaw.browserDetails.browser === "chrome";
-    const isVp9Available = isChrome && vp9On;
-    if (isScreenShare) {
-        return getScreenShareMediaSettings({
-            isSomeoneAlreadyPresenting,
-            simulcastScreenshareOn,
+    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({ peerConnectionId, bandwidth, deprioritizeH264Encoding, }) {
+        this.peerConnectionId = peerConnectionId;
+        this.relayCandidateSeen = false;
+        this.serverReflexiveCandidateSeen = false;
+        this.publicHostCandidateSeen = false;
+        this.ipv6HostCandidateSeen = false;
+        this.ipv6HostCandidateTeredoSeen = false;
+        this.ipv6HostCandidate6to4Seen = false;
+        this.mdnsHostCandidateSeen = false;
+        this.pc = null;
+        this.wasEverConnected = false;
+        this.connectionStatus = null;
+        this.stats = {
+            totalSent: 0,
+            totalRecv: 0,
+        };
+        this.bandwidth = bandwidth || 0;
+        this.pending = [];
+        this.isOperationPending = false;
+        this.streamIds = [];
+        this.streams = [];
+        this.earlyIceCandidates = [];
+        this.afterConnected = new Promise((resolve) => {
+            this.registerConnected = resolve;
         });
+        this.offerOptions = { offerToReceiveAudio: true, offerToReceiveVideo: true };
+        this._deprioritizeH264Encoding = deprioritizeH264Encoding;
     }
-    else {
-        return getCameraMediaSettings({
-            lowBandwidth: lowDataModeEnabled,
-            isVp9Available,
+    setAndGetPeerConnection({ clientId, constraints, peerConnectionConfig, shouldAddLocalVideo, }) {
+        this.peerConnectionConfig = peerConnectionConfig;
+        this.shouldAddLocalVideo = shouldAddLocalVideo;
+        this.clientId = clientId;
+        this.pc = new RTCPeerConnection(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();
+                }
+            }
         });
+        return this.pc;
     }
-};
-const getCameraMediaSettings = ({ lowBandwidth, isVp9Available, }) => {
-    if (lowBandwidth) {
-        if (isVp9Available) {
-            return VIDEO_SETTINGS_VP9_LOW_BANDWIDTH;
+    addStream(stream) {
+        this.streamIds.push(stream.id);
+        this.streams.push(stream);
+        if (RTCPeerConnection.prototype.addTrack) {
+            stream.getAudioTracks().forEach((track) => {
+                this.pc.addTrack(track, stream);
+            });
+            stream.getVideoTracks().forEach((track) => {
+                this.pc.addTrack(track, stream);
+            });
+        }
+        else {
+            this.pc.addStream(stream);
         }
-        return VIDEO_SETTINGS_SD;
-    }
-    if (isVp9Available) {
-        return VIDEO_SETTINGS_VP9;
-    }
-    return VIDEO_SETTINGS_HD;
-};
-const getScreenShareMediaSettings = ({ isSomeoneAlreadyPresenting, simulcastScreenshareOn, }) => {
-    if (isSomeoneAlreadyPresenting) {
-        return ADDITIONAL_SCREEN_SHARE_SETTINGS;
-    }
-    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) => {
-    const { vp9On, h264On } = features;
-    const isChrome = adapterRaw.browserDetails.browser === "chrome";
-    if (!(routerRtpCapabilities === null || routerRtpCapabilities === void 0 ? void 0 : routerRtpCapabilities.codecs)) {
-        return routerRtpCapabilities;
-    }
-    if (vp9On && isChrome) {
-        const sorted = prioritizeRouterRtpCapabilitiesCodecs(routerRtpCapabilities.codecs, PrioritizableCodec.VP9);
-        return Object.assign(Object.assign({}, routerRtpCapabilities), { codecs: sorted });
     }
-    else if (h264On) {
-        const sorted = prioritizeRouterRtpCapabilitiesCodecs(routerRtpCapabilities.codecs, PrioritizableCodec.H264);
-        return Object.assign(Object.assign({}, routerRtpCapabilities), { codecs: sorted });
+    addTrack(track, stream) {
+        if (!stream) {
+            stream = this.streams[0];
+        }
+        stream === null || stream === void 0 ? void 0 : stream.addTrack(track);
+        this.pc.addTrack(track, stream);
     }
-    return routerRtpCapabilities;
-};
-function prioritizeRouterRtpCapabilitiesCodecs(codecs, preferredCodec) {
-    const preferredCodecEntry = codecs.find(({ mimeType }) => mimeType.toLowerCase() === preferredCodec);
-    if (!preferredCodecEntry) {
-        return codecs;
+    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);
+        }
     }
-    return [...codecs].sort((left, right) => {
-        var _a;
-        if (left.mimeType.toLowerCase() === preferredCodec) {
-            return -1;
+    removeStream(stream) {
+        for (let i = 0; i < this.streamIds.length; i++) {
+            if (this.streamIds[i] === stream.id) {
+                this.streamIds.splice(i, 1);
+                this.streams.splice(i, 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;
+        if (this.pc) {
+            if (this.pc.removeTrack) {
+                stream.getTracks().forEach((track) => {
+                    const sender = this.pc.getSenders().find((sender) => sender.track === track);
+                    if (sender) {
+                        this.pc.removeTrack(sender);
+                    }
+                });
+            }
+            else if (this.pc.removeStream) {
+                this.pc.removeStream(stream);
             }
-            return -1;
         }
-        return 0;
-    });
-}
-function getPreferredOrder(availableCodecs, { av1On }) {
-    availableCodecs.unshift("video/vp9");
-    if (av1On) {
-        availableCodecs.unshift("video/av1");
     }
-    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,
-            },
+    _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 = [];
         });
-        return powerEfficient;
-    });
-}
-function sortCodecsByPowerEfficiency(codecs) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const codecPowerEfficiencyEntries = yield Promise.all(codecs.map(({ mimeType }) => getIsCodecDecodingPowerEfficient(mimeType).then((val) => [mimeType, val])));
-        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;
+    }
+    handleOffer(message) {
+        if (!this.canModifyPeerConnection()) {
+            return new Promise((resolve) => {
+                this.pending.push(() => this.handleOffer(message).then(resolve));
+            });
+        }
+        this.isOperationPending = true;
+        let sdp = message.sdp;
+        sdp = filterMidExtension(sdp);
+        sdp = filterMsidSemantic(sdp);
+        const desc = { type: message.type, sdp };
+        let answerToSignal;
+        return this._setRemoteDescription(desc)
+            .then(() => {
+            return this.pc.createAnswer();
+        })
+            .then((answer) => {
+            answerToSignal = answer;
+            return this.pc.setLocalDescription(answer);
+        })
+            .then(() => {
+            return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
+        })
+            .then(() => {
+            return answerToSignal;
         });
-        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;
-    });
-}
-
-const logger$8 = 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();
+    }
+    handleAnswer(message) {
+        const sdp = filterMsidSemantic(message.sdp);
+        const desc = { type: message.type, sdp };
+        return this._setRemoteDescription(desc).then(() => {
+            return setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
+        }, (e) => {
+            logger$7.warn("Could not set remote description from remote answer: ", e);
         });
-        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);
+    addIceCandidate(candidate) {
+        if (!this.srdComplete) {
+            this.earlyIceCandidates.push(candidate);
+            return;
+        }
+        this.srdComplete.then(() => {
+            if (this.pc.signalingState === "closed") {
                 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++;
+            if (adapter$4.browserDetails.browser === "safari" && candidate && candidate.candidate === "") {
                 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$8.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.pc.addIceCandidate(candidate).catch((e) => {
+                logger$7.warn("Failed to add ICE candidate ('%s'): %s", candidate ? candidate.candidate : null, e);
             });
-            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, null, payload.eventClaim);
-        this.emit(PROTOCOL_RESPONSES.CLIENT_LEFT, payload);
+    canModifyPeerConnection() {
+        return this.pc.signalingState === "stable" && !this.isOperationPending;
     }
-    _onPendingClientLeft(payload) {
-        const { clientId } = payload;
-        const client = this._clients[clientId];
-        if (!client) {
-            logger$8.warn(`client ${clientId} not found`);
+    close() {
+        const pc = this.pc;
+        if (!pc) {
             return;
         }
-        if (client.isPendingToLeave) {
-            return;
+        pc.oniceconnectionstatechange = null;
+        pc.onicecandidate = null;
+        pc.ontrack = null;
+        try {
+            pc.close();
         }
-        client.isPendingToLeave = true;
-        if (this._wasClientSendingMedia(clientId)) {
-            client.checkActiveMediaAttempts = 0;
-            this._abortIfNotActive(payload);
+        catch (e) {
+            logger$7.warn("failures during close of session", e);
         }
     }
-    _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);
+    hasConnectedPeerConnection() {
+        return this.pc && this.pc.connectionState === "connected";
     }
-    _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;
+    replaceTrack(oldTrack, newTrack) {
+        const pc = this.pc;
+        if (!pc)
+            return false;
+        const senders = pc.getSenders();
+        if (!oldTrack) {
+            oldTrack = (senders.find((s) => s.track && s.track.kind === newTrack.kind) || {}).track;
+        }
+        if (window.RTCRtpSender && window.RTCRtpSender.prototype.replaceTrack) {
+            if (oldTrack) {
+                const process = () => {
+                    for (let i = 0; i < senders.length; i++) {
+                        const sender = senders[i];
+                        const track = sender.track;
+                        if ((track === null || track === void 0 ? void 0 : track.id) === newTrack.id) {
+                            return Promise.resolve(newTrack);
+                        }
+                        if ((track === null || track === void 0 ? void 0 : track.id) === oldTrack.id) {
+                            return senders[i].replaceTrack(newTrack);
+                        }
+                    }
+                    return null;
+                };
+                let result = process();
+                if (result) {
+                    return result;
+                }
+                let resolve = null;
+                let reject = null;
+                result = new Promise((_resolve, _reject) => {
+                    resolve = _resolve;
+                    reject = _reject;
+                });
+                let retried = 0;
+                let timer = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                    const trackReplacedPromise = process();
+                    if (!trackReplacedPromise) {
+                        if (3 < ++retried) {
+                            clearInterval(timer);
+                            timer = null;
+                            reject("No sender track to replace");
+                        }
+                        return;
+                    }
+                    clearInterval(timer);
+                    timer = null;
+                    const trackReplaced = yield trackReplacedPromise;
+                    resolve(trackReplaced);
+                }), 1000);
+                return result;
             }
-            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);
+            const stream = this.streams.find((s) => s.getTracks().find((t) => t.id === newTrack.id)) || this.streams[0];
+            if (!stream) {
+                return Promise.reject(new Error("replaceTrack: No stream?"));
             }
-        });
-    }
-    _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;
-                    });
+            return pc.addTrack(newTrack, stream);
+        }
+        if (!this.canModifyPeerConnection()) {
+            this.pending.push(() => {
+                this.replaceTrack(oldTrack, newTrack);
+            });
+            return;
+        }
+        this.isOperationPending = true;
+        const onn = pc.onnegotiationneeded;
+        pc.onnegotiationneeded = null;
+        this.removeTrack(oldTrack);
+        this.addTrack(newTrack);
+        setTimeout(() => {
+            pc.onnegotiationneeded = onn;
+        }, 0);
+        if (pc.localDescription.type === "offer") {
+            return pc
+                .createOffer()
+                .then((offer) => {
+                offer.sdp = replaceSSRCs(pc.localDescription.sdp, offer.sdp);
+                return pc.setLocalDescription(offer);
+            })
+                .then(() => {
+                return this._setRemoteDescription(pc.remoteDescription);
+            });
+        }
+        else {
+            return this._setRemoteDescription(pc.remoteDescription)
+                .then(() => {
+                return pc.createAnswer();
+            })
+                .then((answer) => {
+                answer.sdp = replaceSSRCs(pc.localDescription.sdp, answer.sdp);
+                return pc.setLocalDescription(answer);
             });
         }
-        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;
+    changeBandwidth(bandwidth) {
+        if (bandwidth === this.bandwidth) {
+            return;
         }
-        if (screenShare !== state.isScreenshareEnabled) {
-            return true;
+        if (!this.canModifyPeerConnection()) {
+            this.pending.push(() => this.changeBandwidth(bandwidth));
+            return;
         }
-        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`);
+        this.bandwidth = bandwidth;
+        if (!this.pc.localDescription || this.pc.localDescription.type === "") {
+            return;
         }
-        return client.isAudioEnabled || client.isVideoEnabled || client.isScreenshareEnabled;
-    }
-    _getPendingClientsByDeviceId(deviceId) {
-        return Object.values(this._clients).filter((clientState) => {
-            return clientState.deviceId === deviceId && clientState.isPendingToLeave;
-        });
+        setVideoBandwidthUsingSetParameters(this.pc, this.bandwidth);
     }
-    _resetClientState(payload) {
-        this._clients = {};
-        payload.room.clients.forEach((client) => {
-            if (client.id === payload.selfId) {
-                return;
-            }
-            else {
-                this._addClientToState(client);
-            }
+    setAudioOnly(enable, excludedTrackIds = []) {
+        this.pc
+            .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$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;
-class ServerSocket {
-    constructor(hostName, optionsOverrides, glitchFree = false) {
-        this._wasConnectedUsingWebsocket = false;
-        this._reconnectManager = null;
-        this._socket = socket_ioClient.io(hostName, Object.assign({ path: DEFAULT_SOCKET_PATH, randomizationFactor: 0.5, reconnectionDelay: 250, reconnectionDelayMax: 5000, timeout: 5000, transports: ["websocket"], withCredentials: true }, optionsOverrides));
-        this._socket.io.on("reconnect", () => {
-            this._socket.sendBuffer = [];
-        });
-        this._socket.io.on("reconnect_attempt", () => {
-            if (this._wasConnectedUsingWebsocket) {
-                this._socket.io.opts.transports = ["websocket"];
-                if (adapter$3.browserDetails.browser !== "safari")
-                    delete this._wasConnectedUsingWebsocket;
-            }
-            else {
-                this._socket.io.opts.transports = ["websocket", "polling"];
-            }
-        });
-        if (glitchFree)
-            this._reconnectManager = new ReconnectManager(this._socket);
-        this._socket.on("connect", () => {
-            const transport = this.getTransport();
-            if (transport === "websocket") {
-                this._wasConnectedUsingWebsocket = true;
-                if (!this.noopKeepaliveInterval)
-                    this.noopKeepaliveInterval = setInterval(() => {
-                        try {
-                            if (this._socket.connected) {
-                                this._socket.io.engine.sendPacket("noop");
-                            }
-                        }
-                        catch (ex) { }
-                    }, NOOP_KEEPALIVE_INTERVAL);
+function detectMicrophoneNotWorking(pc) {
+    if (adapter$3.browserDetails.browser !== "chrome" ||
+        adapter$3.browserDetails.browser < 58 ||
+        pc.signalingState === "closed") {
+        return Promise.resolve(false);
+    }
+    const sendingAudio = pc.getSenders().some((sender) => sender.track && sender.track.kind === "audio");
+    const receivingAudio = pc.getReceivers().some((receiver) => receiver.track && receiver.track.kind === "audio");
+    return pc.getStats(null).then((result) => {
+        let microphoneFailed = false;
+        result.forEach((report) => {
+            if (report.type === "outbound-rtp" &&
+                (report.kind === "audio" || report.mediaType === "audio") &&
+                sendingAudio) {
+                if (report.bytesSent === 0) {
+                    microphoneFailed = "outbound";
+                }
             }
-        });
-        this._socket.on("disconnect", () => {
-            this.disconnectTimestamp = Date.now();
-            if (this.noopKeepaliveInterval) {
-                clearInterval(this.noopKeepaliveInterval);
-                this.noopKeepaliveInterval = null;
+            else if (report.type === "inbound-rtp" &&
+                (report.kind === "audio" || report.mediaType === "audio") &&
+                receivingAudio) {
+                if (report.bytesReceived === 0) {
+                    microphoneFailed = "inbound";
+                }
             }
         });
-    }
-    setRtcManager(rtcManager) {
-        if (this._reconnectManager) {
-            this._reconnectManager.rtcManager = rtcManager;
-        }
-    }
-    connect() {
-        if (this.isConnected() || this.isConnecting()) {
-            return;
-        }
-        this._socket.open();
-    }
-    disconnect() {
-        this._socket.disconnect();
-    }
-    disconnectOnConnect() {
-        this._socket.once("connect", () => {
-            this._socket.disconnect();
-        });
-    }
-    emit(eventName, ...args) {
-        this._socket.emit.apply(this._socket, arguments);
-    }
-    emitIfConnected(eventName, data) {
-        if (!this.isConnected()) {
-            return;
-        }
-        this.emit(eventName, data);
-    }
-    getTransport() {
-        return (this._socket &&
-            this._socket.io &&
-            this._socket.io.engine &&
-            this._socket.io.engine.transport &&
-            this._socket.io.engine.transport.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._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;
-    }
+        return microphoneFailed;
+    });
 }
 
-const maybeTurnOnly = (iceConfig, features) => {
-    if (!features.useOnlyTURN) {
-        return;
+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 CAMERA_STREAM_ID$1 = "0";
+const STREAM_TYPES = {
+    CAMERA: "camera",
+    SCREEN_SHARE: "screen_share",
+};
+class RtcStream {
+    constructor(id, type) {
+        this.id = "" + id;
+        this.type = type;
+        this.isEnabled = true;
+        this.hasSupportForAutoSuperSize = false;
+        this.isAudioEnabled = true;
+        this.isVideoEnabled = true;
+        this.status = TYPES.CONNECTING;
+        this.stream = null;
+        this.streamId = null;
     }
-    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;
-            }
-        });
+    setup(stream) {
+        this.stream = stream;
+        this.streamId = stream.id;
+        this.setVideoEnabled(this.isVideoEnabled && stream.getVideoTracks().length > 0);
+        this.setAudioEnabled(this.isAudioEnabled && stream.getAudioTracks().length > 0);
+        return this;
     }
-};
-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,
-        ];
+    setStatus(status) {
+        this.status = status;
+        return this;
     }
-    if (features.addCloudflareStunServers) {
-        iceConfig.iceServers = [
-            { urls: "stun:stun.cloudflare.com:3478" },
-            { urls: "stun:stun.cloudflare.com:53" },
-            ...iceConfig.iceServers,
-        ];
+    setVideoEnabled(isEnabled) {
+        this.isVideoEnabled = isEnabled;
+        if (!this.stream) {
+            return;
+        }
+        this.stream.getVideoTracks().forEach((track) => {
+            track.enabled = isEnabled;
+        });
     }
-};
-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;
+    setAudioEnabled(isEnabled) {
+        this.isAudioEnabled = isEnabled;
+        if (!this.stream) {
+            return;
+        }
+        this.stream.getAudioTracks().forEach((track) => {
+            track.enabled = isEnabled;
         });
     }
-    else {
-        return iceServers;
+    static getCameraId() {
+        return CAMERA_STREAM_ID$1;
     }
-};
-
-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;
-        }
+    static getTypeFromId(id) {
+        const streamId = "" + id;
+        return streamId === CAMERA_STREAM_ID$1 ? STREAM_TYPES.CAMERA : STREAM_TYPES.SCREEN_SHARE;
     }
-    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 rtcManagerEvents = {
+    CAMERA_NOT_WORKING: "camera_not_working",
+    CONNECTION_BLOCKED_BY_NETWORK: "connection_blocked_by_network",
+    ICE_IPV6_SEEN: "ice_ipv6_seen",
+    ICE_MDNS_SEEN: "ice_mdns_seen",
+    ICE_NO_PUBLIC_IP_GATHERED: "ice_no_public_ip_gathered",
+    ICE_NO_PUBLIC_IP_GATHERED_3SEC: "ice_no_public_ip_gathered_3sec",
+    ICE_RESTART: "ice_restart",
+    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",
+    PC_SLD_FAILURE: "pc_sld_failure",
+    PC_ON_ANSWER_FAILURE: "pc_on_answer_failure",
+    PC_ON_OFFER_FAILURE: "pc_on_offer_failure",
+};
 
 var _a$2, _b;
 const adapter$2 = (_a$2 = adapterRaw.default) !== null && _a$2 !== void 0 ? _a$2 : adapterRaw;
-const logger$7 = new Logger();
+const logger$6 = new Logger();
 const ICE_PUBLIC_IP_GATHERING_TIMEOUT = 3 * 1000;
 const CAMERA_STREAM_ID = RtcStream.getCameraId();
 const browserName$1 = adapter$2.browserDetails.browser;
@@ -2589,7 +2710,7 @@ class P2pRtcManager {
             () => this._clearMediaServersRefresh(),
             this._serverSocket.on(PROTOCOL_RESPONSES.MEDIASERVER_CONFIG, (data) => {
                 if (data.error) {
-                    logger$7.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
+                    logger$6.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
                     return;
                 }
                 this._updateAndScheduleMediaServersRefresh(data);
@@ -2600,7 +2721,7 @@ class P2pRtcManager {
             this._serverSocket.on(RELAY_MESSAGES.ICE_CANDIDATE, (data) => {
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    logger$7.warn("No RTCPeerConnection on ICE_CANDIDATE", data);
+                    logger$6.warn("No RTCPeerConnection on ICE_CANDIDATE", data);
                     return;
                 }
                 session.addIceCandidate(data.message);
@@ -2608,7 +2729,7 @@ class P2pRtcManager {
             this._serverSocket.on(RELAY_MESSAGES.ICE_END_OF_CANDIDATES, (data) => {
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    logger$7.warn("No RTCPeerConnection on ICE_END_OF_CANDIDATES", data);
+                    logger$6.warn("No RTCPeerConnection on ICE_END_OF_CANDIDATES", data);
                     return;
                 }
                 session.addIceCandidate(null);
@@ -2617,7 +2738,7 @@ class P2pRtcManager {
                 var _a, _b;
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    logger$7.warn("No RTCPeerConnection on SDP_OFFER", data);
+                    logger$6.warn("No RTCPeerConnection on SDP_OFFER", data);
                     return;
                 }
                 const offer = this._transformIncomingSdp(data.message, session.pc);
@@ -2636,7 +2757,7 @@ class P2pRtcManager {
                 var _a, _b;
                 const session = this._getSession(data.clientId);
                 if (!session) {
-                    logger$7.warn("No RTCPeerConnection on SDP_ANSWER", data);
+                    logger$6.warn("No RTCPeerConnection on SDP_ANSWER", data);
                     return;
                 }
                 const answer = this._transformIncomingSdp(data.message, session.pc);
@@ -2658,7 +2779,7 @@ class P2pRtcManager {
                 }
                 const screenshareStream = this.localStreams[screenShareStreamId];
                 if (!screenshareStream) {
-                    logger$7.warn("screenshare stream %s not found", screenShareStreamId);
+                    logger$6.warn("screenshare stream %s not found", screenShareStreamId);
                     return;
                 }
                 const hasAudioTrack = screenshareStream.getAudioTracks().length > 0;
@@ -2735,7 +2856,7 @@ class P2pRtcManager {
             });
         }
         catch (error) {
-            logger$7.error("Error during setting jitter buffer target:", error);
+            logger$6.error("Error during setting jitter buffer target:", error);
         }
     }
     _emitServerEvent(eventName, data, callback) {
@@ -2955,7 +3076,7 @@ class P2pRtcManager {
     _cleanup(peerConnectionId) {
         const session = this._getSession(peerConnectionId);
         if (!session) {
-            logger$7.warn("No RTCPeerConnection in RTCManager.disconnect()", peerConnectionId);
+            logger$6.warn("No RTCPeerConnection in RTCManager.disconnect()", peerConnectionId);
             return;
         }
         session.close();
@@ -2980,17 +3101,17 @@ class P2pRtcManager {
         const promises = [];
         this._forEachPeerConnection((session) => {
             if (!session.hasConnectedPeerConnection()) {
-                logger$7.info("Session doesn't have a connected PeerConnection, adding pending action!");
+                logger$6.info("Session doesn't have a connected PeerConnection, adding pending action!");
                 const pendingActions = this._pendingActionsForConnectedPeerConnections;
                 if (!pendingActions) {
-                    logger$7.warn(`No pending action is created to replace track, because the pending actions array is null`);
+                    logger$6.warn(`No pending action is created to replace track, because the pending actions array is null`);
                     return;
                 }
                 const promise = new Promise((resolve, reject) => {
                     const action = () => {
                         const replacedTrackPromise = session.replaceTrack(oldTrack, newTrack);
                         if (!replacedTrackPromise) {
-                            logger$7.error("replaceTrack returned false!");
+                            logger$6.error("replaceTrack returned false!");
                             reject(`ReplaceTrack returned false`);
                             return;
                         }
@@ -3003,7 +3124,7 @@ class P2pRtcManager {
             }
             const replacedTrackResult = session.replaceTrack(oldTrack, newTrack);
             if (!replacedTrackResult) {
-                logger$7.error("replaceTrack returned false!");
+                logger$6.error("replaceTrack returned false!");
                 return;
             }
             promises.push(replacedTrackResult);
@@ -3065,7 +3186,7 @@ class P2pRtcManager {
         let session = this._getSession(clientId);
         let initialBandwidth = (session && session.bandwidth) || 0;
         if (session) {
-            logger$7.warn("Replacing peer session", clientId);
+            logger$6.warn("Replacing peer session", clientId);
             this._cleanup(clientId);
         }
         else {
@@ -3135,13 +3256,13 @@ class P2pRtcManager {
                 })));
             }
             catch (error) {
-                logger$7.error("Error during setting setCodecPreferences:", error);
+                logger$6.error("Error during setting setCodecPreferences:", error);
             }
         });
     }
     _negotiatePeerConnection(clientId, session, constraints) {
         if (!session) {
-            logger$7.warn("No RTCPeerConnection in negotiatePeerConnection()", clientId);
+            logger$6.warn("No RTCPeerConnection in negotiatePeerConnection()", clientId);
             return;
         }
         const pc = session.pc;
@@ -3165,7 +3286,7 @@ class P2pRtcManager {
                 offer.sdp = cleanSdp(offer.sdp);
             pc.setLocalDescription(offer)
                 .catch((e) => {
-                logger$7.warn("RTCPeerConnection.setLocalDescription() failed with local offer", e);
+                logger$6.warn("RTCPeerConnection.setLocalDescription() failed with local offer", e);
                 this._emit(rtcManagerEvents.PC_SLD_FAILURE, e);
                 throw e;
             })
@@ -3177,7 +3298,7 @@ class P2pRtcManager {
             });
         })
             .catch((e) => {
-            logger$7.warn("RTCPeerConnection.createOffer() failed to create local offer", e);
+            logger$6.warn("RTCPeerConnection.createOffer() failed to create local offer", e);
         }));
     }
     _withForcedRenegotiation(session, action) {
@@ -3292,7 +3413,7 @@ class P2pRtcManager {
                             }
                         }
                         catch (error) {
-                            logger$7.info("Error during parsing candidates! Error: ", { error });
+                            logger$6.info("Error during parsing candidates! Error: ", { error });
                         }
                         break;
                     case "srflx":
@@ -3348,7 +3469,7 @@ class P2pRtcManager {
         }
         let initialBandwidth = (session && session.bandwidth) || 0;
         if (session) {
-            logger$7.warn("Replacing peer session", clientId);
+            logger$6.warn("Replacing peer session", clientId);
             this._cleanup(clientId);
         }
         else {
@@ -3565,7 +3686,7 @@ const defaultParams = {
     scoreFormula: "300 * bands[1].avg / Math.max(bands[1].avg + bands[0].avg, 0.01)",
     outFormula: "score",
 };
-const logger$6 = new Logger();
+const logger$5 = new Logger();
 function createMicAnalyser({ micTrack, params, onScoreUpdated, }) {
     const audioCtx = new AudioContext();
     let analyser = null;
@@ -3587,7 +3708,7 @@ function createMicAnalyser({ micTrack, params, onScoreUpdated, }) {
                 lastTrackWasOurs = true;
             }
             catch (ex) {
-                logger$6.warn("unable to fetch new track for colocation speaker analysis, using current", ex);
+                logger$5.warn("unable to fetch new track for colocation speaker analysis, using current", ex);
             }
         }
         lastTrack = track;
@@ -3674,7 +3795,7 @@ function createMicAnalyser({ micTrack, params, onScoreUpdated, }) {
     };
 }
 
-const logger$5 = new Logger();
+const logger$4 = new Logger();
 const MEDIA_QUALITY = Object.freeze({
     ok: "ok",
     warning: "warning",
@@ -3744,7 +3865,7 @@ class VegaMediaQualityMonitor extends EventEmitter {
     }
     addProducer(clientId, producerId) {
         if (!clientId || !producerId || !(typeof clientId === "string" && typeof producerId === "string")) {
-            logger$5.warn("Missing clientId or producerId");
+            logger$4.warn("Missing clientId or producerId");
             return;
         }
         if (!this._producers[clientId]) {
@@ -3760,7 +3881,7 @@ class VegaMediaQualityMonitor extends EventEmitter {
     }
     addConsumer(clientId, consumerId) {
         if (!clientId || !consumerId) {
-            logger$5.warn("Missing clientId or consumerId");
+            logger$4.warn("Missing clientId or consumerId");
             return;
         }
         if (!this._producers[clientId]) {
@@ -3778,14 +3899,14 @@ class VegaMediaQualityMonitor extends EventEmitter {
         if (!Array.isArray(score) ||
             score.length === 0 ||
             score.some((s) => !s || !s.hasOwnProperty("score") || typeof s.score !== "number" || isNaN(s.score))) {
-            logger$5.warn("Unexpected producer score format");
+            logger$4.warn("Unexpected producer score format");
             return;
         }
         this._producers[clientId][producerId] = { kind, score: this._calcAvgProducerScore(score.map((s) => s.score)) };
     }
     addConsumerScore(clientId, consumerId, kind, score) {
         if (!score || !score.hasOwnProperty("producerScores") || !Array.isArray(score.producerScores)) {
-            logger$5.warn("Unexpected consumer score format");
+            logger$4.warn("Unexpected consumer score format");
             return;
         }
         this._producers[clientId][consumerId] = { kind, score: this._calcAvgProducerScore(score.producerScores) };
@@ -3822,7 +3943,7 @@ class VegaMediaQualityMonitor extends EventEmitter {
             }
         }
         catch (error) {
-            logger$5.error(error);
+            logger$4.error(error);
             return 0;
         }
     }
@@ -3963,7 +4084,7 @@ class SfuV2Parser {
     }
 }
 
-const logger$4 = new Logger();
+const logger$3 = new Logger();
 class VegaConnection extends EventEmitter.EventEmitter {
     constructor(wsUrl, protocol = "whereby-sfu#v4") {
         super();
@@ -3996,12 +4117,12 @@ class VegaConnection extends EventEmitter.EventEmitter {
         (_a = this.socket) === null || _a === void 0 ? void 0 : _a.close();
     }
     _onOpen() {
-        logger$4.info("Connected");
+        logger$3.info("Connected");
         this.emit("open");
     }
     _onMessage(event) {
         const socketMessage = SfuV2Parser.parse(event.data);
-        logger$4.info("Received message", socketMessage);
+        logger$3.info("Received message", socketMessage);
         if (socketMessage === null || socketMessage === void 0 ? void 0 : socketMessage.response) {
             this._handleResponse(socketMessage);
         }
@@ -4010,11 +4131,11 @@ class VegaConnection extends EventEmitter.EventEmitter {
         }
     }
     _onClose() {
-        logger$4.info("Disconnected");
+        logger$3.info("Disconnected");
         this._tearDown();
     }
     _onError(error) {
-        logger$4.info("Error", error);
+        logger$3.info("Error", error);
     }
     _handleResponse(socketMessage) {
         const sent = this.sents.get(socketMessage.id);
@@ -4250,7 +4371,7 @@ function createVegaConnectionManager(config) {
 
 var _a$1;
 const adapter$1 = (_a$1 = adapterRaw.default) !== null && _a$1 !== void 0 ? _a$1 : adapterRaw;
-const logger$3 = new Logger();
+const logger$2 = new Logger();
 const browserName = adapter$1.browserDetails.browser;
 let unloading = false;
 const RESTARTICE_ERROR_RETRY_THRESHOLD_IN_MS = 3500;
@@ -4380,7 +4501,7 @@ class VegaRtcManager {
     setupSocketListeners() {
         this._socketListenerDeregisterFunctions.push(() => this._clearMediaServersRefresh(), this._serverSocket.on(PROTOCOL_RESPONSES.MEDIASERVER_CONFIG, (data) => {
             if (data.error) {
-                logger$3.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
+                logger$2.warn("FETCH_MEDIASERVER_CONFIG failed:", data.error);
                 return;
             }
             this._updateAndScheduleMediaServersRefresh(data);
@@ -4452,7 +4573,7 @@ class VegaRtcManager {
     }
     _onClose() {
         var _a, _b;
-        logger$3.info("_onClose()");
+        logger$2.info("_onClose()");
         (_a = this._sendTransport) === null || _a === void 0 ? void 0 : _a.close();
         (_b = this._receiveTransport) === null || _b === void 0 ? void 0 : _b.close();
         this._sendTransport = null;
@@ -4468,7 +4589,7 @@ class VegaRtcManager {
     _join() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
-            logger$3.info("join()");
+            logger$2.info("join()");
             this._emitToPWA(rtcManagerEvents.SFU_CONNECTION_OPEN);
             try {
                 const { routerRtpCapabilities } = yield this._vegaConnection.request("getCapabilities");
@@ -4495,7 +4616,7 @@ class VegaRtcManager {
                 yield Promise.all(mediaPromises);
             }
             catch (error) {
-                logger$3.error("_join() [error:%o]", error);
+                logger$2.error("_join() [error:%o]", error);
             }
         });
     }
@@ -4523,7 +4644,7 @@ class VegaRtcManager {
             maybeTurnOnly(transportOptions, this._features);
             const transport = (_a = (yield this._mediasoupDeviceInitializedAsync)) === null || _a === void 0 ? void 0 : _a[creator](transportOptions);
             const onConnectionStateListener = (connectionState) => __awaiter(this, void 0, void 0, function* () {
-                logger$3.info(`Transport ConnectionStateChanged ${connectionState}`);
+                logger$2.info(`Transport ConnectionStateChanged ${connectionState}`);
                 if (connectionState !== "disconnected" && connectionState !== "failed") {
                     return;
                 }
@@ -4597,15 +4718,15 @@ class VegaRtcManager {
     _restartIce(transport_1) {
         return __awaiter(this, arguments, void 0, function* (transport, retried = 0) {
             if (!transport || !("closed" in transport) || !("connectionState" in transport)) {
-                logger$3.info("_restartIce: No transport or property closed or connectionState!");
+                logger$2.info("_restartIce: No transport or property closed or connectionState!");
                 return;
             }
             if (transport.closed) {
-                logger$3.info("_restartIce: Transport is closed!");
+                logger$2.info("_restartIce: Transport is closed!");
                 return;
             }
             if (transport.connectionState !== "disconnected" && transport.connectionState !== "failed") {
-                logger$3.info("_restartIce: Connection is healthy ICE restart no loneger needed!");
+                logger$2.info("_restartIce: Connection is healthy ICE restart no loneger needed!");
                 return;
             }
             const { iceRestartStarted } = transport.appData;
@@ -4615,21 +4736,21 @@ class VegaRtcManager {
             }
             transport.appData.iceRestartStarted = now;
             if (RESTARTICE_ERROR_MAX_RETRY_COUNT <= retried) {
-                logger$3.info("_restartIce: Reached restart ICE  maximum retry count!");
+                logger$2.info("_restartIce: Reached restart ICE  maximum retry count!");
                 return;
             }
             if (!this._vegaConnection) {
-                logger$3.info(`_restartIce: Connection is undefined`);
+                logger$2.info(`_restartIce: Connection is undefined`);
                 return;
             }
             const { iceParameters } = yield this._vegaConnection.request("restartIce", { transportId: transport.id });
-            logger$3.info("_restartIce: ICE restart iceParameters received from SFU: ", iceParameters);
+            logger$2.info("_restartIce: ICE restart iceParameters received from SFU: ", iceParameters);
             const error = yield transport
                 .restartIce({ iceParameters })
                 .then(() => null)
                 .catch((err) => err);
             if (error) {
-                logger$3.error(`_restartIce: ICE restart failed: ${error}`);
+                logger$2.error(`_restartIce: ICE restart failed: ${error}`);
                 switch (error.message) {
                     case "missing transportId":
                     case "no such transport":
@@ -4658,7 +4779,7 @@ class VegaRtcManager {
     }
     _internalSendMic() {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_internalSendMic()");
+            logger$2.info("_internalSendMic()");
             this._micProducerPromise = (() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     if (!this._micTrack || !this._sendTransport || this._micProducer) {
@@ -4678,7 +4799,7 @@ class VegaRtcManager {
                     this._qualityMonitor.addProducer(this._selfId, producer.id);
                     producer.observer.once("close", () => {
                         var _a;
-                        logger$3.info('micProducer "close" event');
+                        logger$2.info('micProducer "close" event');
                         if (producer.appData.localClosed)
                             (_a = this._vegaConnection) === null || _a === void 0 ? void 0 : _a.message("closeProducers", { producerIds: [producer.id] });
                         this._micProducer = null;
@@ -4691,7 +4812,7 @@ class VegaRtcManager {
                         this._pauseResumeMic();
                 }
                 catch (error) {
-                    logger$3.error("micProducer failed:%o", error);
+                    logger$2.error("micProducer failed:%o", error);
                 }
                 finally {
                     this._micProducerPromise = null;
@@ -4705,7 +4826,7 @@ class VegaRtcManager {
     }
     _internalSetupMicScore() {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_internalSetupMicScore()");
+            logger$2.info("_internalSetupMicScore()");
             this._micScoreProducerPromise = (() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     if (!this._micProducer || !this._colocation || this._micScoreProducer) {
@@ -4724,7 +4845,7 @@ class VegaRtcManager {
                     this._micScoreProducer = producer;
                     producer.observer.once("close", () => {
                         var _a;
-                        logger$3.info('micScoreProducer "close" event');
+                        logger$2.info('micScoreProducer "close" event');
                         if (producer.appData.localClosed) {
                             (_a = this._vegaConnection) === null || _a === void 0 ? void 0 : _a.message("closeDataProducers", { dataProducerIds: [producer.id] });
                         }
@@ -4733,7 +4854,7 @@ class VegaRtcManager {
                     });
                 }
                 catch (error) {
-                    logger$3.error("micScoreProducer failed:%o", error);
+                    logger$2.error("micScoreProducer failed:%o", error);
                 }
                 finally {
                     this._micScoreProducerPromise = null;
@@ -4751,7 +4872,7 @@ class VegaRtcManager {
     _replaceMicTrack() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            logger$3.info("_replaceMicTrack()");
+            logger$2.info("_replaceMicTrack()");
             if (!this._micTrack || !this._micProducer || this._micProducer.closed)
                 return;
             if (this._micProducer.track !== this._micTrack) {
@@ -4763,7 +4884,7 @@ class VegaRtcManager {
     }
     _pauseResumeMic() {
         var _a, _b;
-        logger$3.info("_pauseResumeMic()");
+        logger$2.info("_pauseResumeMic()");
         if (!this._micProducer || this._micProducer.closed)
             return;
         if (this._micPaused !== this._micProducer.paused) {
@@ -4784,7 +4905,7 @@ class VegaRtcManager {
     }
     _sendMic(track) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_sendMic() [track:%o]", track);
+            logger$2.info("_sendMic() [track:%o]", track);
             this._micTrack = track;
             if (this._micProducer) {
                 return yield this._replaceMicTrack();
@@ -4810,7 +4931,7 @@ class VegaRtcManager {
                 this._micScoreProducer.send(JSON.stringify({ score }));
             }
             catch (ex) {
-                logger$3.error("_sendMicScore failed [error:%o]", ex);
+                logger$2.error("_sendMicScore failed [error:%o]", ex);
             }
             return;
         }
@@ -4821,7 +4942,7 @@ class VegaRtcManager {
     _internalSendWebcam() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            logger$3.info("_internalSendWebcam()");
+            logger$2.info("_internalSendWebcam()");
             if (!this._sendTransport ||
                 this._webcamProducer ||
                 this._webcamProducerPromise ||
@@ -4844,7 +4965,7 @@ class VegaRtcManager {
                     this._qualityMonitor.addProducer(this._selfId, producer.id);
                     producer.observer.once("close", () => {
                         var _a;
-                        logger$3.info('webcamProducer "close" event');
+                        logger$2.info('webcamProducer "close" event');
                         if (producer.appData.localClosed)
                             (_a = this._vegaConnection) === null || _a === void 0 ? void 0 : _a.message("closeProducers", { producerIds: [producer.id] });
                         this._webcamProducer = null;
@@ -4859,7 +4980,7 @@ class VegaRtcManager {
                         this._pauseResumeWebcam();
                 }
                 catch (error) {
-                    logger$3.error("webcamProducer failed:%o", error);
+                    logger$2.error("webcamProducer failed:%o", error);
                 }
                 finally {
                     this._webcamProducerPromise = null;
@@ -4873,7 +4994,7 @@ class VegaRtcManager {
     }
     _replaceWebcamTrack() {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_replaceWebcamTrack()");
+            logger$2.info("_replaceWebcamTrack()");
             if (!this._sendTransport || !this._webcamTrack || this._webcamProducerPromise)
                 return;
             if (!this._webcamProducer && this._webcamTrack.enabled) {
@@ -4888,7 +5009,7 @@ class VegaRtcManager {
     }
     _pauseResumeWebcam() {
         var _a, _b;
-        logger$3.info("_pauseResumeWebcam()");
+        logger$2.info("_pauseResumeWebcam()");
         if (!this._webcamProducer || this._webcamProducer.closed)
             return;
         if (this._webcamPaused !== this._webcamProducer.paused) {
@@ -4909,7 +5030,7 @@ class VegaRtcManager {
     }
     _sendWebcam(track) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_sendWebcam() [track:%o]", track);
+            logger$2.info("_sendWebcam() [track:%o]", track);
             this._webcamTrack = track;
             if (this._webcamProducer) {
                 return yield this._replaceWebcamTrack();
@@ -4923,7 +5044,7 @@ class VegaRtcManager {
     }
     _internalSendScreenVideo() {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_internalSendScreenVideo()");
+            logger$2.info("_internalSendScreenVideo()");
             this._screenVideoProducerPromise = (() => __awaiter(this, void 0, void 0, function* () {
                 var _a, _b;
                 try {
@@ -4945,7 +5066,7 @@ class VegaRtcManager {
                     this._qualityMonitor.addProducer(this._selfId, producer.id);
                     producer.observer.once("close", () => {
                         var _a;
-                        logger$3.info('screenVideoProducer "close" event');
+                        logger$2.info('screenVideoProducer "close" event');
                         if (producer.appData.localClosed)
                             (_a = this._vegaConnection) === null || _a === void 0 ? void 0 : _a.message("closeProducers", { producerIds: [producer.id] });
                         this._screenVideoProducer = null;
@@ -4956,7 +5077,7 @@ class VegaRtcManager {
                         yield this._replaceScreenVideoTrack();
                 }
                 catch (error) {
-                    logger$3.error("screenVideoProducer failed:%o", error);
+                    logger$2.error("screenVideoProducer failed:%o", error);
                 }
                 finally {
                     this._screenVideoProducerPromise = null;
@@ -4970,7 +5091,7 @@ class VegaRtcManager {
     }
     _replaceScreenVideoTrack() {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_replaceScreenVideoTrack()");
+            logger$2.info("_replaceScreenVideoTrack()");
             if (!this._screenVideoTrack || !this._screenVideoProducer || this._screenVideoProducer.closed)
                 return;
             if (this._screenVideoProducer.track !== this._screenVideoTrack) {
@@ -4981,7 +5102,7 @@ class VegaRtcManager {
     }
     _sendScreenVideo(track) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_sendScreenVideo() [track:%o]", track);
+            logger$2.info("_sendScreenVideo() [track:%o]", track);
             this._screenVideoTrack = track;
             if (this._screenVideoProducer) {
                 return yield this._replaceScreenVideoTrack();
@@ -4995,7 +5116,7 @@ class VegaRtcManager {
     }
     _internalSendScreenAudio() {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_internalSendScreenAudio()");
+            logger$2.info("_internalSendScreenAudio()");
             this._screenAudioProducerPromise = (() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     if (!this._screenAudioTrack || !this._sendTransport || this._screenAudioProducer) {
@@ -5013,7 +5134,7 @@ class VegaRtcManager {
                     this._qualityMonitor.addProducer(this._selfId, producer.id);
                     producer.observer.once("close", () => {
                         var _a;
-                        logger$3.info('screenAudioProducer "close" event');
+                        logger$2.info('screenAudioProducer "close" event');
                         if (producer.appData.localClosed)
                             (_a = this._vegaConnection) === null || _a === void 0 ? void 0 : _a.message("closeProducers", { producerIds: [producer.id] });
                         this._screenAudioProducer = null;
@@ -5024,7 +5145,7 @@ class VegaRtcManager {
                         yield this._replaceScreenAudioTrack();
                 }
                 catch (error) {
-                    logger$3.error("screenAudioProducer failed:%o", error);
+                    logger$2.error("screenAudioProducer failed:%o", error);
                 }
                 finally {
                     this._screenAudioProducerPromise = null;
@@ -5038,7 +5159,7 @@ class VegaRtcManager {
     }
     _replaceScreenAudioTrack() {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_replaceScreenAudioTrack()");
+            logger$2.info("_replaceScreenAudioTrack()");
             if (!this._screenAudioTrack || !this._screenAudioProducer || this._screenAudioProducer.closed)
                 return;
             if (this._screenAudioProducer.track !== this._screenAudioTrack) {
@@ -5049,7 +5170,7 @@ class VegaRtcManager {
     }
     _sendScreenAudio(track) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_sendScreenAudio() [track:%o]", track);
+            logger$2.info("_sendScreenAudio() [track:%o]", track);
             this._screenAudioTrack = track;
             if (this._screenAudioProducer) {
                 return yield this._replaceScreenAudioTrack();
@@ -5062,7 +5183,7 @@ class VegaRtcManager {
         });
     }
     _stopProducer(producer) {
-        logger$3.info("_stopProducer()");
+        logger$2.info("_stopProducer()");
         if (!producer || producer.closed)
             return;
         producer.appData.localClosed = true;
@@ -5099,7 +5220,7 @@ class VegaRtcManager {
     }
     disconnect(clientIdOrStreamId, _activeBreakout, eventClaim) {
         var _a;
-        logger$3.info("disconnect() [clientIdOrStreamId:%s, eventClaim:%s]", clientIdOrStreamId, eventClaim);
+        logger$2.info("disconnect() [clientIdOrStreamId:%s, eventClaim:%s]", clientIdOrStreamId, eventClaim);
         const clientState = this._clientStates.get(clientIdOrStreamId);
         if (clientState) {
             clientState.hasAcceptedWebcamStream = false;
@@ -5128,7 +5249,7 @@ class VegaRtcManager {
         }
     }
     removeStream(streamId, _stream, requestedByClientId) {
-        logger$3.info("removeStream() [streamId:%s, requestedByClientId:%s]", streamId, requestedByClientId);
+        logger$2.info("removeStream() [streamId:%s, requestedByClientId:%s]", streamId, requestedByClientId);
         this._emitToSignal(PROTOCOL_REQUESTS.STOP_SCREENSHARE, {
             streamId: OUTBOUND_SCREEN_OUTBOUND_STREAM_ID,
             requestedByClientId,
@@ -5212,7 +5333,7 @@ class VegaRtcManager {
         }
     }
     stopOrResumeAudio(stream, enabled) {
-        logger$3.info("stopOrResumeAudio() [enabled:%s]", enabled);
+        logger$2.info("stopOrResumeAudio() [enabled:%s]", enabled);
         this._micPaused = !enabled;
         this._pauseResumeMic();
     }
@@ -5230,7 +5351,7 @@ class VegaRtcManager {
     }
     stopOrResumeVideo(localStream, enable) {
         var _a;
-        logger$3.info("stopOrResumeVideo() [enable:%s]", enable);
+        logger$2.info("stopOrResumeVideo() [enable:%s]", enable);
         this._webcamPaused = !enable;
         this._pauseResumeWebcam();
         if (!["chrome", "safari"].includes(browserName)) {
@@ -5274,7 +5395,7 @@ class VegaRtcManager {
         return true;
     }
     acceptNewStream({ streamId, clientId }) {
-        logger$3.info("acceptNewStream()", { streamId, clientId });
+        logger$2.info("acceptNewStream()", { streamId, clientId });
         const clientState = this._getOrCreateClientState(clientId);
         const isScreenShare = streamId !== clientId;
         if (isScreenShare) {
@@ -5289,7 +5410,7 @@ class VegaRtcManager {
     }
     updateStreamResolution(streamId, _ignored, { width, height, }) {
         var _a, _b;
-        logger$3.info("updateStreamResolution()", { streamId, width, height });
+        logger$2.info("updateStreamResolution()", { streamId, width, height });
         const consumerId = this._streamIdToVideoConsumerId.get(streamId);
         const consumer = this._consumers.get(consumerId);
         if (!consumer) {
@@ -5397,18 +5518,18 @@ class VegaRtcManager {
                     case "producerScore":
                         return this._onProducerScore(data);
                     default:
-                        logger$3.info(`unknown message method "${method}"`);
+                        logger$2.info(`unknown message method "${method}"`);
                         return;
                 }
             })
                 .catch((error) => {
-                logger$3.error('"message" failed [error:%o]', error);
+                logger$2.error('"message" failed [error:%o]', error);
             });
         });
     }
     _onConsumerReady(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_onConsumerReady()", { id: options.id, producerId: options.producerId });
+            logger$2.info("_onConsumerReady()", { id: options.id, producerId: options.producerId });
             const consumer = yield this._receiveTransport.consume(options);
             consumer.pause();
             consumer.appData.localPaused = true;
@@ -5426,7 +5547,7 @@ class VegaRtcManager {
                     consumer.rtpReceiver.playoutDelayHint = MEDIA_JITTER_BUFFER_TARGET / 1000;
                 }
                 catch (error) {
-                    logger$3.error("Error during setting jitter buffer target:", error);
+                    logger$2.error("Error during setting jitter buffer target:", error);
                 }
             }
             const { sourceClientId: clientId, screenShare, streamId } = consumer.appData;
@@ -5460,12 +5581,12 @@ class VegaRtcManager {
     _onConsumerClosed(_a) {
         return __awaiter(this, arguments, void 0, function* ({ consumerId, reason }) {
             var _b;
-            logger$3.info("_onConsumerClosed()", { consumerId, reason });
+            logger$2.info("_onConsumerClosed()", { consumerId, reason });
             (_b = this._consumers.get(consumerId)) === null || _b === void 0 ? void 0 : _b.close();
         });
     }
     _onConsumerPaused({ consumerId }) {
-        logger$3.info("_onConsumerPaused()", { consumerId });
+        logger$2.info("_onConsumerPaused()", { consumerId });
         const consumer = this._consumers.get(consumerId);
         if (!consumer)
             return;
@@ -5473,7 +5594,7 @@ class VegaRtcManager {
         consumer.pause();
     }
     _onConsumerResumed({ consumerId }) {
-        logger$3.info("_onConsumerResumed()", { consumerId });
+        logger$2.info("_onConsumerResumed()", { consumerId });
         const consumer = this._consumers.get(consumerId);
         if (!consumer)
             return;
@@ -5483,14 +5604,14 @@ class VegaRtcManager {
         }
     }
     _onConsumerScore({ consumerId, kind, score }) {
-        logger$3.info("_onConsumerScore()", { consumerId, kind, score });
+        logger$2.info("_onConsumerScore()", { consumerId, kind, score });
         const { appData: { sourceClientId }, } = this._consumers.get(consumerId) || { appData: {} };
         if (sourceClientId) {
             this._qualityMonitor.addConsumerScore(sourceClientId, consumerId, kind, score);
         }
     }
     _onProducerScore({ producerId, kind, score }) {
-        logger$3.info("_onProducerScore()", { producerId, kind, score });
+        logger$2.info("_onProducerScore()", { producerId, kind, score });
         [this._micProducer, this._webcamProducer, this._screenVideoProducer, this._screenAudioProducer].forEach((producer) => {
             if ((producer === null || producer === void 0 ? void 0 : producer.id) === producerId) {
                 this._qualityMonitor.addProducerScore(this._selfId, producerId, kind, score);
@@ -5499,7 +5620,7 @@ class VegaRtcManager {
     }
     _onDataConsumerReady(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger$3.info("_onDataConsumerReady()", { id: options.id, producerId: options.producerId });
+            logger$2.info("_onDataConsumerReady()", { id: options.id, producerId: options.producerId });
             const consumer = yield this._receiveTransport.consumeData(options);
             this._dataConsumers.set(consumer.id, consumer);
             consumer.once("close", () => {
@@ -5522,7 +5643,7 @@ class VegaRtcManager {
     }
     _onDataConsumerClosed(_a) {
         return __awaiter(this, arguments, void 0, function* ({ dataConsumerId, reason }) {
-            logger$3.info("_onDataConsumerClosed()", { dataConsumerId, reason });
+            logger$2.info("_onDataConsumerClosed()", { dataConsumerId, reason });
             const consumer = this._dataConsumers.get(dataConsumerId);
             consumer === null || consumer === void 0 ? void 0 : consumer.close();
         });
@@ -5697,119 +5818,11 @@ const getRoomMode = () => {
     return roomMode;
 };
 
-const logger$2 = new Logger();
-const debugLogger = {
-    print: (...args) => console.debug(args[0], ...args.slice(1)),
-};
-logger$2.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);
-                }
-            }
-            return;
-        }
-        if (beginNewPacketLossPeriod) {
-            history.hasActivePacketLoss = true;
-            history.currPeriod = {
-                begin: timestamp,
-            };
-        }
-    }
-    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;
-    }
-    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;
-    }
-    handleStaleMeasurements(id) {
-        const staleMeasurementTimeout = this.staleMeasurementTimeouts.get(id);
-        if (staleMeasurementTimeout) {
-            clearTimeout(staleMeasurementTimeout);
-        }
-        this.staleMeasurementTimeouts.set(id, setTimeout(() => {
-            logger$2.debug("handleStaleMeasurements() [measurements invalid for ssrc: %s]", id);
-            this.ssrcsHistory.delete(id);
-        }, this.STALE_MEASUREMENT_TIMEOUT_MS));
-    }
-    endPacketLossPeriod(history, timestamp) {
-        logger$2.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 });
-        }
-        else {
-            history.currPeriod.end = timestamp;
-            this.addNewPacketLossInterval(history);
-        }
-        delete history.currPeriod;
-        history.hasActivePacketLoss = false;
-    }
-    addNewPacketLossInterval(history) {
-        logger$2.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$2.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;
-    }
-}
-
 const packetLossAnalyser = new PacketLossAnalyser();
 const periodicPacketLossDetector = {
     id: "periodic-packet-loss",
     enabled: ({ client, hasLiveTrack, ssrc0 }) => {
-        return (client.isLocalClient &&
+        return (!!client.isLocalClient &&
             hasLiveTrack &&
             !!(ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.ssrc) &&
             (ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.direction) === "out" &&
@@ -5925,7 +5938,7 @@ const issueDetectors = [
     dryTrackIssueDetector,
     {
         id: "denoiser-context-suspended",
-        enabled: ({ client, kind }) => { var _a, _b; return client.isLocalClient && kind === "audio" && !!((_b = (_a = client.audio) === null || _a === void 0 ? void 0 : _a.track) === null || _b === void 0 ? void 0 : _b._denoiserCtx); },
+        enabled: ({ client, kind }) => { var _a, _b; return !!client.isLocalClient && kind === "audio" && !!((_b = (_a = client.audio) === null || _a === void 0 ? void 0 : _a.track) === null || _b === void 0 ? void 0 : _b._denoiserCtx); },
         check: ({ track }) => {
             var _a;
             if (!track || !("_denoiserCtx" in track))
@@ -5951,7 +5964,7 @@ const issueDetectors = [
                 if (remoteClients.some((c) => c.isAudioOnlyModeEnabled))
                     return false;
             }
-            return hasLiveTrack && client.isLocalClient && kind === "video" && !!stats;
+            return hasLiveTrack && !!client.isLocalClient && kind === "video" && !!stats;
         },
         check: ({ stats }) => {
             if (!stats)
@@ -5961,7 +5974,7 @@ const issueDetectors = [
     },
     {
         id: "quality-limitation-cpu",
-        enabled: ({ hasLiveTrack, stats, client, kind }) => hasLiveTrack && client.isLocalClient && kind === "video" && !!stats,
+        enabled: ({ hasLiveTrack, stats, client, kind }) => hasLiveTrack && !!client.isLocalClient && kind === "video" && !!stats,
         check: ({ stats }) => {
             if (!stats)
                 return false;
@@ -6064,12 +6077,12 @@ const metrics = [
     {
         id: "height",
         enabled: ({ hasLiveTrack, track, trackStats, ssrc0, kind }) => hasLiveTrack && kind === "video" && !!trackStats && !!track && !!ssrc0 && !!ssrc0.height,
-        value: ({ trackStats }) => Object.values((trackStats === null || trackStats === void 0 ? void 0 : trackStats.ssrcs) || {}).reduce((max, ssrc) => Math.max(max, ssrc.fps > 0 ? ssrc.height : 0), 0),
+        value: ({ trackStats }) => Object.values((trackStats === null || trackStats === void 0 ? void 0 : trackStats.ssrcs) || {}).reduce((max, ssrc) => Math.max(max, ssrc.fps || 0 > 0 ? ssrc.height || 0 : 0), 0),
     },
     {
         id: "sourceHeight",
         enabled: ({ hasLiveTrack, track, ssrc0, kind }) => hasLiveTrack && kind === "video" && !!track && !!ssrc0 && !!ssrc0.sourceHeight && ssrc0.direction === "out",
-        value: ({ ssrc0 }) => ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.sourceHeight,
+        value: ({ ssrc0 }) => (ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.sourceHeight) || NaN,
     },
     {
         id: "packetloss",
@@ -6079,7 +6092,7 @@ const metrics = [
     {
         id: "jitter",
         enabled: ({ hasLiveTrack, ssrc0 }) => hasLiveTrack && !!ssrc0 && !!ssrc0.bitrate && ssrc0.direction === "in",
-        value: ({ ssrc0 }) => ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.jitter,
+        value: ({ ssrc0 }) => (ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.jitter) || NaN,
     },
     {
         id: "mos",
@@ -6113,13 +6126,13 @@ const metrics = [
         id: "turn-usage",
         global: true,
         enabled: ({ stats }) => !!Object.values((stats === null || stats === void 0 ? void 0 : stats.candidatePairs) || {}).length,
-        value: ({ stats }) => Object.values((stats === null || stats === void 0 ? void 0 : stats.candidatePairs) || {}).some((cp) => cp.usingTurn),
+        value: ({ stats }) => (Object.values((stats === null || stats === void 0 ? void 0 : stats.candidatePairs) || {}).some((cp) => cp.usingTurn) ? 1 : 0),
     },
     {
         id: "turn-tls-usage",
         global: true,
         enabled: ({ stats }) => !!Object.values((stats === null || stats === void 0 ? void 0 : stats.candidatePairs) || {}).length,
-        value: ({ stats }) => Object.values((stats === null || stats === void 0 ? void 0 : stats.candidatePairs) || {}).some((cp) => cp.turnProtocol === "tls"),
+        value: ({ stats }) => Object.values((stats === null || stats === void 0 ? void 0 : stats.candidatePairs) || {}).some((cp) => cp.turnProtocol === "tls") ? 1 : 0,
     },
     {
         id: "concealment",
@@ -6129,7 +6142,7 @@ const metrics = [
             ssrc0.direction === "in" &&
             kind === "audio" &&
             (ssrc0.audioLevel || 0) >= 0.001,
-        value: ({ ssrc0 }) => ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.audioConcealment,
+        value: ({ ssrc0 }) => (ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.audioConcealment) || NaN,
     },
     {
         id: "deceleration",
@@ -6139,7 +6152,7 @@ const metrics = [
             ssrc0.direction === "in" &&
             kind === "audio" &&
             (ssrc0.audioLevel || 0) >= 0.001,
-        value: ({ ssrc0 }) => ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.audioDeceleration,
+        value: ({ ssrc0 }) => (ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.audioDeceleration) || NaN,
     },
     {
         id: "acceleration",
@@ -6149,7 +6162,7 @@ const metrics = [
             ssrc0.direction === "in" &&
             kind === "audio" &&
             (ssrc0.audioLevel || 0) >= 0.001,
-        value: ({ ssrc0 }) => ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.audioAcceleration,
+        value: ({ ssrc0 }) => (ssrc0 === null || ssrc0 === void 0 ? void 0 : ssrc0.audioAcceleration) || NaN,
     },
     {
         id: "qpf",
@@ -6192,9 +6205,6 @@ function onUpdatedStats(statsByView, clients) {
     clients.forEach((client) => {
         const stats = statsByView[client.id];
         ["video", "audio", "global"].forEach((kind) => {
-            var _a, _b;
-            if (!(kind === "global" && !client.isPresentation) && !((_a = client[kind]) === null || _a === void 0 ? void 0 : _a.enabled))
-                return;
             if (kind === "global" && !client.isLocalClient)
                 return;
             let issuesAndMetrics = issuesAndMetricsByView[client.id];
@@ -6202,7 +6212,7 @@ function onUpdatedStats(statsByView, clients) {
                 issuesAndMetrics = { issues: {}, metrics: {} };
                 issuesAndMetricsByView[client.id] = issuesAndMetrics;
             }
-            const track = (_b = client[kind]) === null || _b === void 0 ? void 0 : _b.track;
+            const track = kind === "audio" || kind === "video" ? client[kind].track : undefined;
             const hasLiveTrack = !!track && track.readyState !== "ended";
             const trackStats = track && stats && stats.tracks[track.id];
             const ssrcs = trackStats