@reactoo/watchtogether-sdk-js 2.8.48 → 2.8.52

package/src/modules/wt-room.js

@@ -1,3716 +0,0 @@
-// Watch together janus webrtc library
-
-import adapter from 'webrtc-adapter';
-import emitter from './wt-emitter';
-import {decodeJanusDisplay, generateUUID, maxJitter, median, wait} from "../models/utils";
-
-class Room {
-
-	static noop() {
-
-	}
-
-	constructor(debug) {
-		this.debug = debug;
-		this.sessions = [];
-		this.safariVp8 = false;
-		this.browser = adapter.browserDetails.browser;
-		this.browserDetails = adapter.browserDetails;
-		this.webrtcSupported = Room.isWebrtcSupported();
-		this.safariVp8TestPromise = Room.testSafariVp8();
-		this.safariVp8 = null;
-		this.safariVp8TestPromise.then(safariVp8 => {
-			this.safariVp8 = safariVp8;
-		})
-
-		this._log = Room.noop;
-		if (this.debug) {
-			this._enableDebug();
-		}
-
-		// Let's get it started
-		this.whenInitialized = this.initialize();
-	}
-
-	_enableDebug() {
-		this._log = console.log.bind(console);
-	}
-
-	initialize() {
-		return this.safariVp8TestPromise
-			.then(() => this);
-	}
-
-	createSession(constructId = null, type = 'reactooroom', options = {}) {
-		return new RoomSession(constructId, type, {debug: this.debug, ...options});
-	}
-
-	static testSafariVp8() {
-		return new Promise(resolve => {
-			if (adapter.browserDetails.browser === 'safari' &&
-				adapter.browserDetails.version >= 605) {
-				if (RTCRtpSender && RTCRtpSender.getCapabilities && RTCRtpSender.getCapabilities("video") &&
-					RTCRtpSender.getCapabilities("video").codecs && RTCRtpSender.getCapabilities("video").codecs.length) {
-					var isVp8 = false;
-					for (var i in RTCRtpSender.getCapabilities("video").codecs) {
-						var codec = RTCRtpSender.getCapabilities("video").codecs[i];
-						if (codec && codec.mimeType && codec.mimeType.toLowerCase() === "video/vp8") {
-							isVp8 = true;
-							break;
-						}
-					}
-					resolve(isVp8);
-				} else {
-					// We do it in a very ugly way, as there's no alternative...
-					// We create a PeerConnection to see if VP8 is in an offer
-					var testpc = new RTCPeerConnection({}, {});
-					testpc.createOffer({offerToReceiveVideo: true}).then(function (offer) {
-						let result = offer.sdp.indexOf("VP8") !== -1;
-						testpc.close();
-						testpc = null;
-						resolve(result);
-					});
-				}
-			} else resolve(false);
-		});
-	}
-
-	static isWebrtcSupported() {
-		return window.RTCPeerConnection !== undefined && window.RTCPeerConnection !== null &&
-			navigator.mediaDevices !== undefined && navigator.mediaDevices !== null &&
-			navigator.mediaDevices.getUserMedia !== undefined && navigator.mediaDevices.getUserMedia !== null;
-	}
-}
-
-class RoomSession {
-
-	static noop() {
-
-	}
-
-	static randomString(len) {
-		var charSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-		var randomString = '';
-		for (var i = 0; i < len; i++) {
-			var randomPoz = Math.floor(Math.random() * charSet.length);
-			randomString += charSet.substring(randomPoz, randomPoz + 1);
-		}
-		return randomString;
-	}
-
-	static sessionTypes =  {
-		'reactooroom': 'janus.plugin.reactooroom',
-		'streaming': 'janus.plugin.streaming'
-	}
-
-	static userRoleSubscriptionRules = {
-		participant: {
-			"watchparty": ['participant', 'talkback'],
-			"studio": ['participant', 'talkback', 'host', 'observer'],
-			"commentary": ['participant', 'talkback', 'host'],
-			"intercom": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5'],
-			"videowall": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5'],
-			"videowall-queue": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5'],
-			"videowall-queue-video": ['host', 'talkback', 'observer', 'observerSolo1', 'observerSolo2', 'observerSolo3', 'observerSolo4', 'observerSolo5']
-		},
-		monitor: {
-			"watchparty": ['participant', 'host'],
-			"studio": ['participant', 'host', 'observer'],
-			"commentary": ['participant', 'host'],
-			"intercom": ['host', 'participant'],
-			"videowall": ['host', 'participant'],
-			"videowall-queue": ['host', 'participant'],
-			"videowall-queue-video": ['host', 'participant'],
-		},
-		talkback: {
-			"watchparty": ['participant', 'host', 'talkback'],
-			"studio": ['participant', 'host', 'observer', 'talkback'],
-			"commentary": ['host', 'participant', 'talkback'],
-			"intercom": ['host', 'participant', 'talkback'],
-			"videowall": ['host', 'participant', 'talkback'],
-			"videowall-queue": ['host', 'participant', 'talkback'],
-			"videowall-queue-video": ['host', 'participant', 'talkback'],
-		},
-		observer: {
-			"watchparty": ['participant'],
-			"studio": ['participant'],
-			"commentary": ['participant'],
-			"intercom": ['participant'],
-			"videowall": ['participant'],
-			"videowall-queue": ['participant'],
-			"videowall-queue-video": ['participant'],
-		},
-		observerSolo1: {
-			"watchparty": ['participant'],
-			"studio": ['participant'],
-			"commentary": ['participant'],
-			"intercom": ['participant'],
-			"videowall": ['participant'],
-			"videowall-queue": ['participant'],
-			"videowall-queue-video": ['participant'],
-		},
-		observerSolo2: {
-			"watchparty": ['participant'],
-			"studio": ['participant'],
-			"commentary": ['participant'],
-			"intercom": ['participant'],
-			"videowall": ['participant'],
-			"videowall-queue": ['participant'],
-			"videowall-queue-video": ['participant'],
-		},
-		observerSolo3: {
-			"watchparty": ['participant'],
-			"studio": ['participant'],
-			"commentary": ['participant'],
-			"intercom": ['participant'],
-			"videowall": ['participant'],
-			"videowall-queue": ['participant'],
-			"videowall-queue-video": ['participant'],
-		},
-		observerSolo4: {
-			"watchparty": ['participant'],
-			"studio": ['participant'],
-			"commentary": ['participant'],
-			"intercom": ['participant'],
-			"videowall": ['participant'],
-			"videowall-queue": ['participant'],
-			"videowall-queue-video": ['participant'],
-		},
-		observerSolo5: {
-			"watchparty": ['participant'],
-			"studio": ['participant'],
-			"commentary": ['participant'],
-			"intercom": ['participant'],
-			"videowall": ['participant'],
-			"videowall-queue": ['participant'],
-			"videowall-queue-video": ['participant'],
-		},
-		host: {
-			"watchparty": [],
-			"studio": [],
-			"commentary": [],
-			"intercom": [],
-			"videowall": [],
-			"videowall-queue": [],
-			"videowall-queue-video": [],
-		},
-		companionTV: {},
-		companionPhone: {},
-	};
-
-	constructor(constructId = null, type = 'reactooroom', options = {}) {
-
-		Object.assign(this, emitter());
-		this.options = {...options};
-		this.defaultDataChannelLabel = 'JanusDataChannel'
-		this.server = null;
-		this.iceServers = null;
-		this.token = null;
-		this.roomId = null;
-		this.streamId = null;
-		this.pin = null;
-		this.userId = null;
-		this.sessiontype = type;
-		this.initialBitrate = 0;
-		this.enableDtx = false;
-		this.simulcast = false;
-		this.defaultSimulcastSettings = {
-			"default" : {
-				mode: "controlled", // controlled, manual, browserControlled
-				defaultSubstream: 0, // 2 lowest quality, 0 highest quality
-				bitrates: [
-					{
-						"rid": "l",
-						"active": true,
-						"maxBitrate": 180000,
-						"maxFramerate": 20,
-						"scaleResolutionDownBy": 3.3333333333333335,
-						"priority": "low"
-					},
-					{
-						"rid": "m",
-						"active": true,
-						"maxBitrate": 500000,
-						"maxFramerate": 25,
-						"scaleResolutionDownBy": 1.3333333333333335,
-						"priority": "low"
-					},
-					{
-						"rid": "h",
-						"active": true,
-						"maxBitrate": 2000000,
-						"maxFramerate": 30,
-						"priority": "low"
-					}
-				]
-			},
-		};
-		this.recordingFilename = null;
-		this.pluginName = RoomSession.sessionTypes[type];
-		this.id = null;
-		this.privateId = null;
-		this.constructId = constructId || RoomSession.randomString(16);
-		this.sessionId = null;
-		this.apisecret = null;
-		this.handleId = null;
-		this.ws = null;
-
-		// helper flags
-
-		this.isSupposeToBeConnected = false;
-		this.isRestarting = false;
-		this.isConnecting = false;
-		this.isDisconnecting = false;
-		this.isConnected = false;
-
-		// we added this because joined event that enables "isConnected" happened after we fired publish (long polling)
-		// as a result publish was rejected due to isConnected flag being false
-		// im' not sure what relies on current event based isConnected flag so i've added a new one that is set after join promise resolves
-		this.isPossibleToPublish = false;
-
-		this.isPublished = false;
-		this.isStreaming = false;
-		this.isMuted = [];
-		this.isVideoEnabled = false;
-		this.isAudioEnabed = false;
-		this._statsMaxLength = 31;
-		this._upStatsLength = 10;
-		this._downStatsLength = 2;
-		this._statsTimeoutStopped = true;
-		this._statsTimeoutId = null;
-		this._statsInterval = 3000;
-		this._aqInterval = 2500;
-		this._aqIntervalCounter = 0;
-		this._aqIntervalDivisor = 4;
-		this._aqTimeoutId = null;
-		this._sendMessageTimeout = 10000;
-		this._retries = 0;
-		this._maxRetries = 5;
-		this._keepAlivePeriod = 25000;
-		this._longPollTimeout = 60000;
-		this._maxev = 10;
-		this._keepAliveId = null;
-		this._participants = [];
-		this._restrictSubscribeToUserIds = []; // all if empty
-		this._talkIntercomChannels = ['participants'];
-		this._listenIntercomChannels = ['participants'];
-		this._roomType = 'watchparty';
-		this._isDataChannelOpen = false;
-		this._abortController = null;
-		this._remoteUsersCache = [];
-
-		this.userRoleSubscriptionRules = {
-			...RoomSession.userRoleSubscriptionRules,
-			...(this.options.userRoleSubscriptionRules || {})
-		}
-
-		this._log = RoomSession.noop;
-		if (this.options.debug) {
-			this._enableDebug();
-		}
-	}
-
-	_httpAPICall = function(url, options) {
-		return new Promise((resolve, reject) => {
-			const xhr = new XMLHttpRequest();
-
-			xhr.open(options.verb || 'POST', url);
-
-			// Set default headers
-			xhr.setRequestHeader('Accept', 'application/json, text/plain, */*');
-			if (options.verb === "POST") {
-				xhr.setRequestHeader('Content-Type', 'application/json');
-			}
-
-			// Handle credentials
-			if (options.withCredentials) {
-				xhr.withCredentials = true;
-			}
-
-			// Set timeout if specified
-			if (options.timeout) {
-				xhr.timeout = options.timeout;
-			}
-
-			// Setup handlers
-			xhr.onload = function() {
-				if (xhr.status >= 200 && xhr.status < 300) {
-					let response;
-					try {
-						response = JSON.parse(xhr.responseText);
-					} catch(e) {
-						if (options.error) {
-							options.error('Invalid JSON', xhr.responseText);
-						}
-						reject('Invalid JSON');
-						return;
-					}
-					if (options.success) {
-						options.success(response);
-					}
-					resolve(response);
-				} else {
-					let errorText = xhr.statusText || 'HTTP Error';
-					if (options.error) {
-						options.error(errorText, xhr.responseText);
-					}
-					reject(errorText);
-				}
-			};
-
-			xhr.onerror = function() {
-				let errorText = 'Network error';
-				if (options.error) {
-					options.error(errorText, 'Is the server down?');
-				}
-				reject(errorText);
-			};
-
-			xhr.ontimeout = function() {
-				let errorText = 'Request timed out';
-				if (options.error) {
-					options.error(errorText, 'Is the server down?');
-				}
-				reject(errorText);
-			};
-
-			// Send request
-			try {
-				if (options.body) {
-					xhr.send(JSON.stringify(options.body));
-				} else {
-					xhr.send();
-				}
-			} catch(e) {
-				if (options.error) {
-					options.error('Error sending request', e);
-				}
-				reject(e);
-			}
-		});
-	}
-
-	_pushToRemoteUsersCache(userId, streams, id) {
-		const existingIndex = this._remoteUsersCache.findIndex(u => u.userId === userId);
-		if (existingIndex > -1) {
-			this._remoteUsersCache.splice(existingIndex, 1, {userId, streams, id})
-		} else {
-			this._remoteUsersCache.push({userId, streams, id});
-		}
-	}
-
-	_removeFromRemoteUsersCache(rfid) {
-		const existingIndex = this._remoteUsersCache.findIndex(u => u.id === rfid);
-		if (existingIndex > -1) {
-			this._remoteUsersCache.splice(existingIndex, 1);
-		}
-	}
-
-	_participantShouldSubscribe(userId) {
-		const myUser = decodeJanusDisplay(this.display);
-		const remoteUser = decodeJanusDisplay(userId);
-		let localUserRole = myUser?.role || 'participant';
-		let remoteUserRole = remoteUser?.role || 'participant';
-		return this.userRoleSubscriptionRules[localUserRole][(this._roomType || 'watchparty')].indexOf(remoteUserRole) > -1
-			&& (this._restrictSubscribeToUserIds.length === 0 || this._restrictSubscribeToUserIds.indexOf(remoteUser?.userId) > -1);
-	}
-
-	_intercomSubscribe = (stream) => {
-		if(stream.type === 'data') {
-			return true;
-		}
-		const intercomGroups = JSON.parse(stream.description || "[]")?.intercomGroups || [];
-		return intercomGroups.some(g => this._listenIntercomChannels.indexOf(g) > -1);
-	};
-
-	_getAddParticipantEventName(handleId) {
-
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			this.emit('error', {
-				type: 'warning',
-				id: 15,
-				message: 'id non-existent',
-				data: [handleId, 'getParticipantEventName']
-			});
-			return;
-		}
-
-		const participantRole = decodeJanusDisplay(handle.userId)?.role;
-		switch (participantRole) {
-			case 'participant':
-				return 'addRemoteParticipant';
-			case 'talkback':
-				return 'addRemoteTalkback';
-			case 'monitor':
-				return 'addRemoteTalkback';
-			case 'observer':
-			case 'observerSolo1':
-			case 'observerSolo2':
-			case 'observerSolo3':
-			case 'observerSolo4':
-			case 'observerSolo5':
-				return 'addRemoteObserver';
-			case 'host':
-				return 'addRemoteInstructor';
-			case 'companionTV':
-				return 'addRemoteCompanionTV';
-			case 'companionPhone':
-				return 'addRemoteCompanionPhone';
-			default:
-				return 'addRemoteParticipant';
-		}
-	}
-
-	_getRemoveParticipantEventName(handleId) {
-
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			this.emit('error', {
-				type: 'warning',
-				id: 15,
-				message: 'id non-existent',
-				data: [handleId, 'getParticipantEventName']
-			});
-			return;
-		}
-
-		const participantRole = decodeJanusDisplay(handle.userId)?.role;
-		switch (participantRole) {
-			case 'participant':
-				return 'removeRemoteParticipant';
-			case 'talkback':
-				return 'removeRemoteTalkback';
-			case 'monitor':
-				return 'removeRemoteTalkback';
-			case 'observer':
-			case 'observerSolo1':
-			case 'observerSolo2':
-			case 'observerSolo3':
-			case 'observerSolo4':
-			case 'observerSolo5':
-				return 'removeRemoteObserver';
-			case 'host':
-				return 'removeRemoteInstructor';
-			case 'companionTV':
-				return 'removeRemoteCompanionTV';
-			case 'companionPhone':
-				return 'removeRemoteCompanionPhone';
-			default:
-				return 'removeRemoteParticipant';
-		}
-	}
-
-	sendMessage(handleId, message = {body: 'Example Body'}, dontWait = false, dontResolveOnAck = false, retry = 0) {
-		return this._send({
-			"janus": "message",
-			"handle_id": handleId,
-			...message
-		}, dontWait, dontResolveOnAck, retry)
-			.then(json => {
-				if (json && json["janus"] === "success") {
-					let plugindata = json["plugindata"] || {};
-					let data = plugindata["data"];
-					return Promise.resolve(data);
-				}
-				return Promise.resolve();
-			})
-			.catch(json => {
-				if (json && json["error"]) {
-					return Promise.reject({type: 'warning', id: 1, message: 'sendMessage failed', data: json["error"]})
-				} else {
-					return Promise.reject({type: 'warning', id: 1, message: 'sendMessage failed', data: json});
-				}
-			})
-	}
-
-	_sendHTTP(request = {}, ignoreResponse = false, dontResolveOnAck = false, retry = 0) {
-		let transaction = RoomSession.randomString(12);
-		let requestData = {
-			...request,
-			transaction,
-			token: this.token,
-			...((this.sessionId && {'session_id': this.sessionId}) || {}),
-			...((this.apisecret && {'apisecret': this.apisecret}) || {})
-		};
-		this._log(requestData);
-		return this._httpAPICall(this.server, {body:requestData})
-			.then(json => {
-				if(json['janus'] !== 'success' && json['janus'] !== 'ack') {
-					// TODO: check if this can stay like this
-					// not a success not an ack ... should be error
-					return Promise.reject(json["error"])
-				}
-				return json;
-			})
-	}
-	_sendWebsockets(request = {}, ignoreResponse = false, dontResolveOnAck = false, retry = 0) {
-		let transaction = RoomSession.randomString(12);
-		let requestData = {
-			...request,
-			transaction,
-			token: this.token,
-			...((this.sessionId && {'session_id': this.sessionId}) || {}),
-			...((this.apisecret && {'apisecret': this.apisecret}) || {})
-		};
-		this._log(requestData);
-		const op = () => new Promise((resolve, reject) => {
-			let messageTimeoutId = null;
-			let abortResponse = () => {
-				this._abortController.signal.removeEventListener('abort', abortResponse);
-				clearTimeout(messageTimeoutId);
-				this.ws.removeEventListener('message', parseResponse);
-				reject({type: 'warning', id: 17, message: 'connection cancelled'})
-			};
-
-			let parseResponse = (event) => {
-				let json = JSON.parse(event.data);
-				let r_transaction = json['transaction'];
-				if (r_transaction === transaction && (!dontResolveOnAck || json['janus'] !== 'ack')) {
-					clearTimeout(messageTimeoutId);
-					this._abortController.signal.removeEventListener('abort', abortResponse);
-					this.ws.removeEventListener('message', parseResponse);
-					if (json['janus'] === 'error') {
-						if (json?.error?.code == 403) {
-							this.disconnect(true);
-						}
-						reject({type: 'error', id: 2, message: 'send failed', data: json, requestData});
-					} else {
-						resolve(json);
-					}
-				}
-			};
-
-			if (ignoreResponse) {
-				if (this.ws && this.ws.readyState === 1) {
-					this.ws.send(JSON.stringify(requestData));
-				}
-				resolve();
-			} else {
-				if (this.ws && this.ws.readyState === 1) {
-					this.ws.addEventListener('message', parseResponse);
-					messageTimeoutId = setTimeout(() => {
-						this.ws.removeEventListener('message', parseResponse);
-						this._abortController.signal.removeEventListener('abort', abortResponse);
-						reject({type: 'warning', id: 3, message: 'send timeout', data: requestData});
-					}, this._sendMessageTimeout);
-					this._abortController.signal.addEventListener('abort', abortResponse);
-					this.ws.send(JSON.stringify(requestData));
-				} else {
-					reject({type: 'warning', id: 29, message: 'No connection to WebSockets', data: requestData});
-				}
-			}
-		})
-
-		return op().catch(e => {
-			if (e.id === 17) {
-				return Promise.reject(e);
-			}
-			else if(e.id === 29 && retry > 0) {
-				return wait(this._sendMessageTimeout).then(() => this._send(request, ignoreResponse, dontResolveOnAck, retry - 1));
-			}
-			else if(retry > 0) {
-				return this._send(request, ignoreResponse, dontResolveOnAck, retry - 1);
-			}
-			else {
-				return Promise.reject(e);
-			}
-		})
-	}
-	_send(request = {}, ignoreResponse = false, dontResolveOnAck = false, retry = 0) {
-		if(this.useWebsockets) {
-			return this._sendWebsockets(request, ignoreResponse, dontResolveOnAck, retry);
-		}
-		else {
-			return this._sendHTTP(request, ignoreResponse, dontResolveOnAck, retry)
-		}
-	}
-
-	_longPoll() {
-
-		if(!this.isSupposeToBeConnected) {
-			return;
-		}
-
-
-		let longpoll = this.server + "/" + this.sessionId + "?rid=" + new Date().getTime();
-		if(this._maxev)
-			longpoll = longpoll + "&maxev=" + this._maxev;
-		if(this.token)
-			longpoll = longpoll + "&token=" + encodeURIComponent(this.token);
-		if(this.apisecret)
-			longpoll = longpoll + "&apisecret=" + encodeURIComponent(this.apisecret);
-
-		this._httpAPICall(longpoll, {
-			verb: 'GET',
-			timeout: this._longPollTimeout
-		})
-			.then(this._handleWsEvents.bind(this))
-			.catch(() => {
-
-				this._retries++;
-				if(this._retries > this._maxRetries) {
-					if (this.sessiontype === 'reactooroom') {
-						this.disconnect(true);
-					} else if (this.sessiontype === 'streaming') {
-						this.stopStream();
-					}
-					this.emit('error', {type: 'error', id: 33, message: 'Lost connection to server', data: null});
-				}
-
-				this._longPoll();
-			})
-	}
-
-	_connectionClosed() {
-
-		if (!this.isConnected || this.isConnecting || this.isDisconnecting) {
-			return;
-		}
-
-		if (this._retries < this._maxRetries) {
-			//TODO: clear this timeout
-			setTimeout(() => {
-				this._retries++;
-				this._reconnect().catch(e => {
-					this.emit('error', e)
-				});
-			}, 3000 * this._retries);
-		} else {
-			if (this.sessiontype === 'reactooroom') {
-				this.disconnect(true);
-			} else if (this.sessiontype === 'streaming') {
-				this.stopStream();
-			}
-
-			this.emit('error', {type: 'error', id: 4, message: 'Lost connection to WebSockets', data: null});
-		}
-	}
-
-	_wipeListeners() {
-		if (this.ws) {
-			this.ws.removeEventListener('close', this.__connectionClosedBoundFn);
-			this.ws.removeEventListener('message', this.__handleWsEventsBoundFn);
-		}
-	}
-
-	_startKeepAlive() {
-		this._send({"janus": "keepalive"})
-			.then(json => {
-				if (json["janus"] !== 'ack') {
-					this.emit('error', {
-						type: 'warning',
-						id: 5,
-						message: 'keepalive response suspicious',
-						data: json["janus"]
-					});
-				}
-			})
-			.catch((e) => {
-				this.emit('error', {type: 'warning', id: 6, message: 'keepalive dead', data: e});
-				this._connectionClosed();
-			});
-
-		this._keepAliveId = setTimeout(() => {
-			this._startKeepAlive();
-		}, this._keepAlivePeriod);
-	}
-
-	_stopKeepAlive() {
-		clearTimeout(this._keepAliveId);
-	}
-
-	_handleWsEvents(event, skipPoll = false) {
-
-		this._retries = 0;
-
-		// we have a response from long poll, that means we need to run it again
-		if(!this.useWebsockets && !skipPoll) {
-			this._longPoll();
-		}
-
-		if(!this.useWebsockets && skipPoll) {
-			// we need to fire those events into the wild
-			this.emit('longPollEvent', event);
-		}
-
-		if(Array.isArray(event)) {
-			event.forEach(ev => this._handleWsEvents({data:ev}, true));
-			return;
-		}
-
-		let json = typeof event.data === 'string'
-			? JSON.parse(event.data)
-			: event.data;
-
-		var sender = json["sender"];
-		var type = json["janus"];
-
-		let handle = this._getHandle(sender);
-		if (!handle) {
-			return;
-		}
-
-		if (type === "trickle") {
-			let candidate = json["candidate"];
-			let config = handle.webrtcStuff;
-			if (config.pc && config.remoteSdp) {
-				if (!candidate || candidate.completed === true) {
-					config.pc.addIceCandidate(null);
-				} else {
-					config.pc.addIceCandidate(candidate);
-				}
-			} else {
-				if (!config.candidates) {
-					config.candidates = [];
-				}
-				config.candidates.push(candidate);
-			}
-		} else if (type === "webrtcup") {
-			//none universal
-		} else if (type === "hangup") {
-			this._log('hangup on', handle.handleId, handle.handleId === this.handleId, json);
-			this._removeParticipant(handle.handleId, null, false);
-		} else if (type === "detached") {
-			this._log('detached on', handle.handleId, handle.handleId === this.handleId, json);
-			this._removeParticipant(handle.handleId, null, true);
-		} else if (type === "media") {
-			this._log('Media event:', handle.handleId, json["type"], json["receiving"], json["mid"]);
-		} else if (type === "slowlink") {
-			this._log('Slowlink', handle.handleId, json["uplink"], json["lost"], json["mid"]);
-		} else if (type === "event") {
-			//none universal
-		} else if (type === 'timeout') {
-			this._log('WebSockets Gateway timeout', json);
-			this.ws.close(3504, "Gateway timeout");
-		} else if (type === 'success' || type === 'error') {
-			// we're capturing those elsewhere
-		} else {
-			this._log(`Unknown event: ${type} on session: ${this.sessionId}`);
-		}
-
-
-		// LOCAL
-
-		if (sender === this.handleId) {
-			if (type === "event") {
-
-				var plugindata = json["plugindata"] || {};
-				var msg = plugindata["data"] || {};
-				var jsep = json["jsep"];
-				let result = msg["result"] || null;
-				let event = msg["videoroom"] || null;
-				let list = msg["publishers"] || {};
-				let leaving = msg["leaving"];
-				let kicked = msg["kicked"];
-				let substream = msg["substream"];
-				let temporal = msg["temporal"];
-
-				//let joining = msg["joining"];
-				let unpublished = msg["unpublished"];
-				let error = msg["error"];
-
-				if (event === "joined") {
-					this.id = msg["id"];
-					this.privateId = msg["private_id"];
-					this.isConnected = true;
-					this.isPossibleToPublish = true;
-					this._log('We have successfully joined Room');
-					this.emit('joined', true, this.constructId);
-					this.emit('addLocalParticipant', {
-						tid: generateUUID(),
-						id: handle.handleId,
-						constructId: this.constructId,
-						userId: decodeJanusDisplay(handle.userId)?.userId,
-						role: decodeJanusDisplay(this.display)?.role,
-						track: null,
-						stream: null,
-						streamMap: {},
-						source: null,
-						adding: false,
-						removing: false,
-						hasAudioTrack: false,
-						hasVideoTrack: false,
-					});
-					for (let f in list) {
-						let userId = list[f]["display"];
-						let streams = list[f]["streams"] || [];
-						let id = list[f]["id"];
-						for (let i in streams) {
-							streams[i]["id"] = id;
-							streams[i]["display"] = userId;
-						}
-						this._log('Remote userId: ', userId);
-						this._pushToRemoteUsersCache(userId, streams, id);
-						if (this._participantShouldSubscribe(userId)) {
-							this._log('Creating user: ', userId);
-							this._createParticipant(userId, id)
-								.then(handle => {
-									this._updateParticipantsTrackData(handle.handleId, streams);
-									const subscribe = streams.filter(s => !s.disabled && this._intercomSubscribe(s)).map(stream => ({feed: stream.id, mid: stream.mid}));
-									handle.webrtcStuff.subscribeMap = structuredClone(subscribe);
-									return this.sendMessage(handle.handleId, {
-										body: {
-											"request": "join",
-											"room": this.roomId,
-											"ptype": "subscriber",
-											"private_id": this.privateId,
-											streams: subscribe,
-											//"feed": id,
-											...(this.webrtcVersion > 1000 ? {id: this.userId} : {}),
-											pin: this.pin
-										}
-									})
-								})
-								.catch(err => {
-									this.emit('error', err);
-								})
-						}
-					}
-				}
-				else if (event === "event") {
-
-					if(substream !== undefined && substream !== null) {
-						this._log('Substream event:', substream, sender);
-					}
-
-					if(temporal !== undefined && temporal !== null) {
-						this._log('Temporal event:', temporal);
-					}
-
-					if (msg["streams"] !== undefined && msg["streams"] !== null) {
-						this._log('Got my own streams back', msg["streams"]);
-					}
-
-					for (let f in list) {
-
-						let userId = list[f]["display"];
-						let streams = list[f]["streams"] || [];
-						let id = list[f]["id"];
-						for (let i in streams) {
-							streams[i]["id"] = id;
-							streams[i]["display"] = userId;
-						}
-						this._log('Remote userId: ', userId);
-
-						this._pushToRemoteUsersCache(userId, streams, id);
-
-						if (this._participantShouldSubscribe(userId)) {
-
-							let handle = this._getHandle(null, id);
-							if(handle) {
-
-								this._updateParticipantsTrackData(handle.handleId, streams)
-
-								let subscribe = streams
-									.filter(stream => !stream.disabled && this._intercomSubscribe(stream) && !this._isAlreadySubscribed(handle.handleId, stream.id, stream.mid))
-									.map(s => ({feed: s.id, mid: s.mid}));
-
-								let unsubscribe = streams.filter(stream => stream.disabled || !this._intercomSubscribe(stream))
-									.map(s => ({feed: s.id, mid: s.mid}));
-
-								this._updateSubscribeMap(handle.handleId, subscribe, unsubscribe);
-
-								this._log('Already subscribed to user: ', userId, 'Update streams', subscribe, unsubscribe);
-
-								if(subscribe.length || unsubscribe.length) {
-									this.sendMessage(handle.handleId, {
-										body: {
-											"request": "update",
-											...(subscribe.length ? {subscribe}: {}),
-											...(unsubscribe.length ? {unsubscribe}: {})
-										}
-									})
-								}
-							}
-							else {
-								this._log('Creating user: ', userId, streams);
-								this._createParticipant(userId, id)
-									.then(handle => {
-										this._updateParticipantsTrackData(handle.handleId, streams);
-										const subscribe = streams.filter(s => !s.disabled && this._intercomSubscribe(s)).map(stream => ({feed: stream.id, mid: stream.mid}));
-										handle.webrtcStuff.subscribeMap = structuredClone(subscribe);
-										return this.sendMessage(handle.handleId, {
-											body: {
-												"request": "join",
-												"room": this.roomId,
-												"ptype": "subscriber",
-												"private_id": this.privateId,
-												streams: subscribe,
-												...(this.webrtcVersion > 1000 ? {id: this.userId} : {}),
-												pin: this.pin
-											}
-										})
-									})
-									.catch(err => {
-										this.emit('error', err);
-									})
-							}
-						}
-					}
-
-					if (leaving === 'ok') {
-						this._log('leaving', this.handleId, 'this is us');
-						this._removeParticipant(this.handleId);
-						if (msg['reason'] === 'kicked') {
-							this.emit('kicked');
-							this.disconnect().catch(() => {});
-						}
-					} else if (leaving) {
-						//TODO: in 1 PeerConnection case we only unsubscribe from streams, this may not be true, check janus docs
-						this._log('leaving', leaving);
-						this._removeFromRemoteUsersCache(leaving);
-						this._removeParticipant(null, leaving, true);
-					}
-
-					if (unpublished === 'ok') {
-						this._log('unpublished', this.handleId, 'this is us');
-						this._removeParticipant(this.handleId, null, false); // we do just hangup
-					} else if (unpublished) {
-						//TODO: in 1 PeerConnection case we only unsubscribe from streams
-						this._log('unpublished', unpublished);
-						this._removeFromRemoteUsersCache(unpublished);
-						this._removeParticipant(null, unpublished, true); // we do hangup and detach
-					}
-
-					if(kicked === 'ok') {
-						// this case shouldn't exist
-					} else if(kicked) {
-						this._log('kicked', kicked);
-						this._removeFromRemoteUsersCache(kicked);
-						this._removeParticipant(null, kicked, true);  // we do hangup and detach
-					}
-
-					if (error) {
-						this.emit('error', {
-							type: 'error',
-							id: 7,
-							message: 'local participant error',
-							data: [sender, msg]
-						});
-					}
-				}
-
-				// Streaming related
-				else if (result && result["status"]) {
-					this.emit('streamingStatus', result["status"]);
-					if (result["status"] === 'stopped') {
-						this.stopStream();
-					}
-					if (result["status"] === 'started') {
-						this.emit('streaming', true);
-						this.isStreaming = true;
-					}
-				}
-
-				if (jsep !== undefined && jsep !== null) {
-					if (this.sessiontype === 'reactooroom') {
-						this._webrtcPeer(this.handleId, jsep)
-							.catch(err => {
-								this.emit('error', err);
-							});
-					} else if (this.sessiontype === 'streaming') {
-						this._publishRemote(this.handleId, jsep)
-							.catch(err => {
-								this.emit('error', err);
-							});
-					}
-
-				}
-			}
-			else if (type === "webrtcup") {
-
-				if(this.simulcast) {
-					return;
-				}
-
-				this._log('Configuring bitrate: ' + this.initialBitrate);
-				if (this.initialBitrate > 0) {
-					this.sendMessage(this.handleId, {
-						"body": {
-							"request": "configure",
-							"bitrate": this.initialBitrate
-						}
-					}).catch(() => null)
-				}
-			}
-		}
-
-		//REMOTE
-
-		else {
-
-			let plugindata = json["plugindata"] || {};
-			let msg = plugindata["data"] || {};
-			let jsep = json["jsep"];
-			let event = msg["videoroom"];
-			let error = msg["error"];
-			let substream = msg["substream"];
-			let mid = msg["mid"];
-			let temporal = msg["temporal"];
-
-			if(substream !== undefined && substream !== null) {
-				this._log('Substream: ', sender, mid, substream);
-				this._setSelectedSubstream(sender, mid, substream);
-				this._resetStats(sender, mid);
-				this.requestKeyFrame(sender, mid)
-			}
-
-			if(temporal !== undefined && temporal !== null) {
-				this._log('Temporal: ', temporal);
-			}
-
-			if(type === "webrtcup") {
-				this.requestKeyFrame(handle.handleId);
-			}
-
-			if (event === "updated") {
-				this._log('Remote has updated tracks', msg);
-				if(msg["streams"]) {
-					this._updateTransceiverMap(handle.handleId, msg["streams"]);
-				}
-			}
-
-			if (event === "attached") {
-				this._log('Remote have successfully joined Room', msg);
-				if(msg["streams"]) {
-					this._updateTransceiverMap(handle.handleId, msg["streams"] || []);
-				}
-				this.emit(this._getAddParticipantEventName(handle.handleId), {
-					tid: generateUUID(),
-					id: handle.handleId,
-					userId: decodeJanusDisplay(handle.userId)?.userId,
-					role: decodeJanusDisplay(handle.userId)?.role,
-					fullUserId: handle.userId,
-					stream: null,
-					streamMap: structuredClone(handle.webrtcStuff?.streamMap),
-					tracksMap: structuredClone(handle.webrtcStuff?.tracksMap),
-					transceiverMap: structuredClone(handle.webrtcStuff?.transceiverMap),
-					source: null,
-					track: null,
-					adding: false,
-					removing: false,
-					constructId: this.constructId,
-					hasAudioTrack: false,
-					hasVideoTrack: false
-				});
-			}
-
-			if (error) {
-				this.emit('error', {type: 'warning', id: 8, message: 'remote participant error', data: [sender, msg]});
-			}
-
-			if (jsep) {
-				this._publishRemote(handle.handleId, jsep)
-					.catch(err => {
-						this.emit('error', err);
-					});
-			}
-		}
-	}
-
-	_handleDataEvents(handleId, type, data) {
-
-		let handle = this._getHandle(handleId);
-
-		if (type === 'state') {
-			this._log(` - Data channel status - `, `UID: ${handleId}`, `STATUS: ${JSON.stringify(data)}`, `ME: ${handleId === this.handleId}`)
-			if (handle) {
-				let config = handle.webrtcStuff;
-				config.dataChannelOpen = this.defaultDataChannelLabel === data?.label && data?.state === 'open';
-			}
-
-			if (handleId === this.handleId && this.defaultDataChannelLabel === data?.label) {
-				this._isDataChannelOpen = data?.state === 'open';
-				this.emit('dataChannel', data?.state === 'open');
-			}
-		}
-
-		if (type === 'error') {
-
-			this.emit('error', {
-				type: 'warning',
-				id: 9,
-				message: 'data event warning',
-				data: [handleId, data]
-			});
-
-			if (handle) {
-				let config = handle.webrtcStuff;
-				if(this.defaultDataChannelLabel === data.label) {
-					config.dataChannelOpen = false;
-				}
-			}
-			if (handleId === this.handleId && this.defaultDataChannelLabel === data.label) {
-				this._isDataChannelOpen = false;
-				this.emit('dataChannel', false);
-			}
-		}
-
-		if (handleId === this.handleId && type === 'message') {
-
-			let d = null;
-
-			try {
-				d = JSON.parse(data)
-			} catch (e) {
-				this.emit('error', {type: 'warning', id: 10, message: 'data message parse error', data: [handleId, e]});
-				return;
-			}
-			this.emit('data', d);
-		}
-
-	}
-
-	//removeHandle === true -> hangup, detach, removeHandle === false -> hangup
-	_removeParticipant(handleId, rfid, removeHandle = true) {
-		let handle = this._getHandle(handleId, rfid);
-
-		if (!handle) {
-			return Promise.resolve();
-		} else {
-			handleId = handle.handleId;
-		}
-
-		return this._send({"janus": "hangup", "handle_id": handleId,}, true)
-			.then(() => (removeHandle ? this._send({
-				"janus": "detach",
-				"handle_id": handleId
-			}, true) : Promise.resolve()))
-			.finally(() => {
-
-				try {
-					if (handle.webrtcStuff.stream) {
-						if(!this.isRestarting) {
-							handle.webrtcStuff.stream?.getTracks().forEach(track => track.stop());
-						}
-						else {
-							handle.webrtcStuff.stream?.getTracks().forEach(track => track.onended = null);
-						}
-					}
-				} catch (e) {
-					// Do nothing
-				}
-
-				if(handle.webrtcStuff.stream) {
-					handle.webrtcStuff.stream.onremovetrack = null;
-					handle.webrtcStuff.stream = null;
-				}
-
-				if (handle.webrtcStuff.dataChannel) {
-					Object.keys(handle.webrtcStuff.dataChannel).forEach(label => {
-						handle.webrtcStuff.dataChannel[label].onmessage = null;
-						handle.webrtcStuff.dataChannel[label].onopen = null;
-						handle.webrtcStuff.dataChannel[label].onclose = null;
-						handle.webrtcStuff.dataChannel[label].onerror = null;
-					})
-				}
-				if (handle.webrtcStuff.pc) {
-					handle.webrtcStuff.pc.onicecandidate = null;
-					handle.webrtcStuff.pc.ontrack = null;
-					handle.webrtcStuff.pc.ondatachannel = null;
-					handle.webrtcStuff.pc.onconnectionstatechange = null;
-					handle.webrtcStuff.pc.oniceconnectionstatechange = null;
-				}
-				try {
-					handle.webrtcStuff.pc.close();
-				} catch (e) {
-
-				}
-				handle.webrtcStuff = {
-					stream: null,
-					streamMap: {},
-					tracksMap: [],
-					transceiverMap: [],
-					subscribeMap: [],
-					mySdp: null,
-					mediaConstraints: null,
-					pc: null,
-					dataChannelOpen: false,
-					dataChannel: null,
-					dtmfSender: null,
-					trickle: true,
-					iceDone: false,
-					isIceRestarting: false,
-					stats: {},
-					selectedSubstream: {},
-					initialSimulcastSubstreamBeenSet: {},
-					overriddenSimulcastMode: {},
-				};
-
-				if (handleId === this.handleId) {
-					this._isDataChannelOpen = false;
-					this.isPublished = false;
-					this.emit('published', false);
-					this.emit('removeLocalParticipant', {
-						id: handleId,
-						userId: decodeJanusDisplay(handle.userId)?.userId,
-						role: decodeJanusDisplay(handle.userId)?.role,
-						fullUserId: handle.userId}
-					);
-				} else {
-					this.emit(this._getRemoveParticipantEventName(handleId), {
-						id: handleId,
-						userId: decodeJanusDisplay(handle.userId)?.userId,
-						role: decodeJanusDisplay(handle.userId)?.role,
-						fullUserId: handle.userId}
-					);
-				}
-
-				if (removeHandle) {
-					let handleIndex = this._participants.findIndex(p => p.handleId === handleId);
-					this._participants.splice(handleIndex, 1);
-				}
-
-				return true;
-			});
-
-	}
-
-	_createParticipant(userId = null, rfid = null) {
-		return this._send({
-			"janus": "attach",
-			"plugin": this.pluginName,
-		}).then(json => {
-			let handleId = json.data["id"];
-			let handle = {
-				handleId,
-				rfid, userId,
-				webrtcStuff: {
-					stream: null,
-					streamMap: {},
-					tracksMap: [],
-					transceiverMap: [],
-					subscribeMap: [],
-					mySdp: null,
-					mediaConstraints: null,
-					pc: null,
-					dataChannelOpen: false,
-					dataChannel: null,
-					dtmfSender: null,
-					trickle: true,
-					iceDone: false,
-					isIceRestarting: false,
-					stats: {},
-					selectedSubstream: {},
-					initialSimulcastSubstreamBeenSet: {},
-					overriddenSimulcastMode: {},
-				}
-			};
-			this._participants.push(handle);
-			return handle;
-		})
-	}
-
-
-	_updateSubscribeMap(handleId, subscribe, unsubscribe) {
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			this.emit('error', {
-				type: 'warning',
-				id: 15,
-				message: 'id non-existent',
-				data: [handleId, 'updateSubscribeMap']
-			});
-			return;
-		}
-		let currentSubscribeMap = handle.webrtcStuff.subscribeMap;
-		subscribe.forEach(s => {
-			if(!currentSubscribeMap.find(c => c.feed === s.feed && c.mid === s.mid)) {
-				currentSubscribeMap.push(s);
-			}
-		});
-		unsubscribe.forEach(s => {
-			let index = currentSubscribeMap.findIndex(c => c.feed === s.feed && c.mid === s.mid);
-			if(index > -1) {
-				currentSubscribeMap.splice(index, 1);
-			}
-		});
-	}
-
-	_isAlreadySubscribed(handleId, feed, mid) {
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			this.emit('error', {
-				type: 'warning',
-				id: 15,
-				message: 'id non-existent',
-				data: [handleId, 'isAlreadySubscribed']
-			});
-			return false;
-		}
-		return handle.webrtcStuff.subscribeMap.findIndex(t => t.mid === mid && t.feed === feed) > -1
-	}
-
-	_updateTransceiverMap(handleId, streams) {
-		this._log('Updating current transceiver map', handleId, streams);
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			this.emit('error', {
-				type: 'warning',
-				id: 15,
-				message: 'id non-existent',
-				data: [handleId, 'updateTransceiverMap']
-			});
-			return;
-		}
-		let config = handle.webrtcStuff;
-		config.transceiverMap = structuredClone(streams);
-	}
-
-	_updateParticipantsTrackData(handleId, streams) {
-		this._log('Updating participants track data', handleId, streams);
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			this.emit('error', {
-				type: 'warning',
-				id: 15,
-				message: 'id non-existent',
-				data: [handleId, 'updateParticipantsTrackData']
-			});
-			return;
-		}
-		let config = handle.webrtcStuff;
-		config.tracksMap = structuredClone(streams.map(s => {
-			let source = null;
-			let simulcastBitrates = null;
-			try {
-				const description = JSON.parse(s.description);
-				source = description?.source;
-				simulcastBitrates = description?.simulcastBitrates;
-			} catch(e) {}
-			return {
-				active: !s.disabled,
-				description: s.description,
-				source: source,
-				simulcastBitrates: simulcastBitrates,
-				display: s.display,
-				id: s.id,
-				mid: s.mid,
-				mindex: s.mindex,
-				codec: s.codec,
-				type: s.type,
-			}
-		}));
-	}
-
-	_updateRemoteParticipantStreamMap(handleId) {
-		this._log('Updating participants stream map', handleId);
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			this.emit('error', {
-				type: 'warning',
-				id: 15,
-				message: 'id non-existent',
-				data: [handleId, 'updateRemoteParticipantStreamMap']
-			});
-			return;
-		}
-		let config = handle.webrtcStuff;
-		config.streamMap = {};
-		config.transceiverMap.forEach(tItem => {
-			if(tItem.type === 'data') {
-				return;
-			}
-			if(tItem.active === false) {
-				return;
-			}
-			const source = JSON.parse(tItem.feed_description)?.source;
-			if(!config.streamMap[source]) {
-				config.streamMap[source] = [];
-			}
-			let trackId = config.pc.getTransceivers().find(t => t.mid === tItem.mid)?.receiver?.track?.id;
-			if(trackId) {
-				config.streamMap[source].push(trackId);
-			}
-		})
-	}
-
-
-	_joinRoom(roomId, pin, userId, display) {
-		return this.sendMessage(this.handleId, {
-			body: {
-				"request": "join", "room": roomId, "pin": pin, "ptype": "publisher", "display": display, ...(this.webrtcVersion > 1000 ? {id: userId} : {})
-			}
-		}, false, true)
-	}
-
-	_watchStream(id) {
-		return this.sendMessage(this.handleId, {
-			body: {
-				"request": "watch", id: String(id)
-			}
-		}, false, true)
-	}
-
-	_leaveRoom(dontWait = false) {
-		return this.isConnected
-			? this.sendMessage(this.handleId, {body: {"request": "leave"}}, dontWait)
-				.finally(() => {
-					this.isConnected = false;
-					this.isPossibleToPublish = false;
-					this.emit('joined', false);
-				})
-			: Promise.resolve();
-	}
-
-	_webSocketConnection(reclaim = false)  {
-
-		if (this.isConnecting) {
-			return Promise.reject({type: 'warning', id: 16, message: 'connection establishment already in progress'});
-		}
-		this.isPossibleToPublish = false;
-		this.isConnecting = true;
-		this.emit('joining', true);
-
-		if (this.ws) {
-			this._wipeListeners();
-			if (this.ws.readyState === 1) {
-				this.ws.close();
-			}
-		}
-		this._stopKeepAlive();
-
-		return new Promise((resolve, reject) => {
-
-			this.__connectionClosedBoundFn = this._connectionClosed.bind(this);
-			this.__handleWsEventsBoundFn = this._handleWsEvents.bind(this);
-
-			let abortConnect = () => {
-				this._abortController.signal.removeEventListener('abort', abortConnect);
-				this.ws.removeEventListener('close', this.__connectionClosedBoundFn);
-				this.ws.removeEventListener('message', this.__handleWsEventsBoundFn);
-				this.ws.onopen = null;
-				this.ws.onerror = null;
-				this.isConnecting = false;
-				this.emit('joining', false);
-				reject({type: 'warning', id: 17, message: 'Connection cancelled'});
-			};
-
-			this.ws = new WebSocket(this.server, 'janus-protocol');
-			this.ws.addEventListener('close', this.__connectionClosedBoundFn);
-			this.ws.addEventListener('message', this.__handleWsEventsBoundFn);
-
-			this.ws.onopen = () => {
-				this._abortController.signal.removeEventListener('abort', abortConnect);
-
-				if(!reclaim) {
-
-					this._send({"janus": "create"})
-						.then(json => {
-							this._retries = 0;
-							this.sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
-							this._startKeepAlive();
-							return 1;
-						})
-						.then(() => this._createParticipant(this.userId))
-						.then(handle => {
-							this.handleId = handle.handleId;
-							return 1
-						})
-						.then(() => this._joinRoom(this.roomId, this.pin, this.userId, this.display))
-						.then(() => {
-							this._enableStatsWatch();
-							this._enableSubstreamAutoSelect();
-							this.isConnecting = false;
-							this.isPossibleToPublish = true;
-							this.emit('joining', false);
-							resolve(this);
-						})
-						.catch(error => {
-							this.isConnecting = false;
-							this.emit('joining', false);
-							reject({type: error?.type === 'warning' ? 'warning' : 'error', id: 13, message: 'connection error', data: error})
-						});
-
-				}
-
-				else {
-					this._send({"janus": "claim"})
-						.then(json => {
-							this._retries = 0;
-							this.sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
-							this._startKeepAlive();
-							this.isConnecting = false;
-							this.emit('joining', false);
-							resolve(json);
-						})
-						.catch(error => {
-							this.isConnecting = false;
-							this.emit('joining', false);
-							reject({type: 'error', id: 11, message: 'reconnection error', data: error})
-						});
-				}
-
-			};
-
-			this.ws.onerror = (e) => {
-				this._abortController.signal.removeEventListener('abort', abortConnect);
-				this.isConnecting = false;
-				this.emit('joining', false);
-				reject({type: 'error', id: 14, message: 'ws connection error', data: e});
-			}
-
-			this._abortController.signal.addEventListener('abort', abortConnect);
-
-		});
-	}
-
-	_httpConnection(reclaim = false) {
-
-		if (this.isConnecting) {
-			return Promise.reject({type: 'warning', id: 16, message: 'connection establishment already in progress'});
-		}
-		this.isPossibleToPublish = false;
-		this.isConnecting = true;
-		this.emit('joining', true);
-
-		if (this.ws) {
-			this._wipeListeners();
-			if (this.ws.readyState === 1) {
-				this.ws.close();
-			}
-		}
-		this._stopKeepAlive();
-
-		if(!reclaim) {
-			return this._send({"janus": "create"})
-				.then(json => {
-					this._retries = 0;
-					this.sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
-					this._startKeepAlive();
-					return 1;
-				})
-				.then(() => this._createParticipant(this.userId))
-				.then(handle => {
-					this.handleId = handle.handleId;
-					return 1
-				})
-				.then(() => this._joinRoom(this.roomId, this.pin, this.userId, this.display))
-				.then(() => {
-					this._enableStatsWatch();
-					this._enableSubstreamAutoSelect();
-					this._longPoll();
-					this.isConnecting = false;
-					this.isPossibleToPublish = true;
-					this.emit('joining', false);
-					return Promise.resolve(this);
-				})
-				.catch(error => {
-					this.isConnecting = false;
-					this.emit('joining', false);
-					return Promise.reject({type: error?.type === 'warning' ? 'warning' : 'error', id: 13, message: 'connection error', data: error})
-				});
-		}
-		else {
-			return this._send({"janus": "claim"})
-				.then(json => {
-					this._retries = 0;
-					this.sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
-					this._startKeepAlive();
-					this.isConnecting = false;
-					this.emit('joining', false);
-					return Promise.resolve(json);
-				})
-				.catch(error => {
-					this.isConnecting = false;
-					this.emit('joining', false);
-					return Promise.reject({type: 'error', id: 11, message: 'reconnection error', data: error})
-				});
-		}
-	}
-
-
-	// internal reconnect
-	_reconnect() {
-		if(this.useWebsockets) {
-			return this._webSocketConnection(true)
-		}
-		else {
-			return this._httpConnection(true)
-		}
-	}
-	connect(
-		roomId,
-		pin,
-		server,
-		protocol,
-		iceServers,
-		token,
-		display,
-		userId,
-		webrtcVersion = 0,
-		initialBitrate = 0,
-		recordingFilename,
-		simulcast = false,
-		simulcastSettings = this.defaultSimulcastSettings,
-		enableDtx = false
-	) {
-
-		this.isSupposeToBeConnected = true;
-
-		if (this.isConnecting) {
-			return Promise.reject({type: 'warning', id: 16, message: 'connection already in progress'});
-		}
-
-		this._abortController = new AbortController();
-
-		this.sessionId = null;
-		this.server = server;
-		this.protocol = protocol;
-		this.iceServers = iceServers;
-		this.token = token;
-		this.roomId = roomId;
-		this.pin = pin;
-		this.display = display;
-		this.userId = userId;
-		this.webrtcVersion = webrtcVersion;
-		this.initialBitrate = initialBitrate;
-		this.recordingFilename = recordingFilename;
-		this.enableDtx = enableDtx;
-		this.simulcast = simulcast;
-		this.simulcastSettings = structuredClone(simulcastSettings);
-		this.useWebsockets = this.protocol === 'ws' || this.protocol === 'wss';
-
-		// sort simulcast bitrates
-		if(this.simulcastSettings && typeof this.simulcastSettings === 'object' && Object.keys(this.simulcastSettings).length) {
-			Object.keys(this.simulcastSettings).forEach(k => {
-				this.simulcastSettings[k].bitrates = this.simulcastSettings[k].bitrates.sort((a, b) => {
-					if(a.maxBitrate === b.maxBitrate) {
-						return a.maxFramerate - b.maxFramerate;
-					}
-					return a.maxBitrate - b.maxBitrate;
-				});
-			});
-		}
-
-		if(this.useWebsockets) {
-			return this._webSocketConnection(false)
-		}
-		else {
-			return this._httpConnection(false)
-		}
-	}
-
-	disconnect() {
-
-		this.isSupposeToBeConnected = false;
-
-		if (this.isDisconnecting) {
-			return Promise.resolve();
-		}
-
-		this._abortController?.abort?.();
-		this.isPossibleToPublish = false;
-		this.isDisconnecting = true;
-		this._stopKeepAlive();
-		this._disableStatsWatch();
-		this._disableSubstreamAutoSelect();
-		let isConnected = this.isConnected;
-		return Promise.all(this._participants.map(p => this._removeParticipant(p.handleId)))
-			.finally(() => {
-				this._wipeListeners();
-				if (this.ws && this.ws.readyState === 1) {
-					this._send({"janus": "destroy"}, true);
-					this.ws.close();
-				}
-				this.sessionId = null;
-				this.isPublished = false;
-				this.isConnected = false;
-				this.isDisconnecting = false;
-				this.emit('publishing', false);
-				this.emit('published', false);
-				this.emit('joining', false);
-				this.emit('joined', false);
-				this.emit('disconnect', isConnected);
-				return Promise.resolve('Disconnected');
-			})
-	}
-
-	startStream(streamId, server, iceServers, token, userId) {
-
-		this.isSupposeToBeConnected = true;
-
-		if (this.isConnecting) {
-			return Promise.reject({type: 'warning', id: 16, message: 'connection error', data: 'Connection is in progress'});
-		}
-
-		if (this.ws) {
-			this._wipeListeners();
-		}
-
-		this._stopKeepAlive();
-		this._abortController = new AbortController();
-		this.server = server;
-		this.iceServers = iceServers;
-		this.token = token;
-		this.streamId = streamId;
-		this.userId = userId;
-		this.sessionId = null;
-		this.isConnecting = true;
-		this.emit('streamStarting', true);
-		return new Promise((resolve, reject) => {
-
-			this.ws = new WebSocket(this.server, 'janus-protocol');
-			this.__connectionClosedBoundFn = this._connectionClosed.bind(this);
-			this.__handleWsEventsBoundFn = this._handleWsEvents.bind(this);
-
-			let abortConnect = () => {
-				this._abortController.signal.removeEventListener('abort', abortConnect);
-				this.ws.removeEventListener('close', this.__connectionClosedBoundFn);
-				this.ws.removeEventListener('message', this.__handleWsEventsBoundFn);
-				this.ws.onopen = null;
-				this.ws.onerror = null;
-				this.isConnecting = false;
-				this.emit('streamStarting', false);
-				reject({type: 'warning', id: 17, message: 'Connection cancelled'});
-			};
-
-			this.ws.addEventListener('close', this.__connectionClosedBoundFn);
-			this.ws.addEventListener('message', this.__handleWsEventsBoundFn);
-			this.ws.onopen = () => {
-				this._abortController.signal.removeEventListener('abort', abortConnect);
-				this._retries = 0;
-				this._send({"janus": "create"})
-					.then(json => {
-						this.sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
-						this._startKeepAlive();
-						return 1;
-					})
-					.then(() => this._createParticipant(userId))
-					.then(handle => {
-						this.handleId = handle.handleId;
-						return 1
-					})
-					.then(() => this._watchStream(streamId))
-					.then(() => {
-						this.isConnecting = false;
-						this.emit('streamStarting', false);
-						resolve(this);
-					})
-					.catch(error => {
-						this.isConnecting = false;
-						this.emit('streamStarting', false);
-						reject({type: 'error', id: 13, message: 'connection error', data: error})
-					});
-			};
-			this.ws.onerror = (e) => {
-				this._abortController.signal.removeEventListener('abort', abortConnect);
-				this.isConnecting = false;
-				this.emit('streamStarting', false);
-				reject({type: 'error', id: 14, message: 'ws connection error', data: e});
-			}
-
-			this._abortController.signal.addEventListener('abort', abortConnect);
-		});
-	}
-
-	stopStream() {
-
-		if (this.isDisconnecting) {
-			return Promise.resolve();
-		}
-
-		this._abortController?.abort?.();
-		this._stopKeepAlive();
-
-		let isStreaming = this.isStreaming;
-		this.isPossibleToPublish = false;
-		this.isDisconnecting = true;
-		return this._removeParticipant(this.handleId)
-			.finally(() => {
-				this.sendMessage(this.handleId, {body: {"request": "stop"}}, true);
-				this._wipeListeners();
-				this._send({"janus": "destroy"}, true);
-				if (this.ws && this.ws.readyState === 1) {
-					this.ws.close();
-				}
-				this.sessionId = null;
-				this.isDisconnecting = false;
-				this.isStreaming = false;
-				this.emit('streamStarting', false);
-				this.emit('streaming', false);
-				this.emit('disconnect', isStreaming);
-				return Promise.resolve('Disconnected');
-			});
-	}
-
-	destroy() {
-
-		if (this.sessiontype === 'reactooroom') {
-			return this.disconnect()
-				.then(() => {
-					this.clear();
-					return true;
-				});
-		} else if (this.sessiontype === 'streaming') {
-			return this.stopStream()
-				.then(() => {
-					this.clear();
-					return true
-				})
-		}
-	}
-
-	_enableDebug() {
-		this._log = console.log.bind(console);
-	}
-
-	_getHandle(handleId, rfid = null, userId = null, fullUserId = null) {
-		return this._participants.find(p => p.handleId === handleId || (rfid && p.rfid === rfid) || (userId && decodeJanusDisplay(p.userId)?.userId === userId) || (fullUserId && p.userId === fullUserId));
-	}
-
-
-	_findSimulcastConfig(source, settings) {
-		return Object.keys(settings).reduce((acc, key) => {
-			if(settings[source]) {
-				return settings[source];
-			} else if(source.indexOf(key.match(/\*(.*?)\*/)?.[1]) > -1) {
-				return settings[key];
-			} else return acc;
-		}, settings['default']);
-	}
-
-	_disableStatsWatch() {
-		if (this._statsTimeoutId) {
-			clearTimeout(this._statsTimeoutId);
-			this._statsTimeoutStopped = true;
-			this._statsTimeoutId = null;
-		}
-	}
-	_enableStatsWatch() {
-		if (this._statsTimeoutId) {
-			clearTimeout(this._statsTimeoutId);
-			this._statsTimeoutId = null;
-		}
-		this._statsTimeoutStopped = false;
-		const loop = () => {
-			this._getStats('video')
-				.then(participantsStats => {
-					this._parseVideoStats(participantsStats);
-				})
-				.finally(() => {
-					if (!this._statsTimeoutStopped) {
-						this._statsTimeoutId = setTimeout(loop, this._statsInterval);
-					}
-				})
-		};
-		loop()
-	}
-
-	// This method completely ignores temporal layers
-	// We prefer higher fps and lower resolution so if the fps in not in the range of 0.7 of the max fps we go to the next lower resolution
-
-	_enableSubstreamAutoSelect() {
-
-		if(!this.simulcast) {
-			return;
-		}
-
-		if(this._aqTimeoutId) {
-			clearTimeout(this._aqTimeoutId);
-			this._aqTimeoutId = null;
-			this._aqIntervalCounter = 0;
-		}
-
-
-		const checkStats = () => {
-			this._participants.forEach(p => {
-				if(p.handleId !== this.handleId) {
-
-					const transceivers = p.webrtcStuff?.pc?.getTransceivers();
-					const mids = transceivers?.filter(t => t.receiver.track.kind === "video")?.map(t => t.mid) || [];
-					mids.forEach(mid => {
-
-						const {source, simulcastBitrates} = p.webrtcStuff.tracksMap.find(t => t.mid === mid) || {};
-
-						// track is gone
-						if(!simulcastBitrates) {
-							return;
-						}
-
-						const simulcastConfigForSource = this._findSimulcastConfig(source, this.simulcastSettings);
-						const initialSubstreamBeenSet = !!p.webrtcStuff.initialSimulcastSubstreamBeenSet[mid];
-						const defaultSelectedSubstream = p.webrtcStuff?.overriddenSimulcastMode[mid]?.defaultSubstream ?? simulcastConfigForSource?.defaultSubstream;
-						const simulcastMode = p.webrtcStuff?.overriddenSimulcastMode[mid]?.mode ?? simulcastConfigForSource?.mode;
-
-						if((simulcastMode === 'browserControlled')) {
-							// do nothing
-						}
-
-						else if((simulcastMode === 'manual' && this._aqIntervalCounter % this._aqIntervalDivisor === 0) || !initialSubstreamBeenSet) {
-							p.webrtcStuff.initialSimulcastSubstreamBeenSet[mid] = true;
-							const currentSubstream = p.webrtcStuff.selectedSubstream[mid];
-							if(defaultSelectedSubstream !== undefined && defaultSelectedSubstream !== null && defaultSelectedSubstream !== currentSubstream) {
-								this._log('Attempting to force substream quality', defaultSelectedSubstream);
-								this.selectSubStream(p.handleId, defaultSelectedSubstream, undefined, mid, false)
-									.catch((reason) => this._log(`Changing substream for mid: ${mid} failed. Reason: ${reason}`));
-							}
-						}
-
-						else if(simulcastMode === 'controlled') {
-							const currentSubstream = p.webrtcStuff.selectedSubstream[mid];
-							const settingsForCurrentSubstream = simulcastBitrates?.[simulcastBitrates.length - 1 - currentSubstream];
-
-							let directionDecision = 0;
-							if(p.webrtcStuff?.stats?.[mid]?.length > this._upStatsLength) {
-								const upMedianStats = this._calculateMedianStats(p.webrtcStuff.stats[mid].slice(this._upStatsLength * -1));
-								if(upMedianStats?.freezeDurationSinceLast < (this._upStatsLength * this._statsInterval * 0.33) / 1000 /* && upMedianStats?.freezeCountSinceLast < 3 */) {
-									directionDecision = 1;
-								}
-							}
-
-							if(p.webrtcStuff?.stats?.[mid]?.length > this._downStatsLength) {
-								const downMedianStats = this._calculateMedianStats(p.webrtcStuff.stats[mid].slice(this._downStatsLength * -1));
-								if(downMedianStats?.freezeDurationSinceLast > (this._downStatsLength * this._statsInterval * 0.33) / 1000 /*  || downMedianStats?.freezeCountSinceLast > 5 || downMedianStats?.jitter > maxJitter(settingsForCurrentSubstream.maxFramerate) */) {
-									directionDecision = -1;
-								}
-							}
-
-							if(directionDecision === -1) {
-								if(currentSubstream < simulcastBitrates.length - 1) {
-									this._log('Attempting to down the quality for mid: ', mid, ' quality:', currentSubstream + 1);
-									this._resetStats(p.handleId, mid);
-									this.selectSubStream(p.handleId, currentSubstream + 1, undefined, mid, false)
-										.catch((reason) => this._log(`Changing substream for mid: ${mid} failed. Reason: ${reason}`));
-								}
-							}
-							else if (directionDecision === 1) {
-								if(currentSubstream > 0) {
-									this._log('Attempting to up the quality for mid: ', mid, ' quality:', currentSubstream - 1);
-									this._resetStats(p.handleId, mid);
-									this.selectSubStream(p.handleId, currentSubstream - 1, undefined, mid, false)
-										.catch((reason) => this._log(`Changing substream for mid: ${mid} failed. Reason: ${reason}`));
-								}
-							}
-							else {
-								this._log('No quality change for mid: ', mid);
-							}
-						}
-					});
-				}
-			})
-
-			this._aqIntervalCounter++;
-			this._aqTimeoutId = setTimeout(checkStats, this._aqInterval);
-		}
-
-		checkStats();
-	}
-
-	_disableSubstreamAutoSelect() {
-		if(this._aqTimeoutId) {
-			clearTimeout(this._aqTimeoutId);
-			this._aqTimeoutId = null;
-			this._aqIntervalCounter = 0;
-		}
-	}
-
-	_calculateMedianStats(stats) {
-		let medianStats = {
-			framesPerSecond: null,
-			jitter: null,
-			roundTripTime: null,
-			freezeDurationSinceLast: null,
-			freezeCountSinceLast: null,
-		};
-		let keys = Object.keys(medianStats);
-		keys.forEach(key => {
-			if(key === 'freezeDurationSinceLast' || key ==='freezeCountSinceLast') {
-				medianStats[key] = stats.reduce((acc, cur) => acc + cur[key], 0);
-			}
-			// median but ignore first value of stats array
-			else {
-				let values = stats.map(s => s[key]);
-				medianStats[key] = median(values)
-			}
-
-		});
-		medianStats.statsLength = stats.length;
-		return medianStats;
-	}
-
-
-	_parseVideoStats(participantsStats) {
-
-		let statsToEmit = [];
-
-		for (const sourceStats of participantsStats) {
-
-			for (const participantStats of sourceStats) {
-
-				if (!participantStats?.handleId || participantStats.handleId === this.handleId) continue;
-
-				const handle = this._getHandle(participantStats.handleId);
-				if (!handle) continue;
-
-				const mid = participantStats.mid;
-				handle.webrtcStuff.stats[mid] ??= [];
-
-				const lastStats = handle.webrtcStuff.stats[mid][handle.webrtcStuff.stats[mid].length - 1];
-
-				const stats = {
-					framesPerSecond: null,
-					framesDropped: null,
-					totalFreezesDuration: null,
-					freezeDurationSinceLast: null,
-					freezeCount: null,
-					freezeCountSinceLast: null,
-					jitter: null,
-					packetsLost: null,
-					nackCount: null,
-					roundTripTime: null,
-					width: null,
-					height: null,
-					networkType: null,
-					powerEfficientDecoder: null,
-					selectedSubstream: null,
-					desiredSubstream: null,
-					simulcastMode: null
-				};
-
-				const simulcastConfig = this._findSimulcastConfig(participantStats.source, this.simulcastSettings);
-				const defaultSelectedSubstream = handle.webrtcStuff?.overriddenSimulcastMode[mid]?.defaultSubstream ?? simulcastConfig?.defaultSubstream;
-				const simulcastMode = handle.webrtcStuff?.overriddenSimulcastMode[mid]?.mode ?? simulcastConfig?.mode;
-
-				participantStats.stats.forEach(report => {
-
-					if (report.type === 'inbound-rtp' && report.kind === 'video') {
-						stats.framesPerSecond = report.framesPerSecond || 0;
-						stats.framesDropped = report.framesDropped || 0;
-						stats.totalFreezesDuration = report.totalFreezesDuration || 0;
-						stats.freezeDurationSinceLast = (report.totalFreezesDuration || 0) - (lastStats?.totalFreezesDuration || 0);
-						stats.freezeCount = report.freezeCount || 0;
-						stats.freezeCountSinceLast = (report.freezeCount || 0) - (lastStats?.freezeCount || 0);
-						stats.jitter = report.jitter;
-						stats.packetsLost = report.packetsLost;
-						stats.nackCount = report.nackCount;
-						stats.width = report.frameWidth;
-						stats.height = report.frameHeight;
-						stats.powerEfficientDecoder = report.powerEfficientDecoder;
-					}
-
-					if (report.type === 'candidate-pair') {
-						stats.roundTripTime = report.currentRoundTripTime;
-					}
-
-					if (report.type === 'local-candidate') {
-						stats.networkType = report.networkType;
-					}
-				});
-
-				stats.selectedSubstream = handle.webrtcStuff.selectedSubstream[mid];
-				stats.desiredSubstream = defaultSelectedSubstream;
-				stats.simulcastMode = simulcastMode;
-
-				handle.webrtcStuff.stats[mid].push(stats);
-
-				if (handle.webrtcStuff.stats[mid].length > this._statsMaxLength) {
-					handle.webrtcStuff.stats[mid].shift();
-				}
-
-				statsToEmit.push({
-					handleId: participantStats.handleId,
-					stats,
-					userId: decodeJanusDisplay(handle.userId)?.userId,
-					source: participantStats.source,
-					mid
-				});
-			}
-		}
-
-		this.emit('rtcStats', statsToEmit);
-	}
-
-	_getStats(type = null) {
-		return this._participants.reduce((promise, participant) => {
-			return promise.then(results => {
-				let mediaTrack = [];
-				if (type === 'video') {
-					mediaTrack = participant?.webrtcStuff?.stream?.getVideoTracks() || [];
-				} else if (type === 'audio') {
-					mediaTrack = participant?.webrtcStuff?.stream?.getAudioTracks() || [];
-				}
-
-				if (type !== null) {
-					const transceivers = participant?.webrtcStuff?.pc?.getTransceivers();
-					return Promise.all(mediaTrack.map(track => {
-						const source = Object.keys(participant.webrtcStuff.streamMap).find(s =>
-							participant.webrtcStuff.streamMap[s].find(t => t === track.id)
-						);
-						const mid = transceivers.find(t =>
-							t.receiver?.track?.id === track.id || t.sender?.track?.id === track.id
-						)?.mid;
-
-						return participant.webrtcStuff.pc.getStats(track)
-							.then(r => ({
-								stats: r,
-								source,
-								mid,
-								handleId: participant.handleId
-							}))
-							.catch(e => Promise.reject({
-								stats: null,
-								error: e,
-								handleId: participant.handleId,
-								source,
-								mid
-							}));
-					})).then(participantResults => [...results, participantResults]);
-				} else {
-					return participant?.webrtcStuff?.pc?.getStats(null)
-						.then(r => [...results, {
-							handleId: participant.handleId,
-							stats: r
-						}])
-						.catch(e => [...results, {
-							handleId: participant.handleId,
-							error: e
-						}]);
-				}
-			});
-		}, Promise.resolve([]));
-	}
-
-	_resetStats(handleId, mid) {
-		let handle = this._getHandle(handleId);
-		if(handle) {
-			let config = handle.webrtcStuff;
-			if(!mid) {
-				Object.keys(config.stats).forEach(mid => {
-					config.stats[mid] = [config.stats[mid][config.stats[mid].length - 1]];
-				})
-			}
-			else {
-				// clearing stats for the new substream
-				if(config.stats[mid]) {
-					config.stats[mid] = [config.stats[mid][config.stats[mid].length - 1]];
-				}
-			}
-		}
-	}
-
-	_sendTrickleCandidate(handleId, candidate) {
-		return this._send({
-			"janus": "trickle",
-			"candidate": candidate,
-			"handle_id": handleId
-		}, false, false, 5)
-	}
-
-	_webrtc(handleId, enableOntrack = false) {
-
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			this.emit('error', {
-				type: 'error',
-				id: 15,
-				message: 'id non-existent',
-				data: [handleId, 'create rtc connection']
-			});
-			return;
-		}
-
-		let config = handle.webrtcStuff;
-		if (!config.pc) {
-			let pc_config = {"iceServers": this.iceServers, "iceTransportPolicy": 'all', "bundlePolicy": undefined};
-
-			pc_config["sdpSemantics"] = "unified-plan";
-
-			let pc_constraints = {};
-
-			if (adapter.browserDetails.browser === "edge") {
-				// This is Edge, enable BUNDLE explicitly
-				pc_config.bundlePolicy = "max-bundle";
-			}
-
-			// pc_config.bundlePolicy = 'balanced';
-			// pc_config.iceTransportPolicy = 'relay';
-			// pc_config.rtcpMuxPolicy = "negotiate";
-
-			this._log('new RTCPeerConnection', pc_config, pc_constraints);
-
-			config.pc = new RTCPeerConnection(pc_config, pc_constraints);
-
-			config.pc.onnegotiationneeded = () => {
-				this._log('onnegotiationneeded');
-			};
-
-			config.pc.onconnectionstatechange = () => {
-				if (config.pc.connectionState === 'failed') {
-					this._log('connectionState failed');
-					this._iceRestart(handleId);
-				}
-				this.emit('connectionState', [handleId, handleId === this.handleId, config.pc.connectionState]);
-				if(handleId !== this.handleId && config.pc.connectionState === 'connected') {
-
-					this.emit(this._getAddParticipantEventName(handle.handleId), {
-						tid: generateUUID(),
-						id: handle.handleId,
-						userId: decodeJanusDisplay(handle.userId)?.userId,
-						role: decodeJanusDisplay(handle.userId)?.role,
-						fullUserId: handle.userId,
-						stream: config.stream,
-						streamMap: structuredClone(config.streamMap),
-						tracksMap: structuredClone(config.tracksMap),
-						transceiverMap: structuredClone(config.transceiverMap),
-						track: null,
-						source: null,
-						constructId: this.constructId,
-						adding: false,
-						removing: false,
-						hasAudioTrack: !!(config.stream && config.stream.getAudioTracks().length),
-						hasVideoTrack: !!(config.stream && config.stream.getVideoTracks().length)
-					})
-				}
-			};
-			config.pc.oniceconnectionstatechange = () => {
-				if (config.pc.iceConnectionState === 'failed') {
-					this._log('iceConnectionState failed');
-					this._iceRestart(handleId);
-				}
-				this.emit('iceState', [handleId, handleId === this.handleId, config.pc.iceConnectionState]);
-				if(handleId !== this.handleId && (config.pc.iceConnectionState === 'completed' || config.pc.iceConnectionState === 'connected')) {
-					this.emit(this._getAddParticipantEventName(handle.handleId), {
-						tid: generateUUID(),
-						id: handle.handleId,
-						userId: decodeJanusDisplay(handle.userId)?.userId,
-						role: decodeJanusDisplay(handle.userId)?.role,
-						fullUserId: handle.userId,
-						stream: config.stream,
-						streamMap: structuredClone(config.streamMap),
-						tracksMap: structuredClone(config.tracksMap),
-						transceiverMap: structuredClone(config.transceiverMap),
-						track: null,
-						source: null,
-						constructId: this.constructId,
-						adding: false,
-						hasAudioTrack: !!(config.stream && config.stream.getAudioTracks().length),
-						hasVideoTrack: !!(config.stream && config.stream.getVideoTracks().length)
-					})
-				}
-			};
-			config.pc.onicecandidate = (event) => {
-				if (event.candidate == null || (adapter.browserDetails.browser === 'edge' && event.candidate.candidate.indexOf('endOfCandidates') > 0)) {
-					config.iceDone = true;
-					this._sendTrickleCandidate(handleId, {"completed": true})
-						.catch(e => {
-							this.emit('error', e);
-						});
-				} else {
-					// JSON.stringify doesn't work on some WebRTC objects anymore
-					// See https://code.google.com/p/chromium/issues/detail?id=467366
-					var candidate = {
-						"candidate": event.candidate.candidate,
-						"sdpMid": event.candidate.sdpMid,
-						"sdpMLineIndex": event.candidate.sdpMLineIndex
-					};
-
-					this._sendTrickleCandidate(handleId, candidate)
-						.catch(e => {
-							this.emit('error', e);
-						});
-				}
-			};
-
-			if (enableOntrack) {
-				config.pc.ontrack = (event) => {
-
-					if(!event.streams)
-						return;
-
-					if (!config.stream) {
-						config.stream = new MediaStream();
-					}
-
-					if(!event.streams?.[0]?.onremovetrack) {
-						event.streams[0].onremovetrack = (ev) => {
-							this._log('Remote track removed', ev);
-							config.stream?.removeTrack(ev.track);
-
-							// check if handle still exists
-							if(!this._getHandle(handle.handleId)) {
-								return;
-							}
-							this._updateRemoteParticipantStreamMap(handle.handleId);
-
-							let transceiver = config.pc?.getTransceivers()?.find(
-								t => t.receiver.track === ev.track);
-
-							let mid = transceiver?.mid || ev.track.id;
-							let source = Object.keys(config.streamMap).find(key => config.streamMap[key].includes(ev.track.id));
-							this.emit(this._getAddParticipantEventName(handle.handleId), {
-								tid: generateUUID(),
-								id: handle.handleId,
-								mid,
-								constructId: this.constructId,
-								userId: decodeJanusDisplay(handle.userId)?.userId,
-								role: decodeJanusDisplay(handle.userId)?.role,
-								fullUserId: handle.userId,
-								stream: config.stream,
-								streamMap: structuredClone(config.streamMap),
-								tracksMap: structuredClone(config.tracksMap),
-								transceiverMap: structuredClone(config.transceiverMap),
-								source,
-								track: ev.track,
-								adding: false,
-								removing: true,
-								hasAudioTrack: !!(config.stream && config.stream.getAudioTracks().length),
-								hasVideoTrack: !!(config.stream && config.stream.getVideoTracks().length)
-							});
-						};
-					}
-
-					if (event.track) {
-						config.stream?.addTrack(event.track);
-						this._updateRemoteParticipantStreamMap(handle.handleId);
-						let mid = event.transceiver ? event.transceiver.mid : event.track.id;
-						let source = Object.keys(config.streamMap).find(key => config.streamMap[key].includes(event.track.id));
-						if(event.track.kind === 'video') {
-							this.requestKeyFrame(handle.handleId, mid);
-						}
-
-						this.emit(this._getAddParticipantEventName(handle.handleId), {
-							tid: generateUUID(),
-							mid,
-							id: handle.handleId,
-							userId: decodeJanusDisplay(handle.userId)?.userId,
-							role: decodeJanusDisplay(handle.userId)?.role,
-							fullUserId: handle.userId,
-							stream: config.stream,
-							streamMap: structuredClone(config.streamMap),
-							tracksMap: structuredClone(config.tracksMap),
-							transceiverMap: structuredClone(config.transceiverMap),
-							source,
-							track: event.track,
-							constructId: this.constructId,
-							adding: true,
-							removing: false,
-							hasAudioTrack: !!(config.stream && config.stream.getAudioTracks().length),
-							hasVideoTrack: !!(config.stream && config.stream.getVideoTracks().length)
-						});
-
-						if (event.track.onended)
-							return;
-
-						event.track.onended = (ev) => {
-							this._log('Remote track ended');
-							config.stream?.removeTrack(ev.target);
-							// check if handle still exists
-							if(!this._getHandle(handle.handleId)) {
-								return;
-							}
-							this._updateRemoteParticipantStreamMap(handle.handleId);
-							let transceiver = config.pc?.getTransceivers()?.find(
-								t => t.receiver.track === ev.target);
-							let mid = transceiver?.mid || ev.target.id;
-							let source = Object.keys(config.streamMap).find(key => config.streamMap[key].includes(ev.target.id));
-							this.emit(this._getAddParticipantEventName(handle.handleId), {
-								tid: generateUUID(),
-								id: handle.handleId,
-								mid,
-								constructId: this.constructId,
-								userId: decodeJanusDisplay(handle.userId)?.userId,
-								role: decodeJanusDisplay(handle.userId)?.role,
-								fullUserId: handle.userId,
-								stream: config.stream,
-								streamMap: structuredClone(config.streamMap),
-								tracksMap: structuredClone(config.tracksMap),
-								transceiverMap: structuredClone(config.transceiverMap),
-								source,
-								track: ev.target,
-								adding: false,
-								removing: true,
-								hasAudioTrack: !!(config.stream && config.stream.getAudioTracks().length),
-								hasVideoTrack: !!(config.stream && config.stream.getVideoTracks().length)
-							});
-						};
-
-						event.track.onmute = (ev) => {
-							this._log('Remote track muted');
-
-							let transceiver = config.pc.getTransceivers().find(
-								t => t.receiver.track === ev.target);
-							let mid = transceiver.mid || ev.target.id;
-							let source = Object.keys(config.streamMap).find(key => config.streamMap[key].includes(ev.target.id));
-							this.emit('remoteTrackMuted', {
-								id: handle.handleId,
-								mid,
-								constructId: this.constructId,
-								userId: decodeJanusDisplay(handle.userId)?.userId,
-								role: decodeJanusDisplay(handle.userId)?.role,
-								fullUserId: handle.userId,
-								stream: config.stream,
-								streamMap: structuredClone(config.streamMap),
-								source,
-								kind: ev.target.kind,
-								track: ev.target,
-								muted: true
-							});
-
-						};
-
-						event.track.onunmute = (ev) => {
-							this._log('Remote track unmuted');
-
-							let transceiver = config.pc.getTransceivers().find(
-								t => t.receiver.track === ev.target);
-							let mid = transceiver.mid || ev.target.id;
-							let source = Object.keys(config.streamMap).find(key => config.streamMap[key].includes(ev.target.id));
-
-							this.emit('remoteTrackMuted', {
-								id: handle.handleId,
-								mid,
-								constructId: this.constructId,
-								userId: decodeJanusDisplay(handle.userId)?.userId,
-								role: decodeJanusDisplay(handle.userId)?.role,
-								fullUserId: handle.userId,
-								stream: config.stream,
-								streamMap: structuredClone(config.streamMap),
-								source,
-								kind: ev.target.kind,
-								track: ev.target,
-								muted: false
-							});
-						};
-					}
-				};
-			}
-		}
-
-		if (!config.dataChannel || !config.dataChannelOpen) {
-
-			config.dataChannel = {};
-
-			var onDataChannelMessage = (event) => {
-				this._handleDataEvents(handleId, 'message', event.data);
-			};
-			var onDataChannelStateChange = (event) => {
-				let label = event.target.label;
-				let protocol = event.target.protocol;
-				let state = config.dataChannel[label] ? config.dataChannel[label].readyState : "null";
-				this._handleDataEvents(handleId, 'state', {state, label} );
-			};
-			var onDataChannelError = (error) => {
-				this._handleDataEvents(handleId, 'error', {label: error?.channel?.label, error});
-			};
-
-			const createDataChannel = (label, protocol, incoming) => {
-				let options =  {ordered: true};
-				if(!incoming) {
-					if(protocol) {
-						options = {...options, protocol}
-					}
-					config.dataChannel[label] = config.pc.createDataChannel(label, options);
-				}
-				else {
-					config.dataChannel[label] = incoming;
-				}
-
-				config.dataChannel[label].onmessage = onDataChannelMessage;
-				config.dataChannel[label].onopen = onDataChannelStateChange;
-				config.dataChannel[label].onclose = onDataChannelStateChange;
-				config.dataChannel[label].onerror = onDataChannelError;
-			}
-
-			createDataChannel(this.defaultDataChannelLabel, null,  null)
-			config.pc.ondatachannel = function (event) {
-				createDataChannel(event.channel.label, event.channel.protocol, event.channel)
-			};
-		}
-	}
-
-	_webrtcPeer(handleId, jsep) {
-
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			return Promise.reject({type: 'warning', id: 15, message: 'id non-existent', data: [handleId, 'rtc peer']});
-		}
-
-		var config = handle.webrtcStuff;
-
-		if (jsep !== undefined && jsep !== null) {
-			if (config.pc === null) {
-				this._log("No PeerConnection: if this is an answer, use createAnswer and not _webrtcPeer");
-				return Promise.resolve(null);
-			}
-
-			return config.pc.setRemoteDescription(jsep)
-				.then(() => {
-					config.remoteSdp = jsep.sdp;
-					// Any trickle candidate we cached?
-					if (config.candidates && config.candidates.length > 0) {
-						for (var i = 0; i < config.candidates.length; i++) {
-							var candidate = config.candidates[i];
-							if (!candidate || candidate.completed === true) {
-								config.pc.addIceCandidate(null);
-							} else {
-								config.pc.addIceCandidate(candidate);
-							}
-						}
-						config.candidates = [];
-					}
-					// Done
-					return true;
-				})
-				.catch((e) => {
-					return Promise.reject({type: 'warning', id: 32, message: 'rtc peer', data: [handleId, e]});
-				});
-		} else {
-			return Promise.reject({type: 'warning', id: 22, message: 'rtc peer', data: [handleId, 'invalid jsep']});
-		}
-	}
-
-	_iceRestart(handleId) {
-
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			return;
-		}
-		var config = handle.webrtcStuff;
-
-		// Already restarting;
-		if (config.isIceRestarting) {
-			return;
-		}
-
-		config.isIceRestarting = true;
-
-		if (this.handleId === handleId) {
-			this._log('Performing local ICE restart');
-			let hasAudio = !!(config.stream && config.stream.getAudioTracks().length > 0);
-			let hasVideo = !!(config.stream && config.stream.getVideoTracks().length > 0);
-			this._createAO('offer', handleId, true )
-				.then((jsep) => {
-					if (!jsep) {
-						return null;
-					}
-					return this.sendMessage(handleId, {
-						body: {"request": "configure", "keyframe": true, "audio": hasAudio, "video": hasVideo, "data": true, ...(this.recordingFilename ? {filename: this.recordingFilename} : {})},
-						jsep
-					}, false, false, 5);
-				})
-				.then(r => {
-					config.isIceRestarting = false;
-					this._log('ICE restart success');
-				})
-				.catch((e) => {
-					config.isIceRestarting = false;
-					this.emit('error', {type: 'warning', id: 28, message: 'iceRestart failed', data: e});
-				});
-		} else {
-			this._log('Performing remote ICE restart', handleId);
-			return this.sendMessage(handleId, {
-				body: {"request": "configure", "restart": true}
-			}, false, false, 5).then(() => {
-			}).then(() => {
-				config.isIceRestarting = false;
-				this._log('ICE restart success');
-			}).catch(() => {
-				config.isIceRestarting = false;
-			});
-		}
-	}
-
-	_setupTransceivers(handleId, [audioSend, audioRecv, videoSend, videoRecv, audioTransceiver = null, videoTransceiver = null]) {
-		//TODO: this should be refactored to use handle's trackMap so we dont have to pass any parameters
-
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			return null;
-		}
-		let config = handle.webrtcStuff;
-
-		const setTransceiver = (transceiver, send, recv, kind = 'audio') => {
-			if (!send && !recv) {
-				// disabled: have we removed it?
-				if (transceiver) {
-					if (transceiver.setDirection) {
-						transceiver.setDirection("inactive");
-					} else {
-						transceiver.direction = "inactive";
-					}
-				}
-			} else {
-				if (send && recv) {
-					if (transceiver) {
-						if (transceiver.setDirection) {
-							transceiver.setDirection("sendrecv");
-						} else {
-							transceiver.direction = "sendrecv";
-						}
-					}
-				} else if (send && !recv) {
-					if (transceiver) {
-						if (transceiver.setDirection) {
-							transceiver.setDirection("sendonly");
-						} else {
-							transceiver.direction = "sendonly";
-						}
-					}
-				} else if (!send && recv) {
-					if (transceiver) {
-						if (transceiver.setDirection) {
-							transceiver.setDirection("recvonly");
-						} else {
-							transceiver.direction = "recvonly";
-						}
-					} else {
-						// In theory, this is the only case where we might not have a transceiver yet
-						config.pc.addTransceiver(kind, {direction: "recvonly"});
-					}
-				}
-			}
-		}
-
-		// if we're passing any transceivers, we work only on them, doesn't matter if one of them is null
-		if(audioTransceiver || videoTransceiver) {
-			if(audioTransceiver) {
-				setTransceiver(audioTransceiver, audioSend, audioRecv, 'audio');
-			}
-			if(videoTransceiver) {
-				setTransceiver(videoTransceiver, videoSend, videoRecv, 'video');
-			}
-		}
-		// else we work on all transceivers
-		else {
-			let transceivers = config.pc.getTransceivers();
-			if (transceivers && transceivers.length > 0) {
-				for (let i in transceivers) {
-					let t = transceivers[i];
-					if (
-						(t.sender && t.sender.track && t.sender.track.kind === "audio") ||
-						(t.receiver && t.receiver.track && t.receiver.track.kind === "audio")
-					) {
-						setTransceiver(t, audioSend, audioRecv, 'audio');
-					}
-					if (
-						(t.sender && t.sender.track && t.sender.track.kind === "video") ||
-						(t.receiver && t.receiver.track && t.receiver.track.kind === "video")
-					) {
-						setTransceiver(t, videoSend, videoRecv, 'video');
-					}
-				}
-			}
-		}
-	}
-
-	_createAO(type = 'offer', handleId, iceRestart = false, ) {
-
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			return Promise.reject({
-				type: 'warning',
-				id: 15,
-				message: 'id non-existent',
-				data: [handleId, 'createAO', type]
-			});
-		}
-
-		let methodName = null;
-		if (type === 'offer') {
-			methodName = 'createOffer'
-		} else {
-			methodName = 'createAnswer'
-		}
-
-		let config = handle.webrtcStuff;
-		let mediaConstraints = {};
-
-		if (iceRestart) {
-			mediaConstraints["iceRestart"] = true;
-		}
-
-		return config.pc[methodName](mediaConstraints)
-			.then( (response) => {
-
-				// if type offer and its me and we want dtx we mungle the sdp
-				if(handleId === this.handleId && type === 'offer' && this.enableDtx) {
-					// enable DTX
-					response.sdp = response.sdp.replace("useinbandfec=1", "useinbandfec=1;usedtx=1")
-				}
-
-				config.mySdp = response.sdp;
-				let _p = config.pc.setLocalDescription(response)
-					.catch((e) => {
-						return Promise.reject({
-							type: 'warning',
-							id: 24,
-							message: 'setLocalDescription',
-							data: [handleId, e]
-						})
-					});
-				config.mediaConstraints = mediaConstraints;
-				if (!config.iceDone && !config.trickle) {
-					// Don't do anything until we have all candidates
-					return Promise.resolve(null);
-				}
-
-				// JSON.stringify doesn't work on some WebRTC objects anymore
-				// See https://code.google.com/p/chromium/issues/detail?id=467366
-				var jsep = {
-					"type": response.type,
-					"sdp": response.sdp
-				};
-
-				if(response.e2ee)
-					jsep.e2ee = true;
-				if(response.rid_order === "hml" || response.rid_order === "lmh")
-					jsep.rid_order = response.rid_order;
-				if(response.force_relay)
-					jsep.force_relay = true;
-
-				return _p.then(() => jsep)
-			}, (e) => {
-				return Promise.reject({type: 'warning', id: 25, message: methodName, data: [handleId, e]})
-			});
-
-	}
-
-	_addSimulcastToSDP(sdp) {
-		// Split SDP into lines
-		let sdpLines = sdp.split('\n');
-
-		// Find the index of the video m-line
-		let videoIndex = sdpLines.findIndex(line => line.startsWith('m=video'));
-		if (videoIndex === -1) {
-			// No video m-line found
-			return sdp;
-		}
-
-		// We need to insert the lines after the mid attribute
-		// Find the index of the 'a=mid' line in the video section
-		let midIndex = sdpLines.findIndex((line, index) =>
-			index > videoIndex && line.startsWith('a=mid:')
-		);
-
-		if (midIndex === -1) {
-			// No 'a=mid' line found in video m-section
-			return sdp;
-		}
-
-		// Prepare the simulcast attributes
-		const simulcastLines = [
-			'a=rid:l recv',
-			'a=rid:m recv',
-			'a=rid:h recv',
-			'a=simulcast:recv l;m;h'
-		];
-
-		// Prepare the extmap attributes for RID and Repaired RID
-		const extmapId = sdpLines.reduce((maxId, line) => {
-			const match = line.match(/a=extmap:(\d+)/);
-			return match ? Math.max(maxId, parseInt(match[1])) : maxId;
-		}, 0);
-
-		const extmapLines = [
-			`a=extmap:${extmapId + 1} urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id`,
-			`a=extmap:${extmapId + 2} urn:ietf:params:rtp-hdrext:sdes:repaired-rtp-stream-id`
-		];
-
-		// Insert the extmap lines after the last existing extmap in the video section
-		let lastExtmapIndex = midIndex;
-		for (let i = midIndex + 1; i < sdpLines.length; i++) {
-			if (sdpLines[i].startsWith('a=extmap:')) {
-				lastExtmapIndex = i;
-			} else if (sdpLines[i].startsWith('a=')) {
-				// Reached another attribute
-				break;
-			}
-		}
-
-		// Check if the attributes are already present
-		const hasSimulcast = sdpLines.some(line => line.startsWith('a=simulcast'));
-		const hasRidExtmap = sdpLines.some(line => line.includes('urn:ietf:params:rtp-hdrext:sdes:rtp-stream-id'));
-
-		if (!hasRidExtmap) {
-			// Insert the extmap lines
-			sdpLines.splice(lastExtmapIndex + 1, 0, ...extmapLines);
-		}
-
-		if (!hasSimulcast) {
-			// Insert the simulcast lines after the 'a=mid' line
-			sdpLines.splice(midIndex + 1, 0, ...simulcastLines);
-		}
-
-		// Return the modified SDP
-		return sdpLines.join('\n');
-	}
-
-
-	_publishRemote(handleId, jsep) {
-		let handle = this._getHandle(handleId);
-		if (!handle) {
-			return Promise.reject({
-				type: 'warning',
-				id: 15,
-				message: 'id non-existent',
-				data: [handleId, 'publish remote participant']
-			})
-		}
-
-		this._webrtc(handleId, true);
-
-		let config = handle.webrtcStuff;
-
-		if (jsep) {
-
-			// Just For Debugging
-			// Munge the SDP before setting the remote description
-			// if (jsep && jsep.sdp) {
-			// 	jsep.sdp = this._addSimulcastToSDP(jsep.sdp);
-			// }
-
-			return config.pc.setRemoteDescription(jsep)
-				.then(() => {
-					config.remoteSdp = jsep.sdp;
-					// Any trickle candidate we cached?
-					if (config.candidates && config.candidates.length > 0) {
-						for (var i = 0; i < config.candidates.length; i++) {
-							var candidate = config.candidates[i];
-							if (!candidate || candidate.completed === true) {
-								// end-of-candidates
-								config.pc.addIceCandidate(null);
-							} else {
-								// New candidate
-								config.pc.addIceCandidate(candidate);
-							}
-						}
-						config.candidates = [];
-					}
-
-					this._setupTransceivers(handleId, [false, true, false, true]);
-
-					// Create the answer now
-					return this._createAO('answer', handleId, false)
-						.then(_jsep => {
-							if (!_jsep) {
-								this.emit('error', {
-									type: 'warning',
-									id: 19,
-									message: 'publish remote participant',
-									data: [handleId, 'no jsep']
-								});
-								return Promise.resolve();
-							}
-							return this.sendMessage(handleId, {
-								"body": {"request": "start", ...(this.roomId && {"room": this.roomId}), ...(this.pin && {pin: this.pin})},
-								"jsep": _jsep
-							});
-						})
-				}, (e) => Promise.reject({
-					type: 'warning',
-					id: 23,
-					message: 'setRemoteDescription',
-					data: [handleId, e]
-				}));
-
-		} else {
-			return Promise.resolve();
-		}
-
-	}
-
-	//Public methods
-	_republishOnTrackEnded(source) {
-		let handle = this._getHandle(this.handleId);
-		if (!handle) {
-			return;
-		}
-		let config = handle.webrtcStuff;
-		if (!config.stream) {
-			return;
-		}
-		let sourceTrackIds = (config.streamMap[source] || []);
-		let remainingTracks = [];
-		for(let i = 0; i < sourceTrackIds.length; i++) {
-			let foundTrack = config.stream.getTracks().find(t => t.id === sourceTrackIds[i]);
-			if(foundTrack) {
-				remainingTracks.push(foundTrack);
-			}
-		}
-		if (remainingTracks.length) {
-			let stream = new MediaStream();
-			remainingTracks.forEach(track => stream.addTrack(track));
-			return this.publishLocal(stream, source);
-		}
-		else {
-			return this.publishLocal(null, source);
-		}
-	};
-
-
-	publishLocal(stream = null, source = 'camera0') {
-
-		if(!this.isPossibleToPublish) {
-			return Promise.reject({
-				type: 'warning',
-				id: 18,
-				message: 'Either not connected or disconnecting',
-			})
-		}
-
-		if(stream?.getVideoTracks()?.length > 1) {
-			return Promise.reject({
-				type: 'warning',
-				id: 30,
-				message: 'multiple video tracks not supported',
-				data: null
-			})
-		}
-
-		if(stream?.getAudioTracks()?.length > 1) {
-			return Promise.reject({
-				type: 'warning',
-				id: 30,
-				message: 'multiple audio tracks not supported',
-				data: null
-			})
-		}
-
-		let handle = this._getHandle(this.handleId);
-		if (!handle) {
-			return Promise.reject({
-				type: 'error',
-				id: 31,
-				message: 'no local id, connect before publishing',
-				data: null
-			})
-		}
-
-		this.emit('publishing', true);
-
-		this._webrtc(this.handleId);
-
-		let config = handle.webrtcStuff;
-
-		if (!config.stream) {
-			config.stream = new MediaStream();
-		}
-
-		let needsNegotiation = !this.isPublished;
-		let transceivers = config.pc.getTransceivers();
-		let existingTracks = [...(config.streamMap[source] || [])];
-
-		if(stream?.getTracks().length) {
-			config.streamMap[source] = stream?.getTracks()?.map(track => track.id) || [];
-		} else {
-			delete config.streamMap[source];
-		}
-
-		// remove old audio track related to this source
-		let oldAudioStream = config?.stream?.getAudioTracks()?.find(track => existingTracks.includes(track.id));
-		if (oldAudioStream) {
-			try {
-				oldAudioStream.stop();
-
-			} catch (e) {
-				this._log(e);
-			}
-			config.stream.removeTrack(oldAudioStream);
-		}
-
-		// remove old video track related to this source
-		let oldVideoStream = config?.stream?.getVideoTracks()?.find(track => existingTracks.includes(track.id));
-		if (oldVideoStream) {
-			try {
-				oldVideoStream.stop();
-			} catch (e) {
-				this._log(e);
-			}
-			config.stream.removeTrack(oldVideoStream);
-		}
-
-		const simulcastConfigForSource = this._findSimulcastConfig(source, this.simulcastSettings);
-		let audioTrackReplacePromise = Promise.resolve();
-		let videoTrackReplacePromise = Promise.resolve();
-
-		let audioTransceiver = null;
-		let videoTransceiver = null;
-		let replaceAudio = stream?.getAudioTracks()?.length;
-		let replaceVideo = stream?.getVideoTracks()?.length;
-
-		for(const transceiver of transceivers) {
-			if(['sendonly', 'sendrecv'].includes(transceiver.currentDirection) && transceiver.sender?.track?.kind === 'audio' && existingTracks.includes(transceiver.sender?.track?.id)) {
-				audioTransceiver = transceiver;
-			}
-			else if(['sendonly', 'sendrecv'].includes(transceiver.currentDirection) && transceiver.sender?.track?.kind === 'video' && existingTracks.includes(transceiver.sender?.track?.id)) {
-				videoTransceiver = transceiver;
-			}
-
-			// Reusing existing transceivers
-			// TODO: if we start using different codecs for different sources, we need to check for that here
-
-			else if(transceiver.currentDirection === 'inactive' && transceiver.sender?.getParameters()?.codecs?.find(c => c.mimeType.indexOf('audio') > -1) && replaceAudio && !audioTransceiver) {
-				audioTransceiver = transceiver;
-				needsNegotiation = true;
-			}
-			else if(transceiver.currentDirection === 'inactive' && transceiver.sender?.getParameters()?.codecs?.find(c => c.mimeType.indexOf('video') > -1) && replaceVideo && !videoTransceiver) {
-				videoTransceiver = transceiver;
-				needsNegotiation = true;
-			}
-		}
-
-		if (replaceAudio) {
-			config.stream.addTrack(stream.getAudioTracks()[0]);
-			if (audioTransceiver && audioTransceiver.sender) {
-				audioTrackReplacePromise = audioTransceiver.sender.replaceTrack(stream.getAudioTracks()[0]);
-			} else {
-				config.pc.addTrack(stream.getAudioTracks()[0], config.stream);
-				needsNegotiation = true;
-			}
-		}
-		else {
-			if (audioTransceiver && audioTransceiver.sender) {
-				audioTrackReplacePromise = audioTransceiver.sender.replaceTrack(null);
-				needsNegotiation = true;
-			}
-		}
-
-		if (replaceVideo) {
-			config.stream.addTrack(stream.getVideoTracks()[0]);
-			if (videoTransceiver && videoTransceiver.sender) {
-				videoTrackReplacePromise = videoTransceiver.sender.replaceTrack(stream.getVideoTracks()[0]);
-			} else {
-				if(!this.simulcast) {
-					config.pc.addTrack(stream.getVideoTracks()[0], config.stream);
-				}
-				else {
-					config.pc.addTransceiver(stream.getVideoTracks()[0], {
-						direction: 'sendonly',
-						streams: [config.stream],
-						sendEncodings: structuredClone(simulcastConfigForSource?.bitrates)
-					})
-				}
-				needsNegotiation = true;
-			}
-		}
-		else {
-			if (videoTransceiver && videoTransceiver.sender) {
-				videoTrackReplacePromise = videoTransceiver.sender.replaceTrack(null);
-				needsNegotiation = true;
-			}
-		}
-
-
-		this.isAudioEnabed = !!(config.stream && config.stream.getAudioTracks().length > 0);
-		this.isVideoEnabled = !!(config.stream && config.stream.getVideoTracks().length > 0);
-
-		// we possibly created new transceivers, so we need to get them again
-		transceivers = config.pc.getTransceivers();
-		existingTracks = [...(config.streamMap[source] || [])];
-		if(!audioTransceiver) {
-			audioTransceiver = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'audio' && existingTracks.includes(transceiver.sender.track.id))
-		}
-		if(!videoTransceiver) {
-			videoTransceiver = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'video' && existingTracks.includes(transceiver.sender.track.id))
-		}
-
-		let hasAudio = !!(stream && stream.getAudioTracks().length > 0);
-		let hasVideo = !!(stream && stream.getVideoTracks().length > 0);
-
-		this._setupTransceivers(this.handleId, [hasAudio, false, hasVideo, false, audioTransceiver, videoTransceiver]);
-
-		const emitEvents = () => {
-			this.isPublished = true;
-
-			if(!config.stream.onremovetrack) {
-				config.stream.onremovetrack = (ev) => {};
-			}
-
-			let republishTimeoutId = null;
-			let tracks = config.stream.getTracks();
-
-			this.emit('addLocalParticipant', {
-				tid: generateUUID(),
-				id: handle.handleId,
-				userId: decodeJanusDisplay(handle.userId)?.userId,
-				role: decodeJanusDisplay(this.display)?.role,
-				stream: tracks.length ? config.stream : null, // that null is there due to backward compatibility
-				track: null,
-				streamMap: structuredClone(config.streamMap),
-				source,
-				adding: false,
-				removing: false,
-				constructId: this.constructId,
-				hasAudioTrack: hasAudio,
-				hasVideoTrack: hasVideo
-			});
-
-			if(tracks.length) {
-				tracks.forEach(track => {
-					// used as a flag to not emit tracks that been already emitted
-					if(!track.onended) {
-
-						this.emit('addLocalParticipant', {
-							tid: generateUUID(),
-							id: handle.handleId,
-							userId: decodeJanusDisplay(handle.userId)?.userId,
-							role: decodeJanusDisplay(this.display)?.role,
-							track,
-							stream: config.stream,
-							streamMap: structuredClone(config.streamMap),
-							source,
-							adding: true,
-							removing: false,
-							constructId: this.constructId,
-							hasAudioTrack: hasAudio,
-							hasVideoTrack: hasVideo
-						});
-
-						track.onended = (ev) => {
-							config.stream.removeTrack(track);
-							clearTimeout(republishTimeoutId);
-							republishTimeoutId = setTimeout(() => {
-								this._republishOnTrackEnded(source);
-							}, 100);
-
-						}
-					}
-				})
-			}
-
-			this.isMuted = [];
-			for(const source of Object.keys(config.streamMap)) {
-				const audioTrack = config.stream?.getAudioTracks()?.find(track => config.streamMap[source].includes(track.id));
-				const videoTrack = config.stream?.getVideoTracks()?.find(track => config.streamMap[source].includes(track.id));
-				this.isMuted.push({type: 'audio', value: !audioTrack || !audioTrack.enabled, source, mid: transceivers.find(transceiver => transceiver.sender?.track?.kind === 'audio' && transceiver.sender?.track?.id === audioTrack?.id)?.mid});
-				this.isMuted.push({type: 'video', value: !videoTrack || !videoTrack.enabled, source, mid: transceivers.find(transceiver => transceiver.sender?.track?.kind === 'video' && transceiver.sender?.track?.id === videoTrack?.id)?.mid});
-				this.emit('localHasVideo', !!videoTrack, source);
-				this.emit('localHasAudio', !!audioTrack, source);
-			}
-			for(const val of this.isMuted) {
-				this.emit('localMuted', {...val});
-			}
-			this.emit('published', true);
-			this.emit('publishing', false);
-			return this;
-		};
-
-		// this should be enough
-		if(!needsNegotiation) {
-			return Promise
-				.all([audioTrackReplacePromise, videoTrackReplacePromise])
-				.then(() => emitEvents())
-		}
-
-		this._log('Starting negotiation');
-
-		return Promise
-			.all([audioTrackReplacePromise, videoTrackReplacePromise])
-			.then(() => this._createAO('offer', this.handleId, false))
-			.then((jsep) => {
-				if (!jsep) {
-					return null;
-				}
-				//HOTFIX: Temporary fix for Safari 13
-				if (jsep.sdp && jsep.sdp.indexOf("\r\na=ice-ufrag") === -1) {
-					jsep.sdp = jsep.sdp.replace("\na=ice-ufrag", "\r\na=ice-ufrag");
-				}
-
-
-				let descriptions = [];
-				Object.keys(config.streamMap).forEach(source => {
-					const simulcastConfigForSource = this._findSimulcastConfig(source, this.simulcastSettings);
-					config.streamMap[source].forEach(trackId => {
-						let t = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.id === trackId)
-						if(t) {
-							descriptions.push({mid: t.mid, description: JSON.stringify({source, simulcastBitrates: simulcastConfigForSource?.bitrates, intercomGroups: this._talkIntercomChannels})});
-						}
-					})
-				});
-
-				return this.sendMessage(this.handleId, {
-					body: {
-						"request": "configure",
-						"audio": this.isAudioEnabed,
-						"video": this.isVideoEnabled,
-						"data": true,
-						...(this.recordingFilename ? {filename: this.recordingFilename} : {}),
-						descriptions: descriptions
-					},
-					jsep
-				});
-			})
-			.then((r) => {
-				if (this._isDataChannelOpen === true) {
-					return Promise.resolve(r)
-				} else {
-					return new Promise((resolve, reject) => {
-
-						let dataChannelTimeoutId = null;
-
-						let _resolve = (val) => {
-							if (val) {
-								clearTimeout(dataChannelTimeoutId);
-								this._abortController.signal.removeEventListener('abort', _rejectAbort);
-								this.off('dataChannel', _resolve, this);
-								resolve(this);
-							}
-						};
-
-						let _rejectTimeout = () => {
-							this.off('dataChannel', _resolve, this);
-							this._abortController.signal.removeEventListener('abort', _rejectAbort);
-							reject({type: 'error', id: 27, message: 'Data channel did not open', data: null});
-						}
-
-						let _rejectAbort = () => {
-							this._abortController.signal.removeEventListener('abort', _rejectAbort);
-							clearTimeout(dataChannelTimeoutId);
-							this.off('dataChannel', _resolve, this);
-							reject({type: 'warning', id: 17, message: 'Connection cancelled'})
-						}
-
-						dataChannelTimeoutId = setTimeout(_rejectTimeout, 10000);
-						this._abortController.signal.addEventListener('abort', _rejectAbort);
-
-						this.on('dataChannel', _resolve, this);
-					});
-				}
-			})
-			.then(() => emitEvents())
-			.catch(e => {
-				this.emit('publishing', false);
-				return Promise.reject(e);
-			})
-	}
-
-	unpublishLocal(dontWait = false) {
-		return this.isPublished
-			? this.sendMessage(this.handleId, {body: {"request": "unpublish"}}, dontWait)
-				.finally(r => {
-					this.isPublished = false;
-					this.emit('published', false);
-					return r
-				})
-			: Promise.resolve()
-	}
-
-	getUserTalkIntercomChannels(userId) {
-		let talkIntercomChannels = []
-		// TODO: check if we don't need full userId
-		let handle = this._getHandle(null, null, userId);
-		if (handle) {
-			let config = handle.webrtcStuff;
-			talkIntercomChannels = config.tracksMap.reduce((acc, val) => {
-				if(val.description) {
-					try {
-						let description = JSON.parse(val.description);
-						if(description.intercomGroups) {
-							description.intercomGroups.forEach(group => {
-								if(!acc.includes(group)) {
-									acc.push(group);
-								}
-							});
-						}
-					}
-					catch(e) {}
-				}
-				return acc;
-			}, []);
-		}
-		return talkIntercomChannels;
-	}
-
-	toggleAudio(value = null, source = 'camera0', mid) {
-		let handle = this._getHandle(this.handleId);
-		if (!handle) {
-			this.emit('error', {
-				type: 'warning',
-				id: 21,
-				message: 'no local id, connect first', data: null
-			});
-			return;
-		}
-		let config = handle.webrtcStuff;
-		let transceivers = config.pc?.getTransceivers();
-		let transceiver = null;
-		if(source) {
-			transceiver = transceivers?.find(t => t.sender && t.sender.track && t.receiver.track.kind === "audio" && (config.streamMap[source] || []).includes(t.sender.track.id));
-		}
-		else {
-			transceiver = transceivers?.find(t => t.sender && t.sender.track && t.receiver.track.kind === "audio" && (mid ? t.mid === mid : true));
-		}
-		if (transceiver) {
-			transceiver.sender.track.enabled = value !== null ? !!value : !transceiver.sender.track.enabled;
-		}
-
-		this.isMuted = [];
-		for(const source of Object.keys(config.streamMap)) {
-			const audioTrack = config.stream?.getAudioTracks()?.find(track => config.streamMap[source].includes(track.id));
-			const audioTransceiver = transceivers?.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'audio' && transceiver.sender.track.id === audioTrack?.id);
-			const videoTrack = config.stream?.getVideoTracks()?.find(track => config.streamMap[source].includes(track.id));
-			const videoTransceiver = transceivers?.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'video' && transceiver.sender.track.id === videoTrack?.id);
-			this.isMuted.push({type: 'audio', value: !audioTrack || !audioTransceiver || !audioTransceiver?.sender?.track?.enabled , source, mid: audioTransceiver?.mid});
-			this.isMuted.push({type: 'video', value: !videoTrack || !videoTransceiver || !videoTransceiver?.sender?.track?.enabled, source, mid: videoTransceiver?.mid});
-		}
-		for(let val of this.isMuted) {
-			this.emit('localMuted', {...val});
-		}
-	}
-
-	toggleVideo(value = null, source = 'camera0', mid) {
-		let handle = this._getHandle(this.handleId);
-		if (!handle) {
-			this.emit('error', {
-				type: 'warning',
-				id: 21,
-				message: 'no local id, connect first', data: null
-			});
-			return;
-		}
-		let config = handle.webrtcStuff;
-		let transceivers = config.pc?.getTransceivers();
-		let transceiver = null;
-		if(source) {
-			transceiver = transceivers?.find(t => t.sender && t.sender.track && t.receiver.track.kind === "video" && (config.streamMap[source] || []).includes(t.sender.track.id));
-		}
-		else {
-			transceiver = transceivers?.find(t => t.sender && t.sender.track && t.receiver.track.kind === "video" && (mid ? t.mid === mid : true));
-		}
-		if (transceiver) {
-			transceiver.sender.track.enabled = value !== null ? !!value : !transceiver.sender.track.enabled;
-		}
-		this.isMuted = [];
-		for(const source of Object.keys(config.streamMap)) {
-			const audioTrack = config.stream?.getAudioTracks()?.find(track => config.streamMap[source].includes(track.id));
-			const audioTransceiver = transceivers?.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'audio' && transceiver.sender.track.id === audioTrack?.id);
-			const videoTrack = config.stream?.getVideoTracks()?.find(track => config.streamMap[source].includes(track.id));
-			const videoTransceiver = transceivers?.find(transceiver => transceiver.sender.track && transceiver.sender.track.kind === 'video' && transceiver.sender.track.id === videoTrack?.id);
-			this.isMuted.push({type: 'audio', value: !audioTrack || !audioTransceiver || !audioTransceiver?.sender?.track?.enabled , source, mid: audioTransceiver?.mid});
-			this.isMuted.push({type: 'video', value: !videoTrack || !videoTransceiver || !videoTransceiver?.sender?.track?.enabled, source, mid: videoTransceiver?.mid});
-		}
-		for(let val of this.isMuted) {
-			this.emit('localMuted', {...val});
-		}
-	}
-
-	requestKeyFrame(handleId, mid) {
-		this.sendMessage(handleId, {
-			"body": {
-				"request": "configure",
-				"keyframe": true,
-				...(mid !== undefined ? {streams: [{mid,keyframe:true}]} : {})
-			}
-		}).catch(() => null)
-	}
-
-	_setSelectedSubstream(handleId, mid, substream)  {
-		let handle = this._getHandle(handleId);
-		if(handle) {
-			let config = handle.webrtcStuff;
-			if(!mid) {
-				Object.keys(config.selectedSubstream).forEach(mid => {
-					config.selectedSubstream[mid] = substream;
-				})
-			} else {
-				config.selectedSubstream[mid] = substream;
-			}
-		}
-	}
-
-	overrideSimulcastSettings(handleId, mid, source, settings = {}) {
-		const {mode, defaultSubstream} = settings;
-		let handle = this._getHandle(handleId);
-		if(!handle) {
-			return Promise.resolve();
-		}
-		let config = handle.webrtcStuff;
-		if(source !== undefined || mid !== undefined) {
-			if(mid === undefined) {
-				let transceivers = config.pc.getTransceivers();
-				for(let trackId of config.streamMap[source]) {
-					let transceiver = transceivers.find(transceiver => transceiver.receiver.track && transceiver.receiver.track.kind === 'video' && transceiver.receiver.track.id === trackId)
-					if(transceiver) {
-						mid = transceiver.mid;
-						break;
-					}
-				}
-			}
-
-			if(mid !== undefined) {
-				if(!config.overriddenSimulcastMode[mid]) {
-					config.overriddenSimulcastMode[mid] = {};
-				}
-				config.overriddenSimulcastMode[mid]['defaultSubstream'] = defaultSubstream;
-				config.overriddenSimulcastMode[mid]['mode'] = mode;
-				return true;
-			}
-			else {
-				return false;
-			}
-		}
-	}
-
-	selectSubStream(handleId, substream = 2, source, mid, manual = false) {
-		this._log('Select substream called for handle:', handleId, 'Source or mid:', source ? source : mid, 'Substream:', substream);
-		let handle = this._getHandle(handleId);
-		if(!handle) {
-			return Promise.resolve();
-		}
-		let config = handle.webrtcStuff;
-		return new Promise((resolve, reject) => {
-			let messageTimeoutId;
-
-			let clearListeners = () => {
-				clearTimeout(messageTimeoutId);
-				this._abortController.signal.removeEventListener('abort', abortResponse);
-				this.off('longPollEvent', parseResponse);
-				this.ws?.removeEventListener('message', parseResponse);
-			};
-
-			let abortResponse = () => {
-				clearListeners();
-				reject('aborted');
-			};
-
-			let parseResponse = (event) => {
-				let json = typeof event.data === 'string'
-					? JSON.parse(event.data)
-					: event.data;
-
-				var sender = json["sender"];
-				if(sender === handleId) {
-					let plugindata = json["plugindata"] || {};
-					let msg = plugindata["data"] || {};
-					let substream = msg["substream"];
-					if(substream !== undefined && substream !== null && (mid !== undefined ? msg["mid"] === mid : true)) {
-						clearListeners();
-						resolve({substream, sender});
-					}
-				}
-			}
-
-			if(source !== undefined || mid !== undefined) {
-				if(mid === undefined) {
-					let transceivers = config.pc.getTransceivers();
-					for(let trackId of config.streamMap[source]) {
-						let transceiver = transceivers.find(transceiver => transceiver.receiver.track && transceiver.receiver.track.kind === 'video' && transceiver.receiver.track.id === trackId)
-						if(transceiver) {
-							mid = transceiver.mid;
-							break;
-						}
-					}
-				}
-				if(mid !== undefined) {
-
-					if(!config.overriddenSimulcastMode[mid]) {
-						config.overriddenSimulcastMode[mid] = {};
-					}
-
-					if(substream === null) {
-
-						if(manual) {
-							// reset to previous state
-							config.overriddenSimulcastMode[mid]['defaultSubstream'] = null;
-							config.overriddenSimulcastMode[mid]['mode'] = null;
-						}
-
-						resolve({substream, sender: handleId});
-						return;
-					}
-
-					if(manual) {
-						config.overriddenSimulcastMode[mid]['defaultSubstream'] = substream;
-						config.overriddenSimulcastMode[mid]['mode'] = "manual";
-					}
-
-					this.on('longPollEvent', parseResponse);
-					this.ws?.addEventListener('message', parseResponse);
-					this._abortController.signal.addEventListener('abort', abortResponse);
-					messageTimeoutId = setTimeout(() => {
-						clearListeners();
-						reject('timeout');
-					}, 10000);
-
-					this.sendMessage(handleId, {
-						"body": {
-							"request": "configure",
-							"streams": [
-								{
-									mid, substream: parseInt(substream)
-								}
-							]
-						}
-					})
-				} else {
-					reject('no mid found');
-				}
-			}
-			else {
-				reject('no source or mid');
-			}
-		});
-	}
-
-	setTalkIntercomChannels(groups = ['participants']) {
-
-		if(typeof groups !== 'object' || !("length" in groups)) {
-			this._log('setTalkIntercomChannels: groups must be an array');
-			groups = [groups];
-		}
-
-		this._talkIntercomChannels = structuredClone(groups);
-		let handle = this._getHandle(this.handleId);
-		if (!handle) {
-			return Promise.resolve();
-		}
-		let config = handle.webrtcStuff;
-		let transceivers = config.pc.getTransceivers();
-		let descriptions = [];
-		Object.keys(config.streamMap).forEach(source => {
-			const simulcastConfigForSource = this._findSimulcastConfig(source, this.simulcastSettings);
-			config.streamMap[source].forEach(trackId => {
-				let t = transceivers.find(transceiver => transceiver.sender.track && transceiver.sender.track.id === trackId)
-				if(t) {
-					descriptions.push({mid: t.mid, description: JSON.stringify({simulcastBitrates: simulcastConfigForSource?.bitrates, intercomGroups: groups, source:source})});
-				}
-			})
-		});
-		return this.sendMessage(this.handleId, {
-			body: {
-				"request": "configure",
-				descriptions: descriptions,
-			}
-		})
-	}
-
-	setListenIntercomChannels(groups = ['participants']) {
-
-		if(typeof groups !== 'object' || !("length" in groups)) {
-			this._log('setListenIntercomChannels: groups must be an array');
-			groups = [groups];
-		}
-
-		this._listenIntercomChannels = structuredClone(groups);
-		let handle = this._getHandle(this.handleId);
-		if (!handle) {
-			return Promise.resolve();
-		}
-
-		let promises = [];
-		this._participants.forEach(participant => {
-
-			if(participant.handleId === this.handleId) {
-				return;
-			}
-
-
-			let handle = this._getHandle(participant.handleId);
-			if(handle) {
-
-
-				const tracksMap = handle.webrtcStuff.tracksMap.filter(t => t.active);
-				const subscribe = [];
-				const unsubscribe = [];
-
-				tracksMap.forEach(track => {
-					if(track.type === 'data') {
-						return;
-					}
-					const description = JSON.parse(track.description);
-					const intercomGroups = description?.intercomGroups || [];
-					if(this._listenIntercomChannels.some(g => intercomGroups.includes(g))) {
-						if(!this._isAlreadySubscribed(participant.handleId, track.id, track.mid)) {
-							subscribe.push({feed: track.id, mid: track.mid})
-						}
-					}
-					else {
-						unsubscribe.push({feed: track.id, mid: track.mid})
-					}
-				});
-
-				this._updateSubscribeMap(participant.handleId, subscribe, unsubscribe);
-
-				if(subscribe.length || unsubscribe.length) {
-					promises.push(this.sendMessage(handle.handleId, {
-						body: {
-							"request": "update",
-							...(subscribe.length ? {subscribe}: {}),
-							...(unsubscribe.length ? {unsubscribe}: {})
-						}
-					}));
-				}
-			}
-		});
-		return Promise.all(promises);
-	}
-
-	setRoomType(type = 'watchparty') {
-		this._roomType = type;
-		return this._roomType;
-	}
-
-	setRestrictSubscribeToUserIds(userIds = []) {
-		this._restrictSubscribeToUserIds = structuredClone(userIds);
-		if(!this.isConnected) {
-			return Promise.resolve(this._restrictSubscribeToUserIds);
-		}
-		// sanity check by getting listparticipants and comparing it to _remoteUsersCache
-		this.sendMessage(this.handleId, {body: {request: 'listparticipants', room: this.roomId}})
-			.then(r => {
-				let participants = r.participants;
-				let remoteUsersCache = this._remoteUsersCache;
-				let handle = this._getHandle(this.handleId);
-				// filter out my user id from response and compare it to remoteUsersCache
-				participants = participants.filter(p => p.id !== handle.userId);
-				// get rid of participants that are in participants but not in remoteUsersCache
-				remoteUsersCache = remoteUsersCache.filter(r => participants.find(p => p.id === r.id));
-				remoteUsersCache.forEach(r => {
-					const handle = this._getHandle(null, null, null, r.userId);
-					if(this._participantShouldSubscribe(r.userId)) {
-						// todo: do a nicer flag to indicate inactive handle than just checking for pc
-						if(!handle || !handle.webrtcStuff?.pc) {
-							this._log('Subscribing to ', r.userId)
-							this._createParticipant(r.userId, r.id)
-								.then(handle => {
-									this._updateParticipantsTrackData(handle.handleId, r.streams);
-									const subscribe = r.streams.filter(s => !s.disabled && this._intercomSubscribe(s)).map(stream => ({feed: stream.id, mid: stream.mid}));
-									handle.webrtcStuff.subscribeMap = structuredClone(subscribe);
-									return this.sendMessage(handle.handleId, {
-										body: {
-											"request": "join",
-											"room": this.roomId,
-											"ptype": "subscriber",
-											"private_id": this.privateId,
-											streams: subscribe,
-											//"feed": id,
-											...(this.webrtcVersion > 1000 ? {id: this.userId} : {}),
-											pin: this.pin
-										}
-									})
-								})
-								.catch(err => {
-									this.emit('error', err);
-								})
-
-						}
-
-						else {
-							this._log('Already subscribed to ', r.userId);
-						}
-
-					} else if(handle) {
-						this._log('Unsubscribing from ', r.userId)
-						this._removeParticipant(handle.handleId);
-					}
-				})
-
-				// hotfix
-
-				setTimeout(() => {
-					if(this.isConnected) {
-						this.emit('requestMuteStatus');
-					}
-				}, 2000)
-
-			});
-
-
-	}
-
-
-}
-
-export default Room;