matrix-js-sdk 41.8.0 → 41.9.0

package/lib/webrtc/groupCall.js

@@ -1,8 +1,5 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { TypedEventEmitter } from "../models/typed-event-emitter.js";
 import { CallFeed, SPEAKING_THRESHOLD } from "./callFeed.js";
 import { CallErrorCode, CallEvent, CallState, genCallID, setTracksEnabled, createNewMatrixCall, CallError } from "./call.js";
@@ -19,18 +16,18 @@ import { StatsReport } from "./stats/statsReport.js";
 import { SummaryStatsReportGatherer } from "./stats/summaryStatsReportGatherer.js";
 import { CallFeedStatsReporter } from "./stats/callFeedStatsReporter.js";
 import { KnownMembership } from "../@types/membership.js";
-export var GroupCallIntent = /*#__PURE__*/function (GroupCallIntent) {
+export let GroupCallIntent = /*#__PURE__*/function (GroupCallIntent) {
   GroupCallIntent["Ring"] = "m.ring";
   GroupCallIntent["Prompt"] = "m.prompt";
   GroupCallIntent["Room"] = "m.room";
   return GroupCallIntent;
 }({});
-export var GroupCallType = /*#__PURE__*/function (GroupCallType) {
+export let GroupCallType = /*#__PURE__*/function (GroupCallType) {
   GroupCallType["Video"] = "m.video";
   GroupCallType["Voice"] = "m.voice";
   return GroupCallType;
 }({});
-export var GroupCallTerminationReason = /*#__PURE__*/function (GroupCallTerminationReason) {
+export let GroupCallTerminationReason = /*#__PURE__*/function (GroupCallTerminationReason) {
   GroupCallTerminationReason["CallEnded"] = "call_ended";
   return GroupCallTerminationReason;
 }({});
@@ -39,7 +36,7 @@ export var GroupCallTerminationReason = /*#__PURE__*/function (GroupCallTerminat
  * to be unique over all event types of event emitter.
  * Some objects could emit more then one set of events.
  */
-export var GroupCallEvent = /*#__PURE__*/function (GroupCallEvent) {
+export let GroupCallEvent = /*#__PURE__*/function (GroupCallEvent) {
   GroupCallEvent["GroupCallStateChanged"] = "group_call_state_changed";
   GroupCallEvent["ActiveSpeakerChanged"] = "active_speaker_changed";
   GroupCallEvent["CallsChanged"] = "calls_changed";
@@ -51,7 +48,7 @@ export var GroupCallEvent = /*#__PURE__*/function (GroupCallEvent) {
   GroupCallEvent["Error"] = "group_call_error";
   return GroupCallEvent;
 }({});
-export var GroupCallStatsReportEvent = /*#__PURE__*/function (GroupCallStatsReportEvent) {
+export let GroupCallStatsReportEvent = /*#__PURE__*/function (GroupCallStatsReportEvent) {
   GroupCallStatsReportEvent["ConnectionStats"] = "GroupCall.connection_stats";
   GroupCallStatsReportEvent["ByteSentStats"] = "GroupCall.byte_sent_stats";
   GroupCallStatsReportEvent["SummaryStats"] = "GroupCall.summary_stats";
@@ -63,7 +60,7 @@ export var GroupCallStatsReportEvent = /*#__PURE__*/function (GroupCallStatsRepo
  * The final report-events that get consumed by client.
  */
 
-export var GroupCallErrorCode = /*#__PURE__*/function (GroupCallErrorCode) {
+export let GroupCallErrorCode = /*#__PURE__*/function (GroupCallErrorCode) {
   GroupCallErrorCode["NoUserMedia"] = "no_user_media";
   GroupCallErrorCode["UnknownDevice"] = "unknown_device";
   GroupCallErrorCode["PlaceCallFailed"] = "place_call_failed";
@@ -93,7 +90,7 @@ export class OtherUserSpeakingError extends Error {
     super("Cannot unmute: another user is speaking");
   }
 }
-export var GroupCallState = /*#__PURE__*/function (GroupCallState) {
+export let GroupCallState = /*#__PURE__*/function (GroupCallState) {
   GroupCallState["LocalCallFeedUninitialized"] = "local_call_feed_uninitialized";
   GroupCallState["InitializingLocalCallFeed"] = "initializing_local_call_feed";
   GroupCallState["LocalCallFeedInitialized"] = "local_call_feed_initialized";
@@ -101,26 +98,18 @@ export var GroupCallState = /*#__PURE__*/function (GroupCallState) {
   GroupCallState["Ended"] = "ended";
   return GroupCallState;
 }({});
-var DEVICE_TIMEOUT = 1000 * 60 * 60; // 1 hour
+const DEVICE_TIMEOUT = 1000 * 60 * 60; // 1 hour
 
 function getCallUserId(call) {
-  var _call$getOpponentMemb;
-  return ((_call$getOpponentMemb = call.getOpponentMember()) === null || _call$getOpponentMemb === void 0 ? void 0 : _call$getOpponentMemb.userId) || call.invitee || null;
+  return call.getOpponentMember()?.userId || call.invitee || null;
 }
 export class GroupCall extends TypedEventEmitter {
-  constructor(client, room, type, isPtt, intent, groupCallId, dataChannelsEnabled, dataChannelOptions, isCallWithoutVideoAndAudio) {
-    var _room$currentState$ge, _room$currentState$ge2;
-    var useLivekit = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : false;
-    var livekitServiceURL = arguments.length > 10 ? arguments[10] : undefined;
+  constructor(client, room, type, isPtt, intent, groupCallId, dataChannelsEnabled, dataChannelOptions, isCallWithoutVideoAndAudio,
+  // this tells the js-sdk not to actually establish any calls to exchange media and just to
+  // create the group call signaling events, with the intention that the actual media will be
+  // handled using livekit. The js-sdk doesn't contain any code to do the actual livekit call though.
+  useLivekit = false, livekitServiceURL) {
     super();
-    this.client = client;
-    this.room = room;
-    this.type = type;
-    this.isPtt = isPtt;
-    this.intent = intent;
-    this.dataChannelsEnabled = dataChannelsEnabled;
-    this.dataChannelOptions = dataChannelOptions;
-    this.useLivekit = useLivekit;
     // Config
     _defineProperty(this, "activeSpeakerInterval", 1000);
     _defineProperty(this, "retryCallInterval", 5000);
@@ -179,7 +168,7 @@ export class GroupCall extends TypedEventEmitter {
       if (this.localCallFeed) {
         report = CallFeedStatsReporter.expandCallFeedReport(report, [this.localCallFeed], "from-local-feed");
       }
-      var callFeeds = [];
+      const callFeeds = [];
       this.forEachCall(call => {
         if (call.callId === report.callId) {
           call.getFeeds().forEach(f => callFeeds.push(f));
@@ -203,33 +192,32 @@ export class GroupCall extends TypedEventEmitter {
      *    as they are observed by the RoomState.members event.
      */
     _defineProperty(this, "onIncomingCall", newCall => {
-      var _newCall$getOpponentM, _this$calls$get;
       // The incoming calls may be for another room, which we will ignore.
       if (newCall.roomId !== this.room.roomId) {
         return;
       }
       if (newCall.state !== CallState.Ringing) {
-        logger.warn("GroupCall ".concat(this.groupCallId, " onIncomingCall() incoming call no longer in ringing state - ignoring"));
+        logger.warn(`GroupCall ${this.groupCallId} onIncomingCall() incoming call no longer in ringing state - ignoring`);
         return;
       }
       if (!newCall.groupCallId || newCall.groupCallId !== this.groupCallId) {
-        logger.log("GroupCall ".concat(this.groupCallId, " onIncomingCall() ignored because it doesn't match the current group call"));
+        logger.log(`GroupCall ${this.groupCallId} onIncomingCall() ignored because it doesn't match the current group call`);
         newCall.reject();
         return;
       }
-      var opponentUserId = (_newCall$getOpponentM = newCall.getOpponentMember()) === null || _newCall$getOpponentM === void 0 ? void 0 : _newCall$getOpponentM.userId;
+      const opponentUserId = newCall.getOpponentMember()?.userId;
       if (opponentUserId === undefined) {
-        logger.warn("GroupCall ".concat(this.groupCallId, " onIncomingCall() incoming call with no member - ignoring"));
+        logger.warn(`GroupCall ${this.groupCallId} onIncomingCall() incoming call with no member - ignoring`);
         return;
       }
       if (this.useLivekit) {
         logger.info("Received incoming call whilst in signaling-only mode! Ignoring.");
         return;
       }
-      var deviceMap = (_this$calls$get = this.calls.get(opponentUserId)) !== null && _this$calls$get !== void 0 ? _this$calls$get : new Map();
-      var prevCall = deviceMap.get(newCall.getOpponentDeviceId());
-      if ((prevCall === null || prevCall === void 0 ? void 0 : prevCall.callId) === newCall.callId) return;
-      logger.log("GroupCall ".concat(this.groupCallId, " onIncomingCall() incoming call (userId=").concat(opponentUserId, ", callId=").concat(newCall.callId, ")"));
+      const deviceMap = this.calls.get(opponentUserId) ?? new Map();
+      const prevCall = deviceMap.get(newCall.getOpponentDeviceId());
+      if (prevCall?.callId === newCall.callId) return;
+      logger.log(`GroupCall ${this.groupCallId} onIncomingCall() incoming call (userId=${opponentUserId}, callId=${newCall.callId})`);
       if (prevCall) prevCall.hangup(CallErrorCode.Replaced, false);
       // We must do this before we start initialising / answering the call as we
       // need to know it is the active call for this user+deviceId and to not ignore
@@ -237,11 +225,11 @@ export class GroupCall extends TypedEventEmitter {
       deviceMap.set(newCall.getOpponentDeviceId(), newCall);
       this.calls.set(opponentUserId, deviceMap);
       this.initCall(newCall);
-      var feeds = this.getLocalFeeds().map(feed => feed.clone());
+      const feeds = this.getLocalFeeds().map(feed => feed.clone());
       if (!this.callExpected(newCall)) {
         // Disable our tracks for users not explicitly participating in the
         // call but trying to receive the feeds
-        for (var feed of feeds) {
+        for (const feed of feeds) {
           setTracksEnabled(feed.stream.getAudioTracks(), false);
           setTracksEnabled(feed.stream.getVideoTracks(), false);
         }
@@ -250,24 +238,19 @@ export class GroupCall extends TypedEventEmitter {
       this.emit(GroupCallEvent.CallsChanged, this.calls);
     });
     _defineProperty(this, "onRetryCallLoop", () => {
-      var needsRetry = false;
-      for (var _ref3 of this.participants) {
-        var _ref2 = _slicedToArray(_ref3, 2);
-        var _userId = _ref2[0].userId;
-        var participantMap = _ref2[1];
-        var callMap = this.calls.get(_userId);
-        var retriesMap = this.retryCallCounts.get(_userId);
-        for (var _ref6 of participantMap) {
-          var _retriesMap$get, _retriesMap;
-          var _ref5 = _slicedToArray(_ref6, 2);
-          var deviceId = _ref5[0];
-          var participant = _ref5[1];
-          var call = callMap === null || callMap === void 0 ? void 0 : callMap.get(deviceId);
-          var retries = (_retriesMap$get = (_retriesMap = retriesMap) === null || _retriesMap === void 0 ? void 0 : _retriesMap.get(deviceId)) !== null && _retriesMap$get !== void 0 ? _retriesMap$get : 0;
-          if ((call === null || call === void 0 ? void 0 : call.getOpponentSessionId()) !== participant.sessionId && this.wantsOutgoingCall(_userId, deviceId) && retries < 3) {
+      let needsRetry = false;
+      for (const [{
+        userId
+      }, participantMap] of this.participants) {
+        const callMap = this.calls.get(userId);
+        let retriesMap = this.retryCallCounts.get(userId);
+        for (const [deviceId, participant] of participantMap) {
+          const call = callMap?.get(deviceId);
+          const retries = retriesMap?.get(deviceId) ?? 0;
+          if (call?.getOpponentSessionId() !== participant.sessionId && this.wantsOutgoingCall(userId, deviceId) && retries < 3) {
             if (retriesMap === undefined) {
               retriesMap = new Map();
-              this.retryCallCounts.set(_userId, retriesMap);
+              this.retryCallCounts.set(userId, retriesMap);
             }
             retriesMap.set(deviceId, retries + 1);
             needsRetry = true;
@@ -277,17 +260,17 @@ export class GroupCall extends TypedEventEmitter {
       if (needsRetry) this.placeOutgoingCalls();
     });
     _defineProperty(this, "onCallFeedsChanged", call => {
-      var opponentMemberId = getCallUserId(call);
-      var opponentDeviceId = call.getOpponentDeviceId();
+      const opponentMemberId = getCallUserId(call);
+      const opponentDeviceId = call.getOpponentDeviceId();
       if (!opponentMemberId) {
         throw new Error("Cannot change call feeds without user id");
       }
-      var currentUserMediaFeed = this.getUserMediaFeed(opponentMemberId, opponentDeviceId);
-      var remoteUsermediaFeed = call.remoteUsermediaFeed;
-      var remoteFeedChanged = remoteUsermediaFeed !== currentUserMediaFeed;
-      var deviceMap = this.calls.get(opponentMemberId);
-      var currentCallForUserDevice = deviceMap === null || deviceMap === void 0 ? void 0 : deviceMap.get(opponentDeviceId);
-      if ((currentCallForUserDevice === null || currentCallForUserDevice === void 0 ? void 0 : currentCallForUserDevice.callId) !== call.callId) {
+      const currentUserMediaFeed = this.getUserMediaFeed(opponentMemberId, opponentDeviceId);
+      const remoteUsermediaFeed = call.remoteUsermediaFeed;
+      const remoteFeedChanged = remoteUsermediaFeed !== currentUserMediaFeed;
+      const deviceMap = this.calls.get(opponentMemberId);
+      const currentCallForUserDevice = deviceMap?.get(opponentDeviceId);
+      if (currentCallForUserDevice?.callId !== call.callId) {
         // the call in question is not the current call for this user/deviceId
         // so ignore feed events from it otherwise we'll remove our real feeds
         return;
@@ -301,9 +284,9 @@ export class GroupCall extends TypedEventEmitter {
           this.removeUserMediaFeed(currentUserMediaFeed);
         }
       }
-      var currentScreenshareFeed = this.getScreenshareFeed(opponentMemberId, opponentDeviceId);
-      var remoteScreensharingFeed = call.remoteScreensharingFeed;
-      var remoteScreenshareFeedChanged = remoteScreensharingFeed !== currentScreenshareFeed;
+      const currentScreenshareFeed = this.getScreenshareFeed(opponentMemberId, opponentDeviceId);
+      const remoteScreensharingFeed = call.remoteScreensharingFeed;
+      const remoteScreenshareFeedChanged = remoteScreensharingFeed !== currentScreenshareFeed;
       if (remoteScreenshareFeedChanged) {
         if (!currentScreenshareFeed && remoteScreensharingFeed) {
           this.addScreenshareFeed(remoteScreensharingFeed);
@@ -315,31 +298,29 @@ export class GroupCall extends TypedEventEmitter {
       }
     });
     _defineProperty(this, "onCallStateChanged", (call, state, _oldState) => {
-      var _call$getOpponentMemb2;
       if (state === CallState.Ended) return;
-      var audioMuted = this.localCallFeed.isAudioMuted();
+      const audioMuted = this.localCallFeed.isAudioMuted();
       if (call.localUsermediaStream && call.isMicrophoneMuted() !== audioMuted) {
         call.setMicrophoneMuted(audioMuted);
       }
-      var videoMuted = this.localCallFeed.isVideoMuted();
+      const videoMuted = this.localCallFeed.isVideoMuted();
       if (call.localUsermediaStream && call.isLocalVideoMuted() !== videoMuted) {
         call.setLocalVideoMuted(videoMuted);
       }
-      var opponentUserId = (_call$getOpponentMemb2 = call.getOpponentMember()) === null || _call$getOpponentMemb2 === void 0 ? void 0 : _call$getOpponentMemb2.userId;
+      const opponentUserId = call.getOpponentMember()?.userId;
       if (state === CallState.Connected && opponentUserId) {
-        var retriesMap = this.retryCallCounts.get(opponentUserId);
-        retriesMap === null || retriesMap === void 0 || retriesMap.delete(call.getOpponentDeviceId());
-        if ((retriesMap === null || retriesMap === void 0 ? void 0 : retriesMap.size) === 0) this.retryCallCounts.delete(opponentUserId);
+        const retriesMap = this.retryCallCounts.get(opponentUserId);
+        retriesMap?.delete(call.getOpponentDeviceId());
+        if (retriesMap?.size === 0) this.retryCallCounts.delete(opponentUserId);
       }
     });
     _defineProperty(this, "onCallHangup", call => {
-      var _call$getOpponentMemb3, _call$getOpponentMemb4;
       if (call.hangupReason === CallErrorCode.Replaced) return;
-      var opponentUserId = (_call$getOpponentMemb3 = (_call$getOpponentMemb4 = call.getOpponentMember()) === null || _call$getOpponentMemb4 === void 0 ? void 0 : _call$getOpponentMemb4.userId) !== null && _call$getOpponentMemb3 !== void 0 ? _call$getOpponentMemb3 : this.room.getMember(call.invitee).userId;
-      var deviceMap = this.calls.get(opponentUserId);
+      const opponentUserId = call.getOpponentMember()?.userId ?? this.room.getMember(call.invitee).userId;
+      const deviceMap = this.calls.get(opponentUserId);
 
       // Sanity check that this call is in fact in the map
-      if ((deviceMap === null || deviceMap === void 0 ? void 0 : deviceMap.get(call.getOpponentDeviceId())) === call) {
+      if (deviceMap?.get(call.getOpponentDeviceId()) === call) {
         this.disposeCall(call, call.hangupReason);
         deviceMap.delete(call.getOpponentDeviceId());
         if (deviceMap.size === 0) this.calls.delete(opponentUserId);
@@ -347,8 +328,8 @@ export class GroupCall extends TypedEventEmitter {
       }
     });
     _defineProperty(this, "onCallReplaced", (prevCall, newCall) => {
-      var opponentUserId = prevCall.getOpponentMember().userId;
-      var deviceMap = this.calls.get(opponentUserId);
+      const opponentUserId = prevCall.getOpponentMember().userId;
+      let deviceMap = this.calls.get(opponentUserId);
       if (deviceMap === undefined) {
         deviceMap = new Map();
         this.calls.set(opponentUserId, deviceMap);
@@ -359,12 +340,12 @@ export class GroupCall extends TypedEventEmitter {
       this.emit(GroupCallEvent.CallsChanged, this.calls);
     });
     _defineProperty(this, "onActiveSpeakerLoop", () => {
-      var topAvg = undefined;
-      var nextActiveSpeaker = undefined;
-      for (var callFeed of this.userMediaFeeds) {
+      let topAvg = undefined;
+      let nextActiveSpeaker = undefined;
+      for (const callFeed of this.userMediaFeeds) {
         if (callFeed.isLocal() && this.userMediaFeeds.length > 1) continue;
-        var total = callFeed.speakingVolumeSamples.reduce((acc, volume) => acc + Math.max(volume, SPEAKING_THRESHOLD));
-        var avg = total / callFeed.speakingVolumeSamples.length;
+        const total = callFeed.speakingVolumeSamples.reduce((acc, volume) => acc + Math.max(volume, SPEAKING_THRESHOLD));
+        const avg = total / callFeed.speakingVolumeSamples.length;
         if (!topAvg || avg > topAvg) {
           topAvg = avg;
           nextActiveSpeaker = callFeed;
@@ -381,8 +362,8 @@ export class GroupCall extends TypedEventEmitter {
       // left get denied access to our media, and participants that just
       // joined get granted access
       this.forEachCall(call => {
-        var expected = this.callExpected(call);
-        for (var feed of call.getLocalFeeds()) {
+        const expected = this.callExpected(call);
+        for (const feed of call.getLocalFeeds()) {
           setTracksEnabled(feed.stream.getAudioTracks(), !feed.isAudioMuted() && expected);
           setTracksEnabled(feed.stream.getVideoTracks(), !feed.isVideoMuted() && expected);
         }
@@ -395,18 +376,26 @@ export class GroupCall extends TypedEventEmitter {
       if (newState === GroupCallState.Entered || oldState === GroupCallState.Entered || newState === GroupCallState.Ended) {
         // We either entered, left, or ended the call
         this.updateParticipants();
-        this.updateMemberState().catch(e => logger.error("GroupCall ".concat(this.groupCallId, " onStateChanged() failed to update member state devices\""), e));
+        this.updateMemberState().catch(e => logger.error(`GroupCall ${this.groupCallId} onStateChanged() failed to update member state devices"`, e));
       }
     });
     _defineProperty(this, "onLocalFeedsChanged", () => {
       if (this.state === GroupCallState.Entered) {
-        this.updateMemberState().catch(e => logger.error("GroupCall ".concat(this.groupCallId, " onLocalFeedsChanged() failed to update member state feeds"), e));
+        this.updateMemberState().catch(e => logger.error(`GroupCall ${this.groupCallId} onLocalFeedsChanged() failed to update member state feeds`, e));
       }
     });
+    this.client = client;
+    this.room = room;
+    this.type = type;
+    this.isPtt = isPtt;
+    this.intent = intent;
+    this.dataChannelsEnabled = dataChannelsEnabled;
+    this.dataChannelOptions = dataChannelOptions;
+    this.useLivekit = useLivekit;
     this.reEmitter = new ReEmitter(this);
-    this.groupCallId = groupCallId !== null && groupCallId !== void 0 ? groupCallId : genCallID();
+    this.groupCallId = groupCallId ?? genCallID();
     this._livekitServiceURL = livekitServiceURL;
-    this.creationTs = (_room$currentState$ge = (_room$currentState$ge2 = room.currentState.getStateEvents(EventType.GroupCallPrefix, this.groupCallId)) === null || _room$currentState$ge2 === void 0 ? void 0 : _room$currentState$ge2.getTs()) !== null && _room$currentState$ge !== void 0 ? _room$currentState$ge : null;
+    this.creationTs = room.currentState.getStateEvents(EventType.GroupCallPrefix, this.groupCallId)?.getTs() ?? null;
     this.updateParticipants();
     room.on(RoomStateEvent.Update, this.onRoomState);
     this.on(GroupCallEvent.ParticipantsChanged, this.onParticipantsChanged);
@@ -414,32 +403,26 @@ export class GroupCall extends TypedEventEmitter {
     this.on(GroupCallEvent.LocalScreenshareStateChanged, this.onLocalFeedsChanged);
     this.allowCallWithoutVideoAndAudio = !!isCallWithoutVideoAndAudio;
   }
-  create() {
-    var _this = this;
-    return _asyncToGenerator(function* () {
-      _this.creationTs = Date.now();
-      _this.client.groupCallEventHandler.groupCalls.set(_this.room.roomId, _this);
-      _this.client.emit(GroupCallEventHandlerEvent.Outgoing, _this);
-      yield _this.sendCallStateEvent();
-      return _this;
-    })();
+  async create() {
+    this.creationTs = Date.now();
+    this.client.groupCallEventHandler.groupCalls.set(this.room.roomId, this);
+    this.client.emit(GroupCallEventHandlerEvent.Outgoing, this);
+    await this.sendCallStateEvent();
+    return this;
   }
-  sendCallStateEvent() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      var groupCallState = {
-        "m.intent": _this2.intent,
-        "m.type": _this2.type,
-        "io.element.ptt": _this2.isPtt,
-        // TODO: Specify data-channels better
-        "dataChannelsEnabled": _this2.dataChannelsEnabled,
-        "dataChannelOptions": _this2.dataChannelsEnabled ? _this2.dataChannelOptions : undefined
-      };
-      if (_this2.livekitServiceURL) {
-        groupCallState["io.element.livekit_service_url"] = _this2.livekitServiceURL;
-      }
-      yield _this2.client.sendStateEvent(_this2.room.roomId, EventType.GroupCallPrefix, groupCallState, _this2.groupCallId);
-    })();
+  async sendCallStateEvent() {
+    const groupCallState = {
+      "m.intent": this.intent,
+      "m.type": this.type,
+      "io.element.ptt": this.isPtt,
+      // TODO: Specify data-channels better
+      "dataChannelsEnabled": this.dataChannelsEnabled,
+      "dataChannelOptions": this.dataChannelsEnabled ? this.dataChannelOptions : undefined
+    };
+    if (this.livekitServiceURL) {
+      groupCallState["io.element.livekit_service_url"] = this.livekitServiceURL;
+    }
+    await this.client.sendStateEvent(this.room.roomId, EventType.GroupCallPrefix, groupCallState, this.groupCallId);
   }
   get livekitServiceURL() {
     return this._livekitServiceURL;
@@ -455,7 +438,7 @@ export class GroupCall extends TypedEventEmitter {
     return this._state;
   }
   set state(value) {
-    var prevValue = this._state;
+    const prevValue = this._state;
     if (value !== prevValue) {
       this._state = value;
       this.emit(GroupCallEvent.GroupCallStateChanged, value, prevValue);
@@ -469,9 +452,9 @@ export class GroupCall extends TypedEventEmitter {
     return this._participants;
   }
   set participants(value) {
-    var prevValue = this._participants;
-    var participantStateEqual = (x, y) => x.sessionId === y.sessionId && x.screensharing === y.screensharing;
-    var deviceMapsEqual = (x, y) => mapsEqual(x, y, participantStateEqual);
+    const prevValue = this._participants;
+    const participantStateEqual = (x, y) => x.sessionId === y.sessionId && x.screensharing === y.screensharing;
+    const deviceMapsEqual = (x, y) => mapsEqual(x, y, participantStateEqual);
 
     // Only update if the map actually changed
     if (!mapsEqual(value, prevValue, deviceMapsEqual)) {
@@ -506,19 +489,18 @@ export class GroupCall extends TypedEventEmitter {
    * @param f - The callback.
    */
   forEachCall(f) {
-    for (var deviceMap of this.calls.values()) {
-      for (var call of deviceMap.values()) f(call);
+    for (const deviceMap of this.calls.values()) {
+      for (const call of deviceMap.values()) f(call);
     }
   }
   getLocalFeeds() {
-    var feeds = [];
+    const feeds = [];
     if (this.localCallFeed) feeds.push(this.localCallFeed);
     if (this.localScreenshareFeed) feeds.push(this.localScreenshareFeed);
     return feeds;
   }
   hasLocalParticipant() {
-    var _this$participants$ge, _this$participants$ge2;
-    return (_this$participants$ge = (_this$participants$ge2 = this.participants.get(this.room.getMember(this.client.getUserId()))) === null || _this$participants$ge2 === void 0 ? void 0 : _this$participants$ge2.has(this.client.getDeviceId())) !== null && _this$participants$ge !== void 0 ? _this$participants$ge : false;
+    return this.participants.get(this.room.getMember(this.client.getUserId()))?.has(this.client.getDeviceId()) ?? false;
   }
 
   /**
@@ -526,117 +508,103 @@ export class GroupCall extends TypedEventEmitter {
    * given our knowledge of who is participating in the group call.
    */
   callExpected(call) {
-    var _this$participants$ge3;
-    var userId = getCallUserId(call);
-    var member = userId === null ? null : this.room.getMember(userId);
-    var deviceId = call.getOpponentDeviceId();
-    return member !== null && deviceId !== undefined && ((_this$participants$ge3 = this.participants.get(member)) === null || _this$participants$ge3 === void 0 ? void 0 : _this$participants$ge3.get(deviceId)) !== undefined;
+    const userId = getCallUserId(call);
+    const member = userId === null ? null : this.room.getMember(userId);
+    const deviceId = call.getOpponentDeviceId();
+    return member !== null && deviceId !== undefined && this.participants.get(member)?.get(deviceId) !== undefined;
   }
-  initLocalCallFeed() {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      if (_this3.useLivekit) {
-        logger.info("Livekit group call: not starting local call feed.");
-        return;
-      }
-      if (_this3.state !== GroupCallState.LocalCallFeedUninitialized) {
-        throw new Error("Cannot initialize local call feed in the \"".concat(_this3.state, "\" state."));
-      }
-      _this3.state = GroupCallState.InitializingLocalCallFeed;
+  async initLocalCallFeed() {
+    if (this.useLivekit) {
+      logger.info("Livekit group call: not starting local call feed.");
+      return;
+    }
+    if (this.state !== GroupCallState.LocalCallFeedUninitialized) {
+      throw new Error(`Cannot initialize local call feed in the "${this.state}" state.`);
+    }
+    this.state = GroupCallState.InitializingLocalCallFeed;
 
-      // wraps the real method to serialise calls, because we don't want to try starting
-      // multiple call feeds at once
-      if (_this3.initCallFeedPromise) return _this3.initCallFeedPromise;
-      try {
-        _this3.initCallFeedPromise = _this3.initLocalCallFeedInternal();
-        yield _this3.initCallFeedPromise;
-      } finally {
-        _this3.initCallFeedPromise = undefined;
-      }
-    })();
+    // wraps the real method to serialise calls, because we don't want to try starting
+    // multiple call feeds at once
+    if (this.initCallFeedPromise) return this.initCallFeedPromise;
+    try {
+      this.initCallFeedPromise = this.initLocalCallFeedInternal();
+      await this.initCallFeedPromise;
+    } finally {
+      this.initCallFeedPromise = undefined;
+    }
   }
-  initLocalCallFeedInternal() {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      logger.log("GroupCall ".concat(_this4.groupCallId, " initLocalCallFeedInternal() running"));
-      var stream;
-      try {
-        stream = yield _this4.client.getMediaHandler().getUserMediaStream(true, _this4.type === GroupCallType.Video);
-      } catch (error) {
-        // If is allowed to join a call without a media stream, then we
-        // don't throw an error here. But we need an empty Local Feed to establish
-        // a connection later.
-        if (_this4.allowCallWithoutVideoAndAudio) {
-          stream = new MediaStream();
-        } else {
-          _this4.state = GroupCallState.LocalCallFeedUninitialized;
-          throw error;
-        }
+  async initLocalCallFeedInternal() {
+    logger.log(`GroupCall ${this.groupCallId} initLocalCallFeedInternal() running`);
+    let stream;
+    try {
+      stream = await this.client.getMediaHandler().getUserMediaStream(true, this.type === GroupCallType.Video);
+    } catch (error) {
+      // If is allowed to join a call without a media stream, then we
+      // don't throw an error here. But we need an empty Local Feed to establish
+      // a connection later.
+      if (this.allowCallWithoutVideoAndAudio) {
+        stream = new MediaStream();
+      } else {
+        this.state = GroupCallState.LocalCallFeedUninitialized;
+        throw error;
       }
+    }
 
-      // The call could've been disposed while we were waiting, and could
-      // also have been started back up again (hello, React 18) so if we're
-      // still in this 'initializing' state, carry on, otherwise bail.
-      if (_this4._state !== GroupCallState.InitializingLocalCallFeed) {
-        _this4.client.getMediaHandler().stopUserMediaStream(stream);
-        throw new Error("Group call disposed while gathering media stream");
-      }
-      var callFeed = new CallFeed({
-        client: _this4.client,
-        roomId: _this4.room.roomId,
-        userId: _this4.client.getUserId(),
-        deviceId: _this4.client.getDeviceId(),
-        stream,
-        purpose: SDPStreamMetadataPurpose.Usermedia,
-        audioMuted: _this4.initWithAudioMuted || stream.getAudioTracks().length === 0 || _this4.isPtt,
-        videoMuted: _this4.initWithVideoMuted || stream.getVideoTracks().length === 0
-      });
-      setTracksEnabled(stream.getAudioTracks(), !callFeed.isAudioMuted());
-      setTracksEnabled(stream.getVideoTracks(), !callFeed.isVideoMuted());
-      _this4.localCallFeed = callFeed;
-      _this4.addUserMediaFeed(callFeed);
-      _this4.state = GroupCallState.LocalCallFeedInitialized;
-    })();
+    // The call could've been disposed while we were waiting, and could
+    // also have been started back up again (hello, React 18) so if we're
+    // still in this 'initializing' state, carry on, otherwise bail.
+    if (this._state !== GroupCallState.InitializingLocalCallFeed) {
+      this.client.getMediaHandler().stopUserMediaStream(stream);
+      throw new Error("Group call disposed while gathering media stream");
+    }
+    const callFeed = new CallFeed({
+      client: this.client,
+      roomId: this.room.roomId,
+      userId: this.client.getUserId(),
+      deviceId: this.client.getDeviceId(),
+      stream,
+      purpose: SDPStreamMetadataPurpose.Usermedia,
+      audioMuted: this.initWithAudioMuted || stream.getAudioTracks().length === 0 || this.isPtt,
+      videoMuted: this.initWithVideoMuted || stream.getVideoTracks().length === 0
+    });
+    setTracksEnabled(stream.getAudioTracks(), !callFeed.isAudioMuted());
+    setTracksEnabled(stream.getVideoTracks(), !callFeed.isVideoMuted());
+    this.localCallFeed = callFeed;
+    this.addUserMediaFeed(callFeed);
+    this.state = GroupCallState.LocalCallFeedInitialized;
   }
-  updateLocalUsermediaStream(stream) {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      if (_this5.localCallFeed) {
-        var oldStream = _this5.localCallFeed.stream;
-        _this5.localCallFeed.setNewStream(stream);
-        var micShouldBeMuted = _this5.localCallFeed.isAudioMuted();
-        var vidShouldBeMuted = _this5.localCallFeed.isVideoMuted();
-        logger.log("GroupCall ".concat(_this5.groupCallId, " updateLocalUsermediaStream() (oldStreamId=").concat(oldStream.id, ", newStreamId=").concat(stream.id, ", micShouldBeMuted=").concat(micShouldBeMuted, ", vidShouldBeMuted=").concat(vidShouldBeMuted, ")"));
-        setTracksEnabled(stream.getAudioTracks(), !micShouldBeMuted);
-        setTracksEnabled(stream.getVideoTracks(), !vidShouldBeMuted);
-        _this5.client.getMediaHandler().stopUserMediaStream(oldStream);
-      }
-    })();
+  async updateLocalUsermediaStream(stream) {
+    if (this.localCallFeed) {
+      const oldStream = this.localCallFeed.stream;
+      this.localCallFeed.setNewStream(stream);
+      const micShouldBeMuted = this.localCallFeed.isAudioMuted();
+      const vidShouldBeMuted = this.localCallFeed.isVideoMuted();
+      logger.log(`GroupCall ${this.groupCallId} updateLocalUsermediaStream() (oldStreamId=${oldStream.id}, newStreamId=${stream.id}, micShouldBeMuted=${micShouldBeMuted}, vidShouldBeMuted=${vidShouldBeMuted})`);
+      setTracksEnabled(stream.getAudioTracks(), !micShouldBeMuted);
+      setTracksEnabled(stream.getVideoTracks(), !vidShouldBeMuted);
+      this.client.getMediaHandler().stopUserMediaStream(oldStream);
+    }
   }
-  enter() {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      if (_this6.state === GroupCallState.LocalCallFeedUninitialized) {
-        yield _this6.initLocalCallFeed();
-      } else if (_this6.state !== GroupCallState.LocalCallFeedInitialized) {
-        throw new Error("Cannot enter call in the \"".concat(_this6.state, "\" state"));
-      }
-      logger.log("GroupCall ".concat(_this6.groupCallId, " enter() running"));
-      _this6.state = GroupCallState.Entered;
-      _this6.client.on(CallEventHandlerEvent.Incoming, _this6.onIncomingCall);
-      for (var call of _this6.client.callEventHandler.calls.values()) {
-        _this6.onIncomingCall(call);
-      }
-      if (!_this6.useLivekit) {
-        _this6.retryCallLoopInterval = setInterval(_this6.onRetryCallLoop, _this6.retryCallInterval);
-        _this6.activeSpeaker = undefined;
-        _this6.onActiveSpeakerLoop();
-        _this6.activeSpeakerLoopInterval = setInterval(_this6.onActiveSpeakerLoop, _this6.activeSpeakerInterval);
-      }
-    })();
+  async enter() {
+    if (this.state === GroupCallState.LocalCallFeedUninitialized) {
+      await this.initLocalCallFeed();
+    } else if (this.state !== GroupCallState.LocalCallFeedInitialized) {
+      throw new Error(`Cannot enter call in the "${this.state}" state`);
+    }
+    logger.log(`GroupCall ${this.groupCallId} enter() running`);
+    this.state = GroupCallState.Entered;
+    this.client.on(CallEventHandlerEvent.Incoming, this.onIncomingCall);
+    for (const call of this.client.callEventHandler.calls.values()) {
+      this.onIncomingCall(call);
+    }
+    if (!this.useLivekit) {
+      this.retryCallLoopInterval = setInterval(this.onRetryCallLoop, this.retryCallInterval);
+      this.activeSpeaker = undefined;
+      this.onActiveSpeakerLoop();
+      this.activeSpeakerLoopInterval = setInterval(this.onActiveSpeakerLoop, this.activeSpeakerInterval);
+    }
   }
   dispose() {
-    var _this$stats;
     if (this.localCallFeed) {
       this.removeUserMediaFeed(this.localCallFeed);
       this.localCallFeed = undefined;
@@ -669,29 +637,24 @@ export class GroupCall extends TypedEventEmitter {
     this.retryCallCounts.clear();
     clearInterval(this.retryCallLoopInterval);
     this.client.removeListener(CallEventHandlerEvent.Incoming, this.onIncomingCall);
-    (_this$stats = this.stats) === null || _this$stats === void 0 || _this$stats.stop();
+    this.stats?.stop();
   }
   leave() {
     this.dispose();
     this.state = GroupCallState.LocalCallFeedUninitialized;
   }
-  terminate() {
-    var _arguments = arguments,
-      _this7 = this;
-    return _asyncToGenerator(function* () {
-      var emitStateEvent = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : true;
-      _this7.dispose();
-      _this7.room.off(RoomStateEvent.Update, _this7.onRoomState);
-      _this7.client.groupCallEventHandler.groupCalls.delete(_this7.room.roomId);
-      _this7.client.emit(GroupCallEventHandlerEvent.Ended, _this7);
-      _this7.state = GroupCallState.Ended;
-      if (emitStateEvent) {
-        var existingStateEvent = _this7.room.currentState.getStateEvents(EventType.GroupCallPrefix, _this7.groupCallId);
-        yield _this7.client.sendStateEvent(_this7.room.roomId, EventType.GroupCallPrefix, _objectSpread(_objectSpread({}, existingStateEvent.getContent()), {}, {
-          "m.terminated": GroupCallTerminationReason.CallEnded
-        }), _this7.groupCallId);
-      }
-    })();
+  async terminate(emitStateEvent = true) {
+    this.dispose();
+    this.room.off(RoomStateEvent.Update, this.onRoomState);
+    this.client.groupCallEventHandler.groupCalls.delete(this.room.roomId);
+    this.client.emit(GroupCallEventHandlerEvent.Ended, this);
+    this.state = GroupCallState.Ended;
+    if (emitStateEvent) {
+      const existingStateEvent = this.room.currentState.getStateEvents(EventType.GroupCallPrefix, this.groupCallId);
+      await this.client.sendStateEvent(this.room.roomId, EventType.GroupCallPrefix, _objectSpread(_objectSpread({}, existingStateEvent.getContent()), {}, {
+        "m.terminated": GroupCallTerminationReason.CallEnded
+      }), this.groupCallId);
+    }
   }
 
   /*
@@ -716,65 +679,54 @@ export class GroupCall extends TypedEventEmitter {
    * @param muted - Whether to mute the microphone
    * @returns Whether muting/unmuting was successful
    */
-  setMicrophoneMuted(muted) {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      // hasAudioDevice can block indefinitely if the window has lost focus,
-      // and it doesn't make much sense to keep a device from being muted, so
-      // we always allow muted = true changes to go through
-      if (!muted && !(yield _this8.client.getMediaHandler().hasAudioDevice())) {
-        return false;
-      }
-      var sendUpdatesBefore = !muted && _this8.isPtt;
+  async setMicrophoneMuted(muted) {
+    // hasAudioDevice can block indefinitely if the window has lost focus,
+    // and it doesn't make much sense to keep a device from being muted, so
+    // we always allow muted = true changes to go through
+    if (!muted && !(await this.client.getMediaHandler().hasAudioDevice())) {
+      return false;
+    }
+    const sendUpdatesBefore = !muted && this.isPtt;
 
-      // set a timer for the maximum transmit time on PTT calls
-      if (_this8.isPtt) {
-        // Set or clear the max transmit timer
-        if (!muted && _this8.isMicrophoneMuted()) {
-          _this8.transmitTimer = setTimeout(() => {
-            _this8.setMicrophoneMuted(true);
-          }, _this8.pttMaxTransmitTime);
-        } else if (muted && !_this8.isMicrophoneMuted()) {
-          if (_this8.transmitTimer !== null) clearTimeout(_this8.transmitTimer);
-          _this8.transmitTimer = null;
-        }
+    // set a timer for the maximum transmit time on PTT calls
+    if (this.isPtt) {
+      // Set or clear the max transmit timer
+      if (!muted && this.isMicrophoneMuted()) {
+        this.transmitTimer = setTimeout(() => {
+          this.setMicrophoneMuted(true);
+        }, this.pttMaxTransmitTime);
+      } else if (muted && !this.isMicrophoneMuted()) {
+        if (this.transmitTimer !== null) clearTimeout(this.transmitTimer);
+        this.transmitTimer = null;
       }
-      _this8.forEachCall(call => {
-        var _call$localUsermediaF;
-        return (_call$localUsermediaF = call.localUsermediaFeed) === null || _call$localUsermediaF === void 0 ? void 0 : _call$localUsermediaF.setAudioVideoMuted(muted, null);
-      });
-      var sendUpdates = /*#__PURE__*/function () {
-        var _ref7 = _asyncToGenerator(function* () {
-          var updates = [];
-          _this8.forEachCall(call => updates.push(call.sendMetadataUpdate()));
-          yield Promise.all(updates).catch(e => logger.info("GroupCall ".concat(_this8.groupCallId, " setMicrophoneMuted() failed to send some metadata updates"), e));
-        });
-        return function sendUpdates() {
-          return _ref7.apply(this, arguments);
-        };
-      }();
-      if (sendUpdatesBefore) yield sendUpdates();
-      if (_this8.localCallFeed) {
-        logger.log("GroupCall ".concat(_this8.groupCallId, " setMicrophoneMuted() (streamId=").concat(_this8.localCallFeed.stream.id, ", muted=").concat(muted, ")"));
-        var hasPermission = yield _this8.checkAudioPermissionIfNecessary(muted);
-        if (!hasPermission) {
-          return false;
-        }
-        _this8.localCallFeed.setAudioVideoMuted(muted, null);
-        // I don't believe its actually necessary to enable these tracks: they
-        // are the one on the GroupCall's own CallFeed and are cloned before being
-        // given to any of the actual calls, so these tracks don't actually go
-        // anywhere. Let's do it anyway to avoid confusion.
-        setTracksEnabled(_this8.localCallFeed.stream.getAudioTracks(), !muted);
-      } else {
-        logger.log("GroupCall ".concat(_this8.groupCallId, " setMicrophoneMuted() no stream muted (muted=").concat(muted, ")"));
-        _this8.initWithAudioMuted = muted;
+    }
+    this.forEachCall(call => call.localUsermediaFeed?.setAudioVideoMuted(muted, null));
+    const sendUpdates = async () => {
+      const updates = [];
+      this.forEachCall(call => updates.push(call.sendMetadataUpdate()));
+      await Promise.all(updates).catch(e => logger.info(`GroupCall ${this.groupCallId} setMicrophoneMuted() failed to send some metadata updates`, e));
+    };
+    if (sendUpdatesBefore) await sendUpdates();
+    if (this.localCallFeed) {
+      logger.log(`GroupCall ${this.groupCallId} setMicrophoneMuted() (streamId=${this.localCallFeed.stream.id}, muted=${muted})`);
+      const hasPermission = await this.checkAudioPermissionIfNecessary(muted);
+      if (!hasPermission) {
+        return false;
       }
-      _this8.forEachCall(call => setTracksEnabled(call.localUsermediaFeed.stream.getAudioTracks(), !muted && _this8.callExpected(call)));
-      _this8.emit(GroupCallEvent.LocalMuteStateChanged, muted, _this8.isLocalVideoMuted());
-      if (!sendUpdatesBefore) yield sendUpdates();
-      return true;
-    })();
+      this.localCallFeed.setAudioVideoMuted(muted, null);
+      // I don't believe its actually necessary to enable these tracks: they
+      // are the one on the GroupCall's own CallFeed and are cloned before being
+      // given to any of the actual calls, so these tracks don't actually go
+      // anywhere. Let's do it anyway to avoid confusion.
+      setTracksEnabled(this.localCallFeed.stream.getAudioTracks(), !muted);
+    } else {
+      logger.log(`GroupCall ${this.groupCallId} setMicrophoneMuted() no stream muted (muted=${muted})`);
+      this.initWithAudioMuted = muted;
+    }
+    this.forEachCall(call => setTracksEnabled(call.localUsermediaFeed.stream.getAudioTracks(), !muted && this.callExpected(call)));
+    this.emit(GroupCallEvent.LocalMuteStateChanged, muted, this.isLocalVideoMuted());
+    if (!sendUpdatesBefore) await sendUpdates();
+    return true;
   }
 
   /**
@@ -786,27 +738,24 @@ export class GroupCall extends TypedEventEmitter {
    * not Audio Track exists.
    * As such, this is a compromise, because, the access rights should always be queried before the call.
    */
-  checkAudioPermissionIfNecessary(muted) {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      // We needed this here to avoid an error in case user join a call without a device.
-      try {
-        if (!muted && _this9.localCallFeed && !_this9.localCallFeed.hasAudioTrack) {
-          var stream = yield _this9.client.getMediaHandler().getUserMediaStream(true, !_this9.localCallFeed.isVideoMuted());
-          if ((stream === null || stream === void 0 ? void 0 : stream.getTracks().length) === 0) {
-            // if case permission denied to get a stream stop this here
-            /* istanbul ignore next */
-            logger.log("GroupCall ".concat(_this9.groupCallId, " setMicrophoneMuted() no device to receive local stream, muted=").concat(muted));
-            return false;
-          }
+  async checkAudioPermissionIfNecessary(muted) {
+    // We needed this here to avoid an error in case user join a call without a device.
+    try {
+      if (!muted && this.localCallFeed && !this.localCallFeed.hasAudioTrack) {
+        const stream = await this.client.getMediaHandler().getUserMediaStream(true, !this.localCallFeed.isVideoMuted());
+        if (stream?.getTracks().length === 0) {
+          // if case permission denied to get a stream stop this here
+          /* istanbul ignore next */
+          logger.log(`GroupCall ${this.groupCallId} setMicrophoneMuted() no device to receive local stream, muted=${muted}`);
+          return false;
         }
-      } catch (_unused) {
-        /* istanbul ignore next */
-        logger.log("GroupCall ".concat(_this9.groupCallId, " setMicrophoneMuted() no device or permission to receive local stream, muted=").concat(muted));
-        return false;
       }
-      return true;
-    })();
+    } catch {
+      /* istanbul ignore next */
+      logger.log(`GroupCall ${this.groupCallId} setMicrophoneMuted() no device or permission to receive local stream, muted=${muted}`);
+      return false;
+    }
+    return true;
   }
 
   /**
@@ -814,102 +763,91 @@ export class GroupCall extends TypedEventEmitter {
    * @param muted - Whether to mute the video
    * @returns Whether muting/unmuting was successful
    */
-  setLocalVideoMuted(muted) {
-    var _this0 = this;
-    return _asyncToGenerator(function* () {
-      // hasAudioDevice can block indefinitely if the window has lost focus,
-      // and it doesn't make much sense to keep a device from being muted, so
-      // we always allow muted = true changes to go through
-      if (!muted && !(yield _this0.client.getMediaHandler().hasVideoDevice())) {
-        return false;
-      }
-      if (_this0.localCallFeed) {
+  async setLocalVideoMuted(muted) {
+    // hasAudioDevice can block indefinitely if the window has lost focus,
+    // and it doesn't make much sense to keep a device from being muted, so
+    // we always allow muted = true changes to go through
+    if (!muted && !(await this.client.getMediaHandler().hasVideoDevice())) {
+      return false;
+    }
+    if (this.localCallFeed) {
+      /* istanbul ignore next */
+      logger.log(`GroupCall ${this.groupCallId} setLocalVideoMuted() (stream=${this.localCallFeed.stream.id}, muted=${muted})`);
+      try {
+        const stream = await this.client.getMediaHandler().getUserMediaStream(true, !muted);
+        await this.updateLocalUsermediaStream(stream);
+        this.localCallFeed.setAudioVideoMuted(null, muted);
+        setTracksEnabled(this.localCallFeed.stream.getVideoTracks(), !muted);
+      } catch {
+        // No permission to video device
         /* istanbul ignore next */
-        logger.log("GroupCall ".concat(_this0.groupCallId, " setLocalVideoMuted() (stream=").concat(_this0.localCallFeed.stream.id, ", muted=").concat(muted, ")"));
-        try {
-          var stream = yield _this0.client.getMediaHandler().getUserMediaStream(true, !muted);
-          yield _this0.updateLocalUsermediaStream(stream);
-          _this0.localCallFeed.setAudioVideoMuted(null, muted);
-          setTracksEnabled(_this0.localCallFeed.stream.getVideoTracks(), !muted);
-        } catch (_unused2) {
-          // No permission to video device
-          /* istanbul ignore next */
-          logger.log("GroupCall ".concat(_this0.groupCallId, " setLocalVideoMuted() no device or permission to receive local stream, muted=").concat(muted));
-          return false;
-        }
-      } else {
-        logger.log("GroupCall ".concat(_this0.groupCallId, " setLocalVideoMuted() no stream muted (muted=").concat(muted, ")"));
-        _this0.initWithVideoMuted = muted;
+        logger.log(`GroupCall ${this.groupCallId} setLocalVideoMuted() no device or permission to receive local stream, muted=${muted}`);
+        return false;
       }
-      var updates = [];
-      _this0.forEachCall(call => updates.push(call.setLocalVideoMuted(muted)));
-      yield Promise.all(updates);
+    } else {
+      logger.log(`GroupCall ${this.groupCallId} setLocalVideoMuted() no stream muted (muted=${muted})`);
+      this.initWithVideoMuted = muted;
+    }
+    const updates = [];
+    this.forEachCall(call => updates.push(call.setLocalVideoMuted(muted)));
+    await Promise.all(updates);
 
-      // We setTracksEnabled again, independently from the call doing it
-      // internally, since we might not be expecting the call
-      _this0.forEachCall(call => setTracksEnabled(call.localUsermediaFeed.stream.getVideoTracks(), !muted && _this0.callExpected(call)));
-      _this0.emit(GroupCallEvent.LocalMuteStateChanged, _this0.isMicrophoneMuted(), muted);
-      return true;
-    })();
+    // We setTracksEnabled again, independently from the call doing it
+    // internally, since we might not be expecting the call
+    this.forEachCall(call => setTracksEnabled(call.localUsermediaFeed.stream.getVideoTracks(), !muted && this.callExpected(call)));
+    this.emit(GroupCallEvent.LocalMuteStateChanged, this.isMicrophoneMuted(), muted);
+    return true;
   }
-  setScreensharingEnabled(enabled) {
-    var _arguments2 = arguments,
-      _this1 = this;
-    return _asyncToGenerator(function* () {
-      var opts = _arguments2.length > 1 && _arguments2[1] !== undefined ? _arguments2[1] : {};
-      if (enabled === _this1.isScreensharing()) {
-        return enabled;
-      }
-      if (enabled) {
-        try {
-          logger.log("GroupCall ".concat(_this1.groupCallId, " setScreensharingEnabled() is asking for screensharing permissions"));
-          var stream = yield _this1.client.getMediaHandler().getScreensharingStream(opts);
-          var _loop = function* _loop(track) {
-            var onTrackEnded = () => {
-              _this1.setScreensharingEnabled(false);
-              track.removeEventListener("ended", onTrackEnded);
-            };
-            track.addEventListener("ended", onTrackEnded);
+  async setScreensharingEnabled(enabled, opts = {}) {
+    if (enabled === this.isScreensharing()) {
+      return enabled;
+    }
+    if (enabled) {
+      try {
+        logger.log(`GroupCall ${this.groupCallId} setScreensharingEnabled() is asking for screensharing permissions`);
+        const stream = await this.client.getMediaHandler().getScreensharingStream(opts);
+        for (const track of stream.getTracks()) {
+          const onTrackEnded = () => {
+            this.setScreensharingEnabled(false);
+            track.removeEventListener("ended", onTrackEnded);
           };
-          for (var track of stream.getTracks()) {
-            yield* _loop(track);
-          }
-          logger.log("GroupCall ".concat(_this1.groupCallId, " setScreensharingEnabled() granted screensharing permissions. Setting screensharing enabled on all calls"));
-          _this1.localDesktopCapturerSourceId = opts.desktopCapturerSourceId;
-          _this1.localScreenshareFeed = new CallFeed({
-            client: _this1.client,
-            roomId: _this1.room.roomId,
-            userId: _this1.client.getUserId(),
-            deviceId: _this1.client.getDeviceId(),
-            stream,
-            purpose: SDPStreamMetadataPurpose.Screenshare,
-            audioMuted: false,
-            videoMuted: false
-          });
-          _this1.addScreenshareFeed(_this1.localScreenshareFeed);
-          _this1.emit(GroupCallEvent.LocalScreenshareStateChanged, true, _this1.localScreenshareFeed, _this1.localDesktopCapturerSourceId);
-
-          // TODO: handle errors
-          _this1.forEachCall(call => call.pushLocalFeed(_this1.localScreenshareFeed.clone()));
-          return true;
-        } catch (error) {
-          if (opts.throwOnFail) throw error;
-          logger.error("GroupCall ".concat(_this1.groupCallId, " setScreensharingEnabled() enabling screensharing error"), error);
-          _this1.emit(GroupCallEvent.Error, new GroupCallError(GroupCallErrorCode.NoUserMedia, "Failed to get screen-sharing stream: ", error));
-          return false;
+          track.addEventListener("ended", onTrackEnded);
         }
-      } else {
-        _this1.forEachCall(call => {
-          if (call.localScreensharingFeed) call.removeLocalFeed(call.localScreensharingFeed);
+        logger.log(`GroupCall ${this.groupCallId} setScreensharingEnabled() granted screensharing permissions. Setting screensharing enabled on all calls`);
+        this.localDesktopCapturerSourceId = opts.desktopCapturerSourceId;
+        this.localScreenshareFeed = new CallFeed({
+          client: this.client,
+          roomId: this.room.roomId,
+          userId: this.client.getUserId(),
+          deviceId: this.client.getDeviceId(),
+          stream,
+          purpose: SDPStreamMetadataPurpose.Screenshare,
+          audioMuted: false,
+          videoMuted: false
         });
-        _this1.client.getMediaHandler().stopScreensharingStream(_this1.localScreenshareFeed.stream);
-        _this1.removeScreenshareFeed(_this1.localScreenshareFeed);
-        _this1.localScreenshareFeed = undefined;
-        _this1.localDesktopCapturerSourceId = undefined;
-        _this1.emit(GroupCallEvent.LocalScreenshareStateChanged, false, undefined, undefined);
+        this.addScreenshareFeed(this.localScreenshareFeed);
+        this.emit(GroupCallEvent.LocalScreenshareStateChanged, true, this.localScreenshareFeed, this.localDesktopCapturerSourceId);
+
+        // TODO: handle errors
+        this.forEachCall(call => call.pushLocalFeed(this.localScreenshareFeed.clone()));
+        return true;
+      } catch (error) {
+        if (opts.throwOnFail) throw error;
+        logger.error(`GroupCall ${this.groupCallId} setScreensharingEnabled() enabling screensharing error`, error);
+        this.emit(GroupCallEvent.Error, new GroupCallError(GroupCallErrorCode.NoUserMedia, "Failed to get screen-sharing stream: ", error));
         return false;
       }
-    })();
+    } else {
+      this.forEachCall(call => {
+        if (call.localScreensharingFeed) call.removeLocalFeed(call.localScreensharingFeed);
+      });
+      this.client.getMediaHandler().stopScreensharingStream(this.localScreenshareFeed.stream);
+      this.removeScreenshareFeed(this.localScreenshareFeed);
+      this.localScreenshareFeed = undefined;
+      this.localDesktopCapturerSourceId = undefined;
+      this.emit(GroupCallEvent.LocalScreenshareStateChanged, false, undefined, undefined);
+      return false;
+    }
   }
   isScreensharing() {
     return !!this.localScreenshareFeed;
@@ -922,8 +860,8 @@ export class GroupCall extends TypedEventEmitter {
    * @returns Whether we need to place an outgoing call to the participant.
    */
   wantsOutgoingCall(userId, deviceId) {
-    var localUserId = this.client.getUserId();
-    var localDeviceId = this.client.getDeviceId();
+    const localUserId = this.client.getUserId();
+    const localDeviceId = this.client.getDeviceId();
     return (
       // If a user's ID is less than our own, they'll call us
       userId >= localUserId && (
@@ -936,68 +874,54 @@ export class GroupCall extends TypedEventEmitter {
    * Places calls to all participants that we're responsible for calling.
    */
   placeOutgoingCalls() {
-    var _this10 = this;
-    var callsChanged = false;
-    var _loop2 = function _loop2() {
-        var _this10$calls$get;
-        _ref9 = _slicedToArray(_ref0, 2);
-        var userId = _ref9[0].userId;
-        var participantMap = _ref9[1];
-        var callMap = (_this10$calls$get = _this10.calls.get(userId)) !== null && _this10$calls$get !== void 0 ? _this10$calls$get : new Map();
-        var _loop3 = function _loop3() {
-            _ref10 = _slicedToArray(_ref11, 2);
-            var deviceId = _ref10[0];
-            var participant = _ref10[1];
-            var prevCall = callMap.get(deviceId);
-            if ((prevCall === null || prevCall === void 0 ? void 0 : prevCall.getOpponentSessionId()) !== participant.sessionId && _this10.wantsOutgoingCall(userId, deviceId)) {
-              callsChanged = true;
-              if (prevCall !== undefined) {
-                logger.debug("GroupCall ".concat(_this10.groupCallId, " placeOutgoingCalls() replacing call (userId=").concat(userId, ", deviceId=").concat(deviceId, ", callId=").concat(prevCall.callId, ")"));
-                prevCall.hangup(CallErrorCode.NewSession, false);
+    let callsChanged = false;
+    for (const [{
+      userId
+    }, participantMap] of this.participants) {
+      const callMap = this.calls.get(userId) ?? new Map();
+      for (const [deviceId, participant] of participantMap) {
+        const prevCall = callMap.get(deviceId);
+        if (prevCall?.getOpponentSessionId() !== participant.sessionId && this.wantsOutgoingCall(userId, deviceId)) {
+          callsChanged = true;
+          if (prevCall !== undefined) {
+            logger.debug(`GroupCall ${this.groupCallId} placeOutgoingCalls() replacing call (userId=${userId}, deviceId=${deviceId}, callId=${prevCall.callId})`);
+            prevCall.hangup(CallErrorCode.NewSession, false);
+          }
+          const newCall = createNewMatrixCall(this.client, this.room.roomId, {
+            invitee: userId,
+            opponentDeviceId: deviceId,
+            opponentSessionId: participant.sessionId,
+            groupCallId: this.groupCallId
+          });
+          if (newCall === null) {
+            logger.error(`GroupCall ${this.groupCallId} placeOutgoingCalls() failed to create call (userId=${userId}, device=${deviceId})`);
+            callMap.delete(deviceId);
+          } else {
+            this.initCall(newCall);
+            callMap.set(deviceId, newCall);
+            logger.debug(`GroupCall ${this.groupCallId} placeOutgoingCalls() placing call (userId=${userId}, deviceId=${deviceId}, sessionId=${participant.sessionId})`);
+            newCall.placeCallWithCallFeeds(this.getLocalFeeds().map(feed => feed.clone()), participant.screensharing).then(() => {
+              if (this.dataChannelsEnabled) {
+                newCall.createDataChannel("datachannel", this.dataChannelOptions);
               }
-              var newCall = createNewMatrixCall(_this10.client, _this10.room.roomId, {
-                invitee: userId,
-                opponentDeviceId: deviceId,
-                opponentSessionId: participant.sessionId,
-                groupCallId: _this10.groupCallId
-              });
-              if (newCall === null) {
-                logger.error("GroupCall ".concat(_this10.groupCallId, " placeOutgoingCalls() failed to create call (userId=").concat(userId, ", device=").concat(deviceId, ")"));
-                callMap.delete(deviceId);
+            }).catch(e => {
+              logger.warn(`GroupCall ${this.groupCallId} placeOutgoingCalls() failed to place call (userId=${userId})`, e);
+              if (e instanceof CallError && e.code === GroupCallErrorCode.UnknownDevice) {
+                this.emit(GroupCallEvent.Error, e);
               } else {
-                _this10.initCall(newCall);
-                callMap.set(deviceId, newCall);
-                logger.debug("GroupCall ".concat(_this10.groupCallId, " placeOutgoingCalls() placing call (userId=").concat(userId, ", deviceId=").concat(deviceId, ", sessionId=").concat(participant.sessionId, ")"));
-                newCall.placeCallWithCallFeeds(_this10.getLocalFeeds().map(feed => feed.clone()), participant.screensharing).then(() => {
-                  if (_this10.dataChannelsEnabled) {
-                    newCall.createDataChannel("datachannel", _this10.dataChannelOptions);
-                  }
-                }).catch(e => {
-                  logger.warn("GroupCall ".concat(_this10.groupCallId, " placeOutgoingCalls() failed to place call (userId=").concat(userId, ")"), e);
-                  if (e instanceof CallError && e.code === GroupCallErrorCode.UnknownDevice) {
-                    _this10.emit(GroupCallEvent.Error, e);
-                  } else {
-                    _this10.emit(GroupCallEvent.Error, new GroupCallError(GroupCallErrorCode.PlaceCallFailed, "Failed to place call to ".concat(userId)));
-                  }
-                  newCall.hangup(CallErrorCode.SignallingFailed, false);
-                  if (callMap.get(deviceId) === newCall) callMap.delete(deviceId);
-                });
+                this.emit(GroupCallEvent.Error, new GroupCallError(GroupCallErrorCode.PlaceCallFailed, `Failed to place call to ${userId}`));
               }
-            }
-          },
-          _ref10;
-        for (var _ref11 of participantMap) {
-          _loop3();
-        }
-        if (callMap.size > 0) {
-          _this10.calls.set(userId, callMap);
-        } else {
-          _this10.calls.delete(userId);
+              newCall.hangup(CallErrorCode.SignallingFailed, false);
+              if (callMap.get(deviceId) === newCall) callMap.delete(deviceId);
+            });
+          }
         }
-      },
-      _ref9;
-    for (var _ref0 of this.participants) {
-      _loop2();
+      }
+      if (callMap.size > 0) {
+        this.calls.set(userId, callMap);
+      } else {
+        this.calls.delete(userId);
+      }
     }
     if (callsChanged) this.emit(GroupCallEvent.CallsChanged, this.calls);
   }
@@ -1010,15 +934,15 @@ export class GroupCall extends TypedEventEmitter {
     return userId === undefined ? this.room.currentState.getStateEvents(EventType.GroupCallMemberPrefix) : this.room.currentState.getStateEvents(EventType.GroupCallMemberPrefix, userId);
   }
   initCall(call) {
-    var opponentMemberId = getCallUserId(call);
+    const opponentMemberId = getCallUserId(call);
     if (!opponentMemberId) {
       throw new Error("Cannot init call without user id");
     }
-    var onCallFeedsChanged = () => this.onCallFeedsChanged(call);
-    var onCallStateChanged = (state, oldState) => this.onCallStateChanged(call, state, oldState);
-    var onCallHangup = this.onCallHangup;
-    var onCallReplaced = newCall => this.onCallReplaced(call, newCall);
-    var deviceMap = this.callHandlers.get(opponentMemberId);
+    const onCallFeedsChanged = () => this.onCallFeedsChanged(call);
+    const onCallStateChanged = (state, oldState) => this.onCallStateChanged(call, state, oldState);
+    const onCallHangup = this.onCallHangup;
+    const onCallReplaced = newCall => this.onCallReplaced(call, newCall);
+    let deviceMap = this.callHandlers.get(opponentMemberId);
     if (deviceMap === undefined) {
       deviceMap = new Map();
       this.callHandlers.set(opponentMemberId, deviceMap);
@@ -1039,17 +963,18 @@ export class GroupCall extends TypedEventEmitter {
     onCallFeedsChanged();
   }
   disposeCall(call, hangupReason) {
-    var opponentMemberId = getCallUserId(call);
-    var opponentDeviceId = call.getOpponentDeviceId();
+    const opponentMemberId = getCallUserId(call);
+    const opponentDeviceId = call.getOpponentDeviceId();
     if (!opponentMemberId) {
       throw new Error("Cannot dispose call without user id");
     }
-    var deviceMap = this.callHandlers.get(opponentMemberId);
-    var _ref12 = deviceMap.get(opponentDeviceId),
-      onCallFeedsChanged = _ref12.onCallFeedsChanged,
-      onCallStateChanged = _ref12.onCallStateChanged,
-      onCallHangup = _ref12.onCallHangup,
-      onCallReplaced = _ref12.onCallReplaced;
+    const deviceMap = this.callHandlers.get(opponentMemberId);
+    const {
+      onCallFeedsChanged,
+      onCallStateChanged,
+      onCallHangup,
+      onCallReplaced
+    } = deviceMap.get(opponentDeviceId);
     call.removeListener(CallEvent.FeedsChanged, onCallFeedsChanged);
     call.removeListener(CallEvent.State, onCallStateChanged);
     call.removeListener(CallEvent.Hangup, onCallHangup);
@@ -1059,11 +984,11 @@ export class GroupCall extends TypedEventEmitter {
     if (call.hangupReason === CallErrorCode.Replaced) {
       return;
     }
-    var usermediaFeed = this.getUserMediaFeed(opponentMemberId, opponentDeviceId);
+    const usermediaFeed = this.getUserMediaFeed(opponentMemberId, opponentDeviceId);
     if (usermediaFeed) {
       this.removeUserMediaFeed(usermediaFeed);
     }
-    var screenshareFeed = this.getScreenshareFeed(opponentMemberId, opponentDeviceId);
+    const screenshareFeed = this.getScreenshareFeed(opponentMemberId, opponentDeviceId);
     if (screenshareFeed) {
       this.removeScreenshareFeed(screenshareFeed);
     }
@@ -1081,7 +1006,7 @@ export class GroupCall extends TypedEventEmitter {
     this.emit(GroupCallEvent.UserMediaFeedsChanged, this.userMediaFeeds);
   }
   replaceUserMediaFeed(existingFeed, replacementFeed) {
-    var feedIndex = this.userMediaFeeds.findIndex(f => f.userId === existingFeed.userId && f.deviceId === existingFeed.deviceId);
+    const feedIndex = this.userMediaFeeds.findIndex(f => f.userId === existingFeed.userId && f.deviceId === existingFeed.deviceId);
     if (feedIndex === -1) {
       throw new Error("Couldn't find user media feed to replace");
     }
@@ -1091,7 +1016,7 @@ export class GroupCall extends TypedEventEmitter {
     this.emit(GroupCallEvent.UserMediaFeedsChanged, this.userMediaFeeds);
   }
   removeUserMediaFeed(callFeed) {
-    var feedIndex = this.userMediaFeeds.findIndex(f => f.userId === callFeed.userId && f.deviceId === callFeed.deviceId);
+    const feedIndex = this.userMediaFeeds.findIndex(f => f.userId === callFeed.userId && f.deviceId === callFeed.deviceId);
     if (feedIndex === -1) {
       throw new Error("Couldn't find user media feed to remove");
     }
@@ -1115,7 +1040,7 @@ export class GroupCall extends TypedEventEmitter {
     this.emit(GroupCallEvent.ScreenshareFeedsChanged, this.screenshareFeeds);
   }
   replaceScreenshareFeed(existingFeed, replacementFeed) {
-    var feedIndex = this.screenshareFeeds.findIndex(f => f.userId === existingFeed.userId && f.deviceId === existingFeed.deviceId);
+    const feedIndex = this.screenshareFeeds.findIndex(f => f.userId === existingFeed.userId && f.deviceId === existingFeed.deviceId);
     if (feedIndex === -1) {
       throw new Error("Couldn't find screenshare feed to replace");
     }
@@ -1124,7 +1049,7 @@ export class GroupCall extends TypedEventEmitter {
     this.emit(GroupCallEvent.ScreenshareFeedsChanged, this.screenshareFeeds);
   }
   removeScreenshareFeed(callFeed) {
-    var feedIndex = this.screenshareFeeds.findIndex(f => f.userId === callFeed.userId && f.deviceId === callFeed.deviceId);
+    const feedIndex = this.screenshareFeeds.findIndex(f => f.userId === callFeed.userId && f.deviceId === callFeed.deviceId);
     if (feedIndex === -1) {
       throw new Error("Couldn't find screenshare feed to remove");
     }
@@ -1137,11 +1062,11 @@ export class GroupCall extends TypedEventEmitter {
    * Recalculates and updates the participant map to match the room state.
    */
   updateParticipants() {
-    var localMember = this.room.getMember(this.client.getSafeUserId());
+    const localMember = this.room.getMember(this.client.getSafeUserId());
     if (!localMember) {
       // The client hasn't fetched enough of the room state to get our own member
       // event. This probably shouldn't happen, but sanity check & exit for now.
-      logger.warn("GroupCall ".concat(this.groupCallId, " updateParticipants() tried to update participants before local room member is available"));
+      logger.warn(`GroupCall ${this.groupCallId} updateParticipants() tried to update participants before local room member is available`);
       return;
     }
     if (this.participantsExpirationTimer !== null) {
@@ -1152,30 +1077,30 @@ export class GroupCall extends TypedEventEmitter {
       this.participants = new Map();
       return;
     }
-    var participants = new Map();
-    var now = Date.now();
-    var entered = this.state === GroupCallState.Entered || this.enteredViaAnotherSession;
-    var nextExpiration = Infinity;
-    for (var e of this.getMemberStateEvents()) {
-      var member = this.room.getMember(e.getStateKey());
-      var content = e.getContent();
-      var calls = Array.isArray(content["m.calls"]) ? content["m.calls"] : [];
-      var call = calls.find(call => call["m.call_id"] === this.groupCallId);
-      var devices = Array.isArray(call === null || call === void 0 ? void 0 : call["m.devices"]) ? call["m.devices"] : [];
+    const participants = new Map();
+    const now = Date.now();
+    const entered = this.state === GroupCallState.Entered || this.enteredViaAnotherSession;
+    let nextExpiration = Infinity;
+    for (const e of this.getMemberStateEvents()) {
+      const member = this.room.getMember(e.getStateKey());
+      const content = e.getContent();
+      const calls = Array.isArray(content["m.calls"]) ? content["m.calls"] : [];
+      const call = calls.find(call => call["m.call_id"] === this.groupCallId);
+      const devices = Array.isArray(call?.["m.devices"]) ? call["m.devices"] : [];
 
       // Filter out invalid and expired devices
-      var validDevices = devices.filter(d => typeof d.device_id === "string" && typeof d.session_id === "string" && typeof d.expires_ts === "number" && d.expires_ts > now && Array.isArray(d.feeds));
+      let validDevices = devices.filter(d => typeof d.device_id === "string" && typeof d.session_id === "string" && typeof d.expires_ts === "number" && d.expires_ts > now && Array.isArray(d.feeds));
 
       // Apply local echo for the unentered case
-      if (!entered && (member === null || member === void 0 ? void 0 : member.userId) === this.client.getUserId()) {
+      if (!entered && member?.userId === this.client.getUserId()) {
         validDevices = validDevices.filter(d => d.device_id !== this.client.getDeviceId());
       }
 
       // Must have a connected device and be joined to the room
-      if (validDevices.length > 0 && (member === null || member === void 0 ? void 0 : member.membership) === KnownMembership.Join) {
-        var deviceMap = new Map();
+      if (validDevices.length > 0 && member?.membership === KnownMembership.Join) {
+        const deviceMap = new Map();
         participants.set(member, deviceMap);
-        for (var d of validDevices) {
+        for (const d of validDevices) {
           deviceMap.set(d.device_id, {
             sessionId: d.session_id,
             screensharing: d.feeds.some(f => f.purpose === SDPStreamMetadataPurpose.Screenshare)
@@ -1187,13 +1112,13 @@ export class GroupCall extends TypedEventEmitter {
 
     // Apply local echo for the entered case
     if (entered) {
-      var _deviceMap = participants.get(localMember);
-      if (_deviceMap === undefined) {
-        _deviceMap = new Map();
-        participants.set(localMember, _deviceMap);
+      let deviceMap = participants.get(localMember);
+      if (deviceMap === undefined) {
+        deviceMap = new Map();
+        participants.set(localMember, deviceMap);
       }
-      if (!_deviceMap.has(this.client.getDeviceId())) {
-        _deviceMap.set(this.client.getDeviceId(), {
+      if (!deviceMap.has(this.client.getDeviceId())) {
+        deviceMap.set(this.client.getDeviceId(), {
           sessionId: this.client.getSessionId(),
           screensharing: this.getLocalFeeds().some(f => f.purpose === SDPStreamMetadataPurpose.Screenshare)
         });
@@ -1211,116 +1136,102 @@ export class GroupCall extends TypedEventEmitter {
    *   returns null, the update will be skipped.
    * @param keepAlive - Whether the request should outlive the window.
    */
-  updateDevices(fn) {
-    var _arguments3 = arguments,
-      _this11 = this;
-    return _asyncToGenerator(function* () {
-      var _event$getContent;
-      var keepAlive = _arguments3.length > 1 && _arguments3[1] !== undefined ? _arguments3[1] : false;
-      var now = Date.now();
-      var localUserId = _this11.client.getUserId();
-      var event = _this11.getMemberStateEvents(localUserId);
-      var content = (_event$getContent = event === null || event === void 0 ? void 0 : event.getContent()) !== null && _event$getContent !== void 0 ? _event$getContent : {};
-      var calls = Array.isArray(content["m.calls"]) ? content["m.calls"] : [];
-      var call = null;
-      var otherCalls = [];
-      for (var c of calls) {
-        if (c["m.call_id"] === _this11.groupCallId) {
-          call = c;
-        } else {
-          otherCalls.push(c);
-        }
+  async updateDevices(fn, keepAlive = false) {
+    const now = Date.now();
+    const localUserId = this.client.getUserId();
+    const event = this.getMemberStateEvents(localUserId);
+    const content = event?.getContent() ?? {};
+    const calls = Array.isArray(content["m.calls"]) ? content["m.calls"] : [];
+    let call = null;
+    const otherCalls = [];
+    for (const c of calls) {
+      if (c["m.call_id"] === this.groupCallId) {
+        call = c;
+      } else {
+        otherCalls.push(c);
       }
-      if (call === null) call = {};
-      var devices = Array.isArray(call["m.devices"]) ? call["m.devices"] : [];
+    }
+    if (call === null) call = {};
+    const devices = Array.isArray(call["m.devices"]) ? call["m.devices"] : [];
 
-      // Filter out invalid and expired devices
-      var validDevices = devices.filter(d => typeof d.device_id === "string" && typeof d.session_id === "string" && typeof d.expires_ts === "number" && d.expires_ts > now && Array.isArray(d.feeds));
-      var newDevices = fn(validDevices);
-      if (newDevices === null) return;
-      var newCalls = [...otherCalls];
-      if (newDevices.length > 0) {
-        newCalls.push(_objectSpread(_objectSpread({}, call), {}, {
-          "m.call_id": _this11.groupCallId,
-          "m.devices": newDevices
-        }));
-      }
-      var newContent = {
-        "m.calls": newCalls
-      };
-      yield _this11.client.sendStateEvent(_this11.room.roomId, EventType.GroupCallMemberPrefix, newContent, localUserId, {
-        keepAlive
-      });
-    })();
+    // Filter out invalid and expired devices
+    const validDevices = devices.filter(d => typeof d.device_id === "string" && typeof d.session_id === "string" && typeof d.expires_ts === "number" && d.expires_ts > now && Array.isArray(d.feeds));
+    const newDevices = fn(validDevices);
+    if (newDevices === null) return;
+    const newCalls = [...otherCalls];
+    if (newDevices.length > 0) {
+      newCalls.push(_objectSpread(_objectSpread({}, call), {}, {
+        "m.call_id": this.groupCallId,
+        "m.devices": newDevices
+      }));
+    }
+    const newContent = {
+      "m.calls": newCalls
+    };
+    await this.client.sendStateEvent(this.room.roomId, EventType.GroupCallMemberPrefix, newContent, localUserId, {
+      keepAlive
+    });
   }
-  addDeviceToMemberState() {
-    var _this12 = this;
-    return _asyncToGenerator(function* () {
-      yield _this12.updateDevices(devices => [...devices.filter(d => d.device_id !== _this12.client.getDeviceId()), {
-        device_id: _this12.client.getDeviceId(),
-        session_id: _this12.client.getSessionId(),
-        expires_ts: Date.now() + DEVICE_TIMEOUT,
-        feeds: _this12.getLocalFeeds().map(feed => ({
-          purpose: feed.purpose
-        }))
-        // TODO: Add data channels
-      }]);
-    })();
+  async addDeviceToMemberState() {
+    await this.updateDevices(devices => [...devices.filter(d => d.device_id !== this.client.getDeviceId()), {
+      device_id: this.client.getDeviceId(),
+      session_id: this.client.getSessionId(),
+      expires_ts: Date.now() + DEVICE_TIMEOUT,
+      feeds: this.getLocalFeeds().map(feed => ({
+        purpose: feed.purpose
+      }))
+      // TODO: Add data channels
+    }]);
   }
-  updateMemberState() {
-    var _this13 = this;
-    return _asyncToGenerator(function* () {
-      // Clear the old update interval before proceeding
-      if (_this13.resendMemberStateTimer !== null) {
-        clearInterval(_this13.resendMemberStateTimer);
-        _this13.resendMemberStateTimer = null;
-      }
-      if (_this13.state === GroupCallState.Entered) {
-        // Add the local device
-        yield _this13.addDeviceToMemberState();
+  async updateMemberState() {
+    // Clear the old update interval before proceeding
+    if (this.resendMemberStateTimer !== null) {
+      clearInterval(this.resendMemberStateTimer);
+      this.resendMemberStateTimer = null;
+    }
+    if (this.state === GroupCallState.Entered) {
+      // Add the local device
+      await this.addDeviceToMemberState();
 
-        // Resend the state event every so often so it doesn't become stale
-        _this13.resendMemberStateTimer = setInterval(/*#__PURE__*/_asyncToGenerator(function* () {
-          logger.log("GroupCall ".concat(_this13.groupCallId, " updateMemberState() resending call member state\""));
-          try {
-            yield _this13.addDeviceToMemberState();
-          } catch (e) {
-            logger.error("GroupCall ".concat(_this13.groupCallId, " updateMemberState() failed to resend call member state"), e);
-          }
-        }), DEVICE_TIMEOUT * 3 / 4);
-      } else {
-        // Remove the local device
-        yield _this13.updateDevices(devices => devices.filter(d => d.device_id !== _this13.client.getDeviceId()), true);
-      }
-    })();
+      // Resend the state event every so often so it doesn't become stale
+      this.resendMemberStateTimer = setInterval(async () => {
+        logger.log(`GroupCall ${this.groupCallId} updateMemberState() resending call member state"`);
+        try {
+          await this.addDeviceToMemberState();
+        } catch (e) {
+          logger.error(`GroupCall ${this.groupCallId} updateMemberState() failed to resend call member state`, e);
+        }
+      }, DEVICE_TIMEOUT * 3 / 4);
+    } else {
+      // Remove the local device
+      await this.updateDevices(devices => devices.filter(d => d.device_id !== this.client.getDeviceId()), true);
+    }
   }
 
   /**
    * Cleans up our member state by filtering out logged out devices, inactive
    * devices, and our own device (if we know we haven't entered).
    */
-  cleanMemberState() {
-    var _this14 = this;
-    return _asyncToGenerator(function* () {
-      var _yield$_this14$client = yield _this14.client.getDevices(),
-        myDevices = _yield$_this14$client.devices;
-      var deviceMap = new Map(myDevices.map(d => [d.device_id, d]));
+  async cleanMemberState() {
+    const {
+      devices: myDevices
+    } = await this.client.getDevices();
+    const deviceMap = new Map(myDevices.map(d => [d.device_id, d]));
 
-      // updateDevices takes care of filtering out inactive devices for us
-      yield _this14.updateDevices(devices => {
-        var newDevices = devices.filter(d => {
-          var device = deviceMap.get(d.device_id);
-          return (device === null || device === void 0 ? void 0 : device.last_seen_ts) !== undefined && !(d.device_id === _this14.client.getDeviceId() && _this14.state !== GroupCallState.Entered && !_this14.enteredViaAnotherSession);
-        });
-
-        // Skip the update if the devices are unchanged
-        return newDevices.length === devices.length ? null : newDevices;
+    // updateDevices takes care of filtering out inactive devices for us
+    await this.updateDevices(devices => {
+      const newDevices = devices.filter(d => {
+        const device = deviceMap.get(d.device_id);
+        return device?.last_seen_ts !== undefined && !(d.device_id === this.client.getDeviceId() && this.state !== GroupCallState.Entered && !this.enteredViaAnotherSession);
       });
-    })();
+
+      // Skip the update if the devices are unchanged
+      return newDevices.length === devices.length ? null : newDevices;
+    });
   }
   getGroupCallStats() {
     if (this.stats === undefined) {
-      var userID = this.client.getUserId() || "unknown";
+      const userID = this.client.getUserId() || "unknown";
       this.stats = new GroupCallStats(this.groupCallId, userID, this.statsCollectIntervalTime);
       this.stats.reports.on(StatsReport.CONNECTION_STATS, this.onConnectionStats);
       this.stats.reports.on(StatsReport.BYTE_SENT_STATS, this.onByteSentStats);