matrix-js-sdk 41.8.0 → 41.9.0

package/lib/matrixrtc/MatrixRTCSession.js

@@ -1,8 +1,5 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+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; }
 /*
 Copyright 2023 - 2026 The Matrix.org Foundation C.I.C.
 
@@ -38,7 +35,7 @@ import { computeSlotId } from "./utils.js";
 /**
  * Events emitted by MatrixRTCSession
  */
-export var MatrixRTCSessionEvent = /*#__PURE__*/function (MatrixRTCSessionEvent) {
+export let MatrixRTCSessionEvent = /*#__PURE__*/function (MatrixRTCSessionEvent) {
   // A member joined, left, or updated a property of their membership.
   MatrixRTCSessionEvent["MembershipsChanged"] = "memberships_changed";
   // We joined or left the session: our own local idea of whether we are joined,
@@ -62,7 +59,7 @@ export var MatrixRTCSessionEvent = /*#__PURE__*/function (MatrixRTCSessionEvent)
 // - we use a `Ms` postfix if the option is a duration to avoid using words like:
 //   `time`, `duration`, `delay`, `timeout`... that might be mistaken/confused with technical terms.
 
-var DEFAULT_SESSION_MEMBERSHIPS_FOR_SLOT_OPTS = {
+const DEFAULT_SESSION_MEMBERSHIPS_FOR_SLOT_OPTS = {
   listenForStickyEvents: true,
   listenForMemberStateEvents: true
 };
@@ -73,16 +70,13 @@ var DEFAULT_SESSION_MEMBERSHIPS_FOR_SLOT_OPTS = {
  */
 export class MatrixRTCSession extends TypedEventEmitter {
   get membershipStatus() {
-    var _this$membershipManag;
-    return (_this$membershipManag = this.membershipManager) === null || _this$membershipManag === void 0 ? void 0 : _this$membershipManag.status;
+    return this.membershipManager?.status;
   }
   get probablyLeft() {
-    var _this$membershipManag2;
-    return (_this$membershipManag2 = this.membershipManager) === null || _this$membershipManag2 === void 0 ? void 0 : _this$membershipManag2.probablyLeft;
+    return this.membershipManager?.probablyLeft;
   }
   get delayId() {
-    var _this$membershipManag3;
-    return (_this$membershipManag3 = this.membershipManager) === null || _this$membershipManag3 === void 0 ? void 0 : _this$membershipManag3.delayId;
+    return this.membershipManager?.delayId;
   }
 
   /**
@@ -93,8 +87,7 @@ export class MatrixRTCSession extends TypedEventEmitter {
    * @deprecated use `slotId` instead.
    */
   get callId() {
-    var _this$slotDescription;
-    return (_this$slotDescription = this.slotDescription) === null || _this$slotDescription === void 0 ? void 0 : _this$slotDescription.id;
+    return this.slotDescription?.id;
   }
   /**
    * The slotId of the call.
@@ -112,19 +105,18 @@ export class MatrixRTCSession extends TypedEventEmitter {
    *
    * By default, this will return *both* sticky and member state events.
    */
-  static sessionMembershipsForSlot(room, slotDescription) {
-    var _arguments = arguments;
-    return _asyncToGenerator(function* () {
-      var options = _arguments.length > 2 && _arguments[2] !== undefined ? _arguments[2] : DEFAULT_SESSION_MEMBERSHIPS_FOR_SLOT_OPTS;
-      var logger = rootLogger.getChild("[MatrixRTCSession ".concat(room.roomId, " ").concat(slotDescription.application, "#").concat(slotDescription.id, "]"));
-      var callMemberEvents = collectMembersEvents(room, options, logger);
-      var callMemberships = yield computeBackendIdentityAndVerifyMemberEvents(room, callMemberEvents, slotDescription, logger);
-      callMemberships.sort((a, b) => a.createdTs() - b.createdTs());
-      if (callMemberships.length > 1) {
-        logger.debug("Call memberships in room ".concat(room.roomId, ", in order: "), callMemberships.map(m => [m.createdTs(), m.userId]));
-      }
-      return callMemberships;
-    })();
+  static async sessionMembershipsForSlot(room, slotDescription,
+  // default both true this implied we combine sticky and state events for the final call state
+  // (prefer sticky events in case of a duplicate)
+  options = DEFAULT_SESSION_MEMBERSHIPS_FOR_SLOT_OPTS) {
+    const logger = rootLogger.getChild(`[MatrixRTCSession ${room.roomId} ${slotDescription.application}#${slotDescription.id}]`);
+    const callMemberEvents = collectMembersEvents(room, options, logger);
+    const callMemberships = await computeBackendIdentityAndVerifyMemberEvents(room, callMemberEvents, slotDescription, logger);
+    callMemberships.sort((a, b) => a.createdTs() - b.createdTs());
+    if (callMemberships.length > 1) {
+      logger.debug(`Call memberships in room ${room.roomId}, in order: `, callMemberships.map(m => [m.createdTs(), m.userId]));
+    }
+    return callMemberships;
   }
 
   /**
@@ -162,13 +154,7 @@ export class MatrixRTCSession extends TypedEventEmitter {
    * @param calculateMembershipsOpts - Options to configure how memberships are calculated for this session.
    */
   constructor(client, roomSubset, slotDescription, calculateMembershipsOpts) {
-    var _this;
     super();
-    _this = this;
-    this.client = client;
-    this.roomSubset = roomSubset;
-    this.slotDescription = slotDescription;
-    this.calculateMembershipsOpts = calculateMembershipsOpts;
     _defineProperty(this, "membershipManager", void 0);
     _defineProperty(this, "encryptionManager", void 0);
     _defineProperty(this, "joinConfig", void 0);
@@ -222,9 +208,9 @@ export class MatrixRTCSession extends TypedEventEmitter {
      */
     // We allow this name schema since this function should only be used for testing purposes.
     // eslint-disable-next-line @typescript-eslint/naming-convention
-    _defineProperty(this, "_onRTCSessionMemberUpdate", /*#__PURE__*/_asyncToGenerator(function* () {
-      yield _this.recalculateSessionMembers();
-    }));
+    _defineProperty(this, "_onRTCSessionMemberUpdate", async () => {
+      await this.recalculateSessionMembers();
+    });
     // helper variables to make sure we do not have parallel running recalculations.
     _defineProperty(this, "recalculateSessionMembersPromise", Promise.resolve());
     /**
@@ -234,44 +220,45 @@ export class MatrixRTCSession extends TypedEventEmitter {
      *
      * This function should be called when the room members or call memberships might have changed.
      */
-    _defineProperty(this, "recalculateSessionMembers", /*#__PURE__*/_asyncToGenerator(function* () {
-      var _this$encryptionManag;
+    _defineProperty(this, "recalculateSessionMembers", async () => {
       // Clear the flag.
-      _this.membershipNeedsRecalculation = false;
-      var oldMemberships = _this.memberships;
-      _this.memberships = yield MatrixRTCSession.sessionMembershipsForSlot(_this.room, _this.slotDescription, _this.calculateMembershipsOpts);
-      var changed = oldMemberships.length != _this.memberships.length || oldMemberships.some((m, i) => !CallMembership.equal(m, _this.memberships[i]));
+      this.membershipNeedsRecalculation = false;
+      const oldMemberships = this.memberships;
+      this.memberships = await MatrixRTCSession.sessionMembershipsForSlot(this.room, this.slotDescription, this.calculateMembershipsOpts);
+      const changed = oldMemberships.length != this.memberships.length || oldMemberships.some((m, i) => !CallMembership.equal(m, this.memberships[i]));
       if (changed) {
-        var _this$membershipManag4, _this$membershipManag5;
-        _this.logger.info("Memberships for call in room ".concat(_this.roomSubset.roomId, " have changed: emitting (").concat(_this.memberships.length, " members)"));
-        logDurationSync(_this.logger, "emit MatrixRTCSessionEvent.MembershipsChanged", () => {
-          _this.emit(MatrixRTCSessionEvent.MembershipsChanged, oldMemberships, _this.memberships);
+        this.logger.info(`Memberships for call in room ${this.roomSubset.roomId} have changed: emitting (${this.memberships.length} members)`);
+        logDurationSync(this.logger, "emit MatrixRTCSessionEvent.MembershipsChanged", () => {
+          this.emit(MatrixRTCSessionEvent.MembershipsChanged, oldMemberships, this.memberships);
         });
-        void ((_this$membershipManag4 = _this.membershipManager) === null || _this$membershipManag4 === void 0 ? void 0 : _this$membershipManag4.onRTCSessionMemberUpdate(_this.memberships));
+        void this.membershipManager?.onRTCSessionMemberUpdate(this.memberships);
         // The `ownMembership` will be set when calling `onRTCSessionMemberUpdate`.
-        var ownMembership = (_this$membershipManag5 = _this.membershipManager) === null || _this$membershipManag5 === void 0 ? void 0 : _this$membershipManag5.ownMembership;
-        if (_this.pendingNotificationToSend && ownMembership && oldMemberships.length === 0) {
-          var _this$joinConfig;
+        const ownMembership = this.membershipManager?.ownMembership;
+        if (this.pendingNotificationToSend && ownMembership && oldMemberships.length === 0) {
           // If we're the first member in the call, we're responsible for
           // sending the notification event
-          if (ownMembership.eventId && (_this$joinConfig = _this.joinConfig) !== null && _this$joinConfig !== void 0 && _this$joinConfig.notificationType) {
-            _this.sendCallNotify(ownMembership.eventId, _this.joinConfig.notificationType, ownMembership.callIntent);
+          if (ownMembership.eventId && this.joinConfig?.notificationType) {
+            this.sendCallNotify(ownMembership.eventId, this.joinConfig.notificationType, ownMembership.callIntent);
           } else {
-            _this.logger.warn("Own membership eventId is undefined, cannot send call notification");
+            this.logger.warn("Own membership eventId is undefined, cannot send call notification");
           }
         }
         // If anyone else joins the session it is no longer our responsibility to send the notification.
         // (If we were the joiner we already did sent the notification in the block above.)
-        if (_this.memberships.length > 0) _this.pendingNotificationToSend = undefined;
+        if (this.memberships.length > 0) this.pendingNotificationToSend = undefined;
       } else {
-        _this.logger.debug("No membership changes detected for room ".concat(_this.roomSubset.roomId));
+        this.logger.debug(`No membership changes detected for room ${this.roomSubset.roomId}`);
       }
       // This also needs to be done if `changed` = false
       // A member might have updated their fingerprint (created_ts)
-      void ((_this$encryptionManag = _this.encryptionManager) === null || _this$encryptionManag === void 0 ? void 0 : _this$encryptionManag.onMembershipsUpdate(oldMemberships));
-      _this.setExpiryTimer();
-    }));
-    this.logger = rootLogger.getChild("[MatrixRTCSession ".concat(roomSubset.roomId, " ").concat(slotDescription.application, "#").concat(slotDescription.id, "]"));
+      this.encryptionManager?.onMembershipsUpdate(oldMemberships);
+      this.setExpiryTimer();
+    });
+    this.client = client;
+    this.roomSubset = roomSubset;
+    this.slotDescription = slotDescription;
+    this.calculateMembershipsOpts = calculateMembershipsOpts;
+    this.logger = rootLogger.getChild(`[MatrixRTCSession ${roomSubset.roomId} ${slotDescription.application}#${slotDescription.id}]`);
     this.roomSubset.on(RoomStateEvent.Members, this.onRoomMemberUpdate);
     this.roomSubset.on(RoomStickyEventsEvent.Update, this.onStickyEventUpdate);
     this.initialMembershipCalculated = this.ensureRecalculateSessionMembers();
@@ -282,25 +269,20 @@ export class MatrixRTCSession extends TypedEventEmitter {
    * This is determined by checking if the relativeExpiry has been set.
    */
   isJoined() {
-    var _this$membershipManag6, _this$membershipManag7;
-    return (_this$membershipManag6 = (_this$membershipManag7 = this.membershipManager) === null || _this$membershipManag7 === void 0 ? void 0 : _this$membershipManag7.isJoined()) !== null && _this$membershipManag6 !== void 0 ? _this$membershipManag6 : false;
+    return this.membershipManager?.isJoined() ?? false;
   }
 
   /**
    * Performs cleanup & removes timers for client shutdown
    */
-  stop() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      var _this2$membershipMana;
-      yield (_this2$membershipMana = _this2.membershipManager) === null || _this2$membershipMana === void 0 ? void 0 : _this2$membershipMana.leave(1000);
-      if (_this2.expiryTimeout) {
-        clearTimeout(_this2.expiryTimeout);
-        _this2.expiryTimeout = undefined;
-      }
-      _this2.roomSubset.off(RoomStateEvent.Members, _this2.onRoomMemberUpdate);
-      _this2.roomSubset.off(RoomStickyEventsEvent.Update, _this2.onStickyEventUpdate);
-    })();
+  async stop() {
+    await this.membershipManager?.leave(1000);
+    if (this.expiryTimeout) {
+      clearTimeout(this.expiryTimeout);
+      this.expiryTimeout = undefined;
+    }
+    this.roomSubset.off(RoomStateEvent.Members, this.onRoomMemberUpdate);
+    this.roomSubset.off(RoomStickyEventsEvent.Update, this.onStickyEventUpdate);
   }
   /**
    * Announces this user and device as joined to the MatrixRTC session,
@@ -319,26 +301,22 @@ export class MatrixRTCSession extends TypedEventEmitter {
    * @param joinConfig - Additional configuration for the joined session.
    */
   joinRTCSession(ownMembershipIdentity, fociPreferred, multiSfuFocus, joinConfig) {
-    var _this$joinConfig2;
     if (this.isJoined()) {
-      this.logger.info("Already joined to session in room ".concat(this.roomSubset.roomId, ": ignoring join call"));
+      this.logger.info(`Already joined to session in room ${this.roomSubset.roomId}: ignoring join call`);
       return;
     } else {
       // Create MembershipManager and pass the RTCSession logger (with room id info)
-      this.membershipManager = joinConfig !== null && joinConfig !== void 0 && joinConfig.unstableSendStickyEvents ? new StickyEventMembershipManager(joinConfig, this.roomSubset, this.client, this.slotDescription, ownMembershipIdentity.memberId, this.logger) : new MembershipManager(joinConfig, this.roomSubset, this.client, this.slotDescription, this.logger);
+      this.membershipManager = joinConfig?.unstableSendStickyEvents ? new StickyEventMembershipManager(joinConfig, this.roomSubset, this.client, this.slotDescription, ownMembershipIdentity.memberId, this.logger) : new MembershipManager(joinConfig, this.roomSubset, this.client, this.slotDescription, this.logger);
       this.reEmitter.reEmit(this.membershipManager, [MembershipManagerEvent.ProbablyLeft, MembershipManagerEvent.StatusChanged, MembershipManagerEvent.DelayIdChanged]);
       // Create Encryption manager
-      var _ref3 = [this.roomSubset, this.client, this.statistics],
-        room = _ref3[0],
-        _client = _ref3[1],
-        statistics = _ref3[2];
-      var transport = new ToDeviceKeyTransport(ownMembershipIdentity, room.roomId, _client, statistics);
+      const [room, client, statistics] = [this.roomSubset, this.client, this.statistics];
+      const transport = new ToDeviceKeyTransport(ownMembershipIdentity, room.roomId, client, statistics);
       this.encryptionManager = new RTCEncryptionManager(ownMembershipIdentity, () => this.memberships, transport, (keyBin, encryptionKeyIndex, membership, rtcBackendIdentity) => {
         this.emit(MatrixRTCSessionEvent.EncryptionKeyChanged, keyBin, encryptionKeyIndex, membership, rtcBackendIdentity);
       }, this.logger);
     }
     this.joinConfig = joinConfig;
-    this.pendingNotificationToSend = (_this$joinConfig2 = this.joinConfig) === null || _this$joinConfig2 === void 0 ? void 0 : _this$joinConfig2.notificationType;
+    this.pendingNotificationToSend = this.joinConfig?.notificationType;
 
     // Join!
     this.membershipManager.join(fociPreferred, multiSfuFocus, e => {
@@ -358,10 +336,9 @@ export class MatrixRTCSession extends TypedEventEmitter {
    * @deprecated use the joinRTCSession method instead
    */
   joinRoomSession(fociPreferred, multiSfuFocus, joinConfig) {
-    var userId = this.client.getUserId(),
-      deviceId = this.client.getDeviceId();
+    const [userId, deviceId] = [this.client.getUserId(), this.client.getDeviceId()];
     // TODO this wants to become a UUID
-    var memberId = "".concat(userId, ":").concat(deviceId);
+    const memberId = `${userId}:${deviceId}`;
     this.joinRTCSession({
       userId,
       deviceId,
@@ -379,21 +356,16 @@ export class MatrixRTCSession extends TypedEventEmitter {
    * A timeout can be provided so that there is a guarantee for the promise to resolve.
    * @returns Whether the membership update was attempted and did not time out.
    */
-  leaveRoomSession() {
-    var _arguments2 = arguments,
-      _this3 = this;
-    return _asyncToGenerator(function* () {
-      var timeout = _arguments2.length > 0 && _arguments2[0] !== undefined ? _arguments2[0] : undefined;
-      if (!_this3.isJoined()) {
-        _this3.logger.info("Not joined to session in room ".concat(_this3.roomSubset.roomId, ": ignoring leave call"));
-        return false;
-      }
-      _this3.logger.info("Leaving call session in room ".concat(_this3.roomSubset.roomId));
-      _this3.encryptionManager.leave();
-      var leavePromise = _this3.membershipManager.leave(timeout);
-      _this3.emit(MatrixRTCSessionEvent.JoinStateChanged, false);
-      return yield leavePromise;
-    })();
+  async leaveRoomSession(timeout = undefined) {
+    if (!this.isJoined()) {
+      this.logger.info(`Not joined to session in room ${this.roomSubset.roomId}: ignoring leave call`);
+      return false;
+    }
+    this.logger.info(`Leaving call session in room ${this.roomSubset.roomId}`);
+    this.encryptionManager.leave();
+    const leavePromise = this.membershipManager.leave(timeout);
+    this.emit(MatrixRTCSessionEvent.JoinStateChanged, false);
+    return await leavePromise;
   }
   /**
    * This returns the focus in use by the oldest membership.
@@ -401,8 +373,8 @@ export class MatrixRTCSession extends TypedEventEmitter {
    * @deprecated use `member.getTransport(session.getOldestMembership())` instead for the specific member you want to get the focus for.
    */
   getFocusInUse() {
-    var oldestMembership = this.getOldestMembership();
-    return oldestMembership === null || oldestMembership === void 0 ? void 0 : oldestMembership.getTransport(oldestMembership);
+    const oldestMembership = this.getOldestMembership();
+    return oldestMembership?.getTransport(oldestMembership);
   }
   getOldestMembership() {
     return this.memberships[0];
@@ -416,8 +388,7 @@ export class MatrixRTCSession extends TypedEventEmitter {
    * @returns A call intent, or `undefined` if no consensus or not given.
    */
   getConsensusCallIntent() {
-    var _this$memberships$fin;
-    var getFirstCallIntent = (_this$memberships$fin = this.memberships.find(m => !!m.callIntent)) === null || _this$memberships$fin === void 0 ? void 0 : _this$memberships$fin.callIntent;
+    const getFirstCallIntent = this.memberships.find(m => !!m.callIntent)?.callIntent;
     if (!getFirstCallIntent) {
       return undefined;
     }
@@ -426,16 +397,12 @@ export class MatrixRTCSession extends TypedEventEmitter {
     }
     return undefined;
   }
-  updateCallIntent(callIntent) {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      var _this4$membershipMana, _this4$membershipMana2;
-      var myMembership = (_this4$membershipMana = _this4.membershipManager) === null || _this4$membershipMana === void 0 ? void 0 : _this4$membershipMana.ownMembership;
-      if (!myMembership) {
-        throw Error("Not connected yet");
-      }
-      yield (_this4$membershipMana2 = _this4.membershipManager) === null || _this4$membershipMana2 === void 0 ? void 0 : _this4$membershipMana2.updateCallIntent(callIntent);
-    })();
+  async updateCallIntent(callIntent) {
+    const myMembership = this.membershipManager?.ownMembership;
+    if (!myMembership) {
+      throw Error("Not connected yet");
+    }
+    await this.membershipManager?.updateCallIntent(callIntent);
   }
 
   /**
@@ -443,8 +410,7 @@ export class MatrixRTCSession extends TypedEventEmitter {
    * the keys.
    */
   reemitEncryptionKeys() {
-    var _this$encryptionManag2;
-    (_this$encryptionManag2 = this.encryptionManager) === null || _this$encryptionManag2 === void 0 || _this$encryptionManag2.getEncryptionKeys().forEach((keyRing, key) => {
+    this.encryptionManager?.getEncryptionKeys().forEach((keyRing, key) => {
       keyRing.forEach(keyInfo => {
         this.emit(MatrixRTCSessionEvent.EncryptionKeyChanged, keyInfo.key, keyInfo.keyIndex, keyInfo.membership, keyInfo.rtcBackendIdentity);
       });
@@ -459,9 +425,9 @@ export class MatrixRTCSession extends TypedEventEmitter {
       clearTimeout(this.expiryTimeout);
       this.expiryTimeout = undefined;
     }
-    var soonestExpiry;
-    for (var membership of this.memberships) {
-      var thisExpiry = membership.getMsUntilExpiry();
+    let soonestExpiry;
+    for (const membership of this.memberships) {
+      const thisExpiry = membership.getMsUntilExpiry();
       // If getMsUntilExpiry is undefined we have a MSC4143 (MatrixRTC) compliant event - it never expires
       // but will be reliably resent on disconnect.
       if (thisExpiry !== undefined && (soonestExpiry === undefined || thisExpiry < soonestExpiry)) {
@@ -481,45 +447,34 @@ export class MatrixRTCSession extends TypedEventEmitter {
    * @param callIntent The type of call this is (e.g. "audio").
    */
   sendCallNotify(parentEventId, notificationType, callIntent) {
-    var _this5 = this;
-    var sendNotificationEvent = /*#__PURE__*/function () {
-      var _ref4 = _asyncToGenerator(function* () {
-        var content = {
-          "m.mentions": {
-            user_ids: [],
-            room: true
-          },
-          "notification_type": notificationType,
-          "m.relates_to": {
-            event_id: parentEventId,
-            rel_type: RelationType.Reference
-          },
-          "sender_ts": Date.now(),
-          "lifetime": 30000 // 30 seconds
-        };
-        if (callIntent) {
-          content["m.call.intent"] = callIntent;
-        }
-        var response = yield _this5.client.sendEvent(_this5.roomSubset.roomId, EventType.RTCNotification, content);
-        return {
-          response,
-          content
-        };
-      });
-      return function sendNotificationEvent() {
-        return _ref4.apply(this, arguments);
+    const sendNotificationEvent = async () => {
+      const content = {
+        "m.mentions": {
+          user_ids: [],
+          room: true
+        },
+        "notification_type": notificationType,
+        "m.relates_to": {
+          event_id: parentEventId,
+          rel_type: RelationType.Reference
+        },
+        "sender_ts": Date.now(),
+        "lifetime": 30000 // 30 seconds
+      };
+      if (callIntent) {
+        content["m.call.intent"] = callIntent;
+      }
+      const response = await this.client.sendEvent(this.roomSubset.roomId, EventType.RTCNotification, content);
+      return {
+        response,
+        content
       };
-    }();
+    };
     void sendNotificationEvent().then(notification => {
       // Join event_id and origin event content
-      var newResult = _objectSpread(_objectSpread({}, notification.response), notification.content);
+      const newResult = _objectSpread(_objectSpread({}, notification.response), notification.content);
       this.emit(MatrixRTCSessionEvent.DidSendCallNotification, newResult);
-    }).catch(_ref5 => {
-      var _ref6 = _slicedToArray(_ref5, 2),
-        errorLegacy = _ref6[0],
-        errorNew = _ref6[1];
-      return this.logger.error("Failed to send call notification", errorLegacy, errorNew);
-    });
+    }).catch(([errorLegacy, errorNew]) => this.logger.error("Failed to send call notification", errorLegacy, errorNew));
   }
   /**
    * Ensures that membership is recalculated when the state of the session may have changed.
@@ -539,35 +494,29 @@ export class MatrixRTCSession extends TypedEventEmitter {
 }
 
 /// Private helpers
-function computeBackendIdentityAndVerifyMemberEvents(_x, _x2, _x3, _x4) {
-  return _computeBackendIdentityAndVerifyMemberEvents.apply(this, arguments);
-}
-function _computeBackendIdentityAndVerifyMemberEvents() {
-  _computeBackendIdentityAndVerifyMemberEvents = _asyncToGenerator(function* (room, callMemberEvents, slotDescription, logger) {
-    var callMemberships = [];
-    for (var memberEvent of callMemberEvents) {
-      var content = memberEvent.getContent();
+async function computeBackendIdentityAndVerifyMemberEvents(room, callMemberEvents, slotDescription, logger) {
+  const callMemberships = [];
+  for (const memberEvent of callMemberEvents) {
+    const content = memberEvent.getContent();
 
-      // Quick filter to avoid unneeded processing of invalid events or left events.
-      if (!quickFilterNonRelevantContents(content, logger)) {
-        continue;
-      }
-      try {
-        var membership = yield CallMembership.parseFromEvent(memberEvent);
-        if (isValidMembership(membership, room, slotDescription, logger)) {
-          callMemberships.push(membership);
-        }
-      } catch (e) {
-        logger.warn("Couldn't construct call membership: ", e);
+    // Quick filter to avoid unneeded processing of invalid events or left events.
+    if (!quickFilterNonRelevantContents(content, logger)) {
+      continue;
+    }
+    try {
+      const membership = await CallMembership.parseFromEvent(memberEvent);
+      if (isValidMembership(membership, room, slotDescription, logger)) {
+        callMemberships.push(membership);
       }
+    } catch (e) {
+      logger.warn("Couldn't construct call membership: ", e);
     }
-    return callMemberships;
-  });
-  return _computeBackendIdentityAndVerifyMemberEvents.apply(this, arguments);
+  }
+  return callMemberships;
 }
 function quickFilterNonRelevantContents(content, logger) {
   // Ignore sticky keys for the count
-  var eventKeysCount = Object.keys(content).filter(k => k !== "msc4354_sticky_key").length;
+  const eventKeysCount = Object.keys(content).filter(k => k !== "msc4354_sticky_key").length;
   // Don't even bother about empty events (saves us from costly type/"key in" checks in bigger rooms)
   if (eventKeysCount === 0) return false;
 
@@ -585,17 +534,16 @@ function quickFilterNonRelevantContents(content, logger) {
   }
 }
 function isValidMembership(membership, room, slotDescription, logger) {
-  var _membership$userId;
   if (membership.slotDescription.id !== slotDescription.id) {
-    logger.info("Ignoring membership of user ".concat(membership.userId, " for a different slot. Theirs: ").concat(JSON.stringify(membership.slotDescription), ", Expected: ").concat(JSON.stringify(slotDescription)));
+    logger.info(`Ignoring membership of user ${membership.userId} for a different slot. Theirs: ${JSON.stringify(membership.slotDescription)}, Expected: ${JSON.stringify(slotDescription)}`);
     return false;
   }
   if (membership.isExpired()) {
-    logger.info("Ignoring expired device membership ".concat(membership.userId, "/").concat(membership.deviceId));
+    logger.info(`Ignoring expired device membership ${membership.userId}/${membership.deviceId}`);
     return false;
   }
-  if (!room.hasMembershipState((_membership$userId = membership.userId) !== null && _membership$userId !== void 0 ? _membership$userId : "", KnownMembership.Join)) {
-    logger.info("Ignoring membership of user ".concat(membership.userId, " who is not in the room."));
+  if (!room.hasMembershipState(membership.userId ?? "", KnownMembership.Join)) {
+    logger.info(`Ignoring membership of user ${membership.userId} who is not in the room.`);
     return false;
   }
   return true;
@@ -605,20 +553,22 @@ function isValidMembership(membership, room, slotDescription, logger) {
  * Collects the raw member events from room state and sticky store.
  */
 function collectMembersEvents(room, options, logger) {
-  var listenForStickyEvents = options.listenForStickyEvents,
-    listenForMemberStateEvents = options.listenForMemberStateEvents;
-  var callMemberEvents = [];
+  const {
+    listenForStickyEvents,
+    listenForMemberStateEvents
+  } = options;
+  let callMemberEvents = [];
   if (listenForStickyEvents) {
     // prefill with sticky events
     callMemberEvents = [...room._unstable_getStickyEvents()].filter(e => e.getType() === EventType.RTCMembership);
   }
   if (listenForMemberStateEvents) {
-    var roomState = room.getLiveTimeline().getState(EventTimeline.FORWARDS);
+    const roomState = room.getLiveTimeline().getState(EventTimeline.FORWARDS);
     if (!roomState) {
       logger.warn("Couldn't get state for room " + room.roomId + "using empty membership array");
       return [];
     }
-    var callMemberStateEvents = roomState.getStateEvents(EventType.GroupCallMemberPrefix);
+    const callMemberStateEvents = roomState.getStateEvents(EventType.GroupCallMemberPrefix);
     callMemberEvents = callMemberEvents.concat(callMemberStateEvents.filter(callMemberStateEvent => !callMemberEvents.some(
     // only care about state events which have keys which we have not yet seen in the sticky events.
     // TODO: I believe this can discard a joined state event if there is a matching left sticky event.