@unwanted/matrix-sdk-mini 34.12.0-1 → 34.12.0-2

package/lib/client.js

@@ -27,10 +27,7 @@ limitations under the License.
 import { SyncApi, SyncState } from "./sync.js";
 import { EventStatus, MatrixEvent, MatrixEventEvent } from "./models/event.js";
 import { StubStore } from "./store/stub.js";
-import { createNewMatrixCall, supportsMatrixCall } from "./webrtc/call.js";
 import { Filter } from "./filter.js";
-import { CallEventHandler } from "./webrtc/callEventHandler.js";
-import { GroupCallEventHandler } from "./webrtc/groupCallEventHandler.js";
 import * as utils from "./utils.js";
 import { noUnsafeEventProps, replaceParam, safeSet, sleep } from "./utils.js";
 import { Direction, EventTimeline } from "./models/event-timeline.js";
@@ -59,8 +56,6 @@ import { BackupManager } from "./crypto/backup.js";
 import { DEFAULT_TREE_POWER_LEVELS_TEMPLATE, MSC3089TreeSpace } from "./models/MSC3089TreeSpace.js";
 import { SearchOrderBy } from "./@types/search.js";
 import { PushRuleActionName, PushRuleKind } from "./@types/PushRules.js";
-import { GroupCall } from "./webrtc/groupCall.js";
-import { MediaHandler } from "./webrtc/mediaHandler.js";
 import { TypedEventEmitter } from "./models/typed-event-emitter.js";
 import { MAIN_ROOM_TIMELINE, ReceiptType } from "./@types/read_receipts.js";
 import { SlidingSyncSdk } from "./sliding-sync-sdk.js";
@@ -73,7 +68,6 @@ import { buildFeatureSupportMap, Feature, ServerSupport } from "./feature.js";
 import { RUST_SDK_STORE_PREFIX } from "./rust-crypto/constants.js";
 import { decodeRecoveryKey, CryptoEvent } from "./crypto-api/index.js";
 import { ServerSideSecretStorageImpl } from "./secret-storage.js";
-import { MatrixRTCSessionManager } from "./matrixrtc/MatrixRTCSessionManager.js";
 import { getRelationsThreadFilter } from "./thread-utils.js";
 import { KnownMembership } from "./@types/membership.js";
 import { ServerCapabilities } from "./serverCapabilities.js";
@@ -177,9 +171,6 @@ export class MatrixClient extends TypedEventEmitter {
     // one of crypto or rustCrypto
     _defineProperty(this, "cryptoCallbacks", void 0);
     // XXX: Intended private, used in code.
-    _defineProperty(this, "callEventHandler", void 0);
-    // XXX: Intended private, used in code.
-    _defineProperty(this, "groupCallEventHandler", void 0);
     _defineProperty(this, "supportsCallTransfer", false);
     // XXX: Intended private, used in code.
     _defineProperty(this, "forceTURN", false);
@@ -222,7 +213,6 @@ export class MatrixClient extends TypedEventEmitter {
     _defineProperty(this, "checkTurnServersIntervalID", void 0);
     _defineProperty(this, "exportedOlmDeviceToImport", void 0);
     _defineProperty(this, "txnCtr", 0);
-    _defineProperty(this, "mediaHandler", new MediaHandler(this));
     _defineProperty(this, "sessionId", void 0);
     /** IDs of events which are currently being encrypted.
      *
@@ -236,23 +226,7 @@ export class MatrixClient extends TypedEventEmitter {
     _defineProperty(this, "_secretStorage", void 0);
     // A manager for determining which invites should be ignored.
     _defineProperty(this, "ignoredInvites", void 0);
-    _defineProperty(this, "matrixRTC", void 0);
     _defineProperty(this, "serverCapabilitiesService", void 0);
-    _defineProperty(this, "startCallEventHandler", () => {
-      if (this.isInitialSyncComplete()) {
-        if (supportsMatrixCall()) {
-          this.callEventHandler.start();
-          this.groupCallEventHandler.start();
-        }
-        this.off(ClientEvent.Sync, this.startCallEventHandler);
-      }
-    });
-    _defineProperty(this, "startMatrixRTC", () => {
-      if (this.isInitialSyncComplete()) {
-        this.matrixRTC.start();
-        this.off(ClientEvent.Sync, this.startMatrixRTC);
-      }
-    });
     /**
      * Once the client has been initialised, we want to clear notifications we
      * know for a fact should be here.
@@ -342,19 +316,6 @@ export class MatrixClient extends TypedEventEmitter {
         };
       }());
     }
-    if (supportsMatrixCall()) {
-      this.callEventHandler = new CallEventHandler(this);
-      this.groupCallEventHandler = new GroupCallEventHandler(this);
-      this.canSupportVoip = true;
-      // Start listening for calls after the initial sync is done
-      // We do not need to backfill the call event buffer
-      // with encrypted events that might never get decrypted
-      this.on(ClientEvent.Sync, this.startCallEventHandler);
-    }
-
-    // NB. We initialise MatrixRTC whether we have call support or not: this is just
-    // the underlying session management and doesn't use any actual media capabilities
-    this.matrixRTC = new MatrixRTCSessionManager(this);
     this.serverCapabilitiesService = new ServerCapabilities(this.http);
     this.on(ClientEvent.Sync, this.fixupRoomNotifications);
     this.timelineSupport = Boolean(opts.timelineSupport);
@@ -407,7 +368,6 @@ export class MatrixClient extends TypedEventEmitter {
         return;
       }
       _this2.clientRunning = true;
-      _this2.on(ClientEvent.Sync, _this2.startMatrixRTC);
 
       // Create our own user object artificially (instead of waiting for sync)
       // so it's always available, even if the user is not in any rooms etc.
@@ -484,10 +444,9 @@ export class MatrixClient extends TypedEventEmitter {
    * clean shutdown.
    */
   stopClient() {
-    var _this$cryptoBackend, _this$syncApi, _this$peekSync, _this$callEventHandle, _this$groupCallEventH;
+    var _this$cryptoBackend, _this$syncApi, _this$peekSync;
     (_this$cryptoBackend = this.cryptoBackend) === null || _this$cryptoBackend === void 0 || _this$cryptoBackend.stop(); // crypto might have been initialised even if the client wasn't fully started
 
-    this.off(ClientEvent.Sync, this.startMatrixRTC);
     if (!this.clientRunning) return; // already stopped
 
     this.logger.debug("stopping MatrixClient");
@@ -495,17 +454,12 @@ export class MatrixClient extends TypedEventEmitter {
     (_this$syncApi = this.syncApi) === null || _this$syncApi === void 0 || _this$syncApi.stop();
     this.syncApi = undefined;
     (_this$peekSync = this.peekSync) === null || _this$peekSync === void 0 || _this$peekSync.stopPeeking();
-    (_this$callEventHandle = this.callEventHandler) === null || _this$callEventHandle === void 0 || _this$callEventHandle.stop();
-    (_this$groupCallEventH = this.groupCallEventHandler) === null || _this$groupCallEventH === void 0 || _this$groupCallEventH.stop();
-    this.callEventHandler = undefined;
-    this.groupCallEventHandler = undefined;
     globalThis.clearInterval(this.checkTurnServersIntervalID);
     this.checkTurnServersIntervalID = undefined;
     if (this.clientWellKnownIntervalID !== undefined) {
       globalThis.clearInterval(this.clientWellKnownIntervalID);
     }
     this.toDeviceMessageQueue.stop();
-    this.matrixRTC.stop();
     this.serverCapabilitiesService.stop();
   }
 
@@ -797,13 +751,6 @@ export class MatrixClient extends TypedEventEmitter {
     return this.canSupportVoip;
   }
 
-  /**
-   * @returns
-   */
-  getMediaHandler() {
-    return this.mediaHandler;
-  }
-
   /**
    * Set whether VoIP calls are forced to use only TURN
    * candidates. This is the same as the forceTURN option
@@ -830,40 +777,6 @@ export class MatrixClient extends TypedEventEmitter {
   getUseE2eForGroupCall() {
     return this.useE2eForGroupCall;
   }
-
-  /**
-   * Creates a new call.
-   * The place*Call methods on the returned call can be used to actually place a call
-   *
-   * @param roomId - The room the call is to be placed in.
-   * @returns the call or null if the browser doesn't support calling.
-   */
-  createCall(roomId) {
-    return createNewMatrixCall(this, roomId);
-  }
-
-  /**
-   * Creates a new group call and sends the associated state event
-   * to alert other members that the room now has a group call.
-   *
-   * @param roomId - The room the call is to be placed in.
-   */
-  createGroupCall(roomId, type, isPtt, intent, dataChannelsEnabled, dataChannelOptions) {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      if (_this9.getGroupCallForRoom(roomId)) {
-        throw new Error("".concat(roomId, " already has an existing group call"));
-      }
-      var room = _this9.getRoom(roomId);
-      if (!room) {
-        throw new Error("Cannot find room ".concat(roomId));
-      }
-
-      // Because without Media section a WebRTC connection is not possible, so need a RTCDataChannel to set up a
-      // no media WebRTC connection anyway.
-      return new GroupCall(_this9, room, type, isPtt, intent, undefined, dataChannelsEnabled || _this9.isVoipWithNoMediaAllowed, dataChannelOptions, _this9.isVoipWithNoMediaAllowed, _this9.useLivekitForGroupCalls, _this9.livekitServiceURL).create();
-    })();
-  }
   getLivekitServiceURL() {
     return this.livekitServiceURL;
   }
@@ -874,29 +787,6 @@ export class MatrixClient extends TypedEventEmitter {
     this.livekitServiceURL = newURL;
   }
 
-  /**
-   * Wait until an initial state for the given room has been processed by the
-   * client and the client is aware of any ongoing group calls. Awaiting on
-   * the promise returned by this method before calling getGroupCallForRoom()
-   * avoids races where getGroupCallForRoom is called before the state for that
-   * room has been processed. It does not, however, fix other races, eg. two
-   * clients both creating a group call at the same time.
-   * @param roomId - The room ID to wait for
-   * @returns A promise that resolves once existing group calls in the room
-   *          have been processed.
-   */
-  waitUntilRoomReadyForGroupCalls(roomId) {
-    return this.groupCallEventHandler.waitUntilRoomReadyForGroupCalls(roomId);
-  }
-
-  /**
-   * Get an existing group call for the provided room.
-   * @returns The group call or null if it doesn't already exist.
-   */
-  getGroupCallForRoom(roomId) {
-    return this.groupCallEventHandler.groupCalls.get(roomId) || null;
-  }
-
   /**
    * Get the current sync state.
    * @returns the sync state, which may be null.
@@ -999,11 +889,11 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Promise resolving with The capabilities of the homeserver
    */
   getCapabilities() {
-    var _this10 = this;
+    var _this9 = this;
     return _asyncToGenerator(function* () {
-      var caps = _this10.serverCapabilitiesService.getCachedCapabilities();
+      var caps = _this9.serverCapabilitiesService.getCachedCapabilities();
       if (caps) return caps;
-      return _this10.serverCapabilitiesService.fetchCapabilities();
+      return _this9.serverCapabilitiesService.fetchCapabilities();
     })();
   }
 
@@ -1039,43 +929,43 @@ export class MatrixClient extends TypedEventEmitter {
    * @deprecated libolm is deprecated. Prefer {@link initRustCrypto}.
    */
   initCrypto() {
-    var _this11 = this;
+    var _this10 = this;
     return _asyncToGenerator(function* () {
-      if (_this11.cryptoBackend) {
-        _this11.logger.warn("Attempt to re-initialise e2e encryption on MatrixClient");
+      if (_this10.cryptoBackend) {
+        _this10.logger.warn("Attempt to re-initialise e2e encryption on MatrixClient");
         return;
       }
-      if (!_this11.cryptoStore) {
+      if (!_this10.cryptoStore) {
         // the cryptostore is provided by sdk.createClient, so this shouldn't happen
         throw new Error("Cannot enable encryption: no cryptoStore provided");
       }
-      _this11.logger.debug("Crypto: Starting up crypto store...");
-      yield _this11.cryptoStore.startup();
-      var userId = _this11.getUserId();
+      _this10.logger.debug("Crypto: Starting up crypto store...");
+      yield _this10.cryptoStore.startup();
+      var userId = _this10.getUserId();
       if (userId === null) {
         throw new Error("Cannot enable encryption on MatrixClient with unknown userId: " + "ensure userId is passed in createClient().");
       }
-      if (_this11.deviceId === null) {
+      if (_this10.deviceId === null) {
         throw new Error("Cannot enable encryption on MatrixClient with unknown deviceId: " + "ensure deviceId is passed in createClient().");
       }
-      var crypto = new Crypto(_this11, userId, _this11.deviceId, _this11.store, _this11.cryptoStore, _this11.verificationMethods);
-      _this11.reEmitter.reEmit(crypto, [LegacyCryptoEvent.KeyBackupFailed, LegacyCryptoEvent.KeyBackupSessionsRemaining, LegacyCryptoEvent.RoomKeyRequest, LegacyCryptoEvent.RoomKeyRequestCancellation, LegacyCryptoEvent.Warning, LegacyCryptoEvent.DevicesUpdated, LegacyCryptoEvent.WillUpdateDevices, LegacyCryptoEvent.DeviceVerificationChanged, LegacyCryptoEvent.UserTrustStatusChanged, LegacyCryptoEvent.KeysChanged]);
-      _this11.logger.debug("Crypto: initialising crypto object...");
+      var crypto = new Crypto(_this10, userId, _this10.deviceId, _this10.store, _this10.cryptoStore, _this10.verificationMethods);
+      _this10.reEmitter.reEmit(crypto, [LegacyCryptoEvent.KeyBackupFailed, LegacyCryptoEvent.KeyBackupSessionsRemaining, LegacyCryptoEvent.RoomKeyRequest, LegacyCryptoEvent.RoomKeyRequestCancellation, LegacyCryptoEvent.Warning, LegacyCryptoEvent.DevicesUpdated, LegacyCryptoEvent.WillUpdateDevices, LegacyCryptoEvent.DeviceVerificationChanged, LegacyCryptoEvent.UserTrustStatusChanged, LegacyCryptoEvent.KeysChanged]);
+      _this10.logger.debug("Crypto: initialising crypto object...");
       yield crypto.init({
-        exportedOlmDevice: _this11.exportedOlmDeviceToImport,
-        pickleKey: _this11.pickleKey
+        exportedOlmDevice: _this10.exportedOlmDeviceToImport,
+        pickleKey: _this10.pickleKey
       });
-      delete _this11.exportedOlmDeviceToImport;
-      _this11.olmVersion = Crypto.getOlmVersion();
+      delete _this10.exportedOlmDeviceToImport;
+      _this10.olmVersion = Crypto.getOlmVersion();
 
       // if crypto initialisation was successful, tell it to attach its event handlers.
-      crypto.registerEventHandlers(_this11);
-      _this11.cryptoBackend = _this11.crypto = crypto;
+      crypto.registerEventHandlers(_this10);
+      _this10.cryptoBackend = _this10.crypto = crypto;
 
       // upload our keys in the background
-      _this11.crypto.uploadDeviceKeys().catch(e => {
+      _this10.crypto.uploadDeviceKeys().catch(e => {
         // TODO: throwing away this error is a really bad idea.
-        _this11.logger.error("Error uploading device keys", e);
+        _this10.logger.error("Error uploading device keys", e);
       });
     })();
   }
@@ -1098,54 +988,54 @@ export class MatrixClient extends TypedEventEmitter {
    */
   initRustCrypto() {
     var _arguments = arguments,
-      _this12 = this;
+      _this11 = this;
     return _asyncToGenerator(function* () {
-      var _this12$pickleKey;
+      var _this11$pickleKey;
       var args = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : {};
-      if (_this12.cryptoBackend) {
-        _this12.logger.warn("Attempt to re-initialise e2e encryption on MatrixClient");
+      if (_this11.cryptoBackend) {
+        _this11.logger.warn("Attempt to re-initialise e2e encryption on MatrixClient");
         return;
       }
-      var userId = _this12.getUserId();
+      var userId = _this11.getUserId();
       if (userId === null) {
         throw new Error("Cannot enable encryption on MatrixClient with unknown userId: " + "ensure userId is passed in createClient().");
       }
-      var deviceId = _this12.getDeviceId();
+      var deviceId = _this11.getDeviceId();
       if (deviceId === null) {
         throw new Error("Cannot enable encryption on MatrixClient with unknown deviceId: " + "ensure deviceId is passed in createClient().");
       }
 
       // importing rust-crypto will download the webassembly, so we delay it until we know it will be
       // needed.
-      _this12.logger.debug("Downloading Rust crypto library");
+      _this11.logger.debug("Downloading Rust crypto library");
       var RustCrypto = yield import("./rust-crypto/index.js");
       var rustCrypto = yield RustCrypto.initRustCrypto({
-        logger: _this12.logger,
-        http: _this12.http,
+        logger: _this11.logger,
+        http: _this11.http,
         userId: userId,
         deviceId: deviceId,
-        secretStorage: _this12.secretStorage,
-        cryptoCallbacks: _this12.cryptoCallbacks,
+        secretStorage: _this11.secretStorage,
+        cryptoCallbacks: _this11.cryptoCallbacks,
         storePrefix: args.useIndexedDB === false ? null : RUST_SDK_STORE_PREFIX,
         storeKey: args.storageKey,
         storePassphrase: args.storagePassword,
-        legacyCryptoStore: _this12.cryptoStore,
-        legacyPickleKey: (_this12$pickleKey = _this12.pickleKey) !== null && _this12$pickleKey !== void 0 ? _this12$pickleKey : "DEFAULT_KEY",
+        legacyCryptoStore: _this11.cryptoStore,
+        legacyPickleKey: (_this11$pickleKey = _this11.pickleKey) !== null && _this11$pickleKey !== void 0 ? _this11$pickleKey : "DEFAULT_KEY",
         legacyMigrationProgressListener: (progress, total) => {
-          _this12.emit(CryptoEvent.LegacyCryptoStoreMigrationProgress, progress, total);
+          _this11.emit(CryptoEvent.LegacyCryptoStoreMigrationProgress, progress, total);
         }
       });
-      rustCrypto.setSupportedVerificationMethods(_this12.verificationMethods);
-      _this12.cryptoBackend = rustCrypto;
+      rustCrypto.setSupportedVerificationMethods(_this11.verificationMethods);
+      _this11.cryptoBackend = rustCrypto;
 
       // attach the event listeners needed by RustCrypto
-      _this12.on(RoomMemberEvent.Membership, rustCrypto.onRoomMembership.bind(rustCrypto));
-      _this12.on(ClientEvent.Event, event => {
+      _this11.on(RoomMemberEvent.Membership, rustCrypto.onRoomMembership.bind(rustCrypto));
+      _this11.on(ClientEvent.Event, event => {
         rustCrypto.onLiveEventFromSync(event);
       });
 
       // re-emit the events emitted by the crypto impl
-      _this12.reEmitter.reEmit(rustCrypto, [CryptoEvent.VerificationRequestReceived, CryptoEvent.UserTrustStatusChanged, CryptoEvent.KeyBackupStatus, CryptoEvent.KeyBackupSessionsRemaining, CryptoEvent.KeyBackupFailed, CryptoEvent.KeyBackupDecryptionKeyCached, CryptoEvent.KeysChanged, CryptoEvent.DevicesUpdated, CryptoEvent.WillUpdateDevices]);
+      _this11.reEmitter.reEmit(rustCrypto, [CryptoEvent.VerificationRequestReceived, CryptoEvent.UserTrustStatusChanged, CryptoEvent.KeyBackupStatus, CryptoEvent.KeyBackupSessionsRemaining, CryptoEvent.KeyBackupFailed, CryptoEvent.KeyBackupDecryptionKeyCached, CryptoEvent.KeysChanged, CryptoEvent.DevicesUpdated, CryptoEvent.WillUpdateDevices]);
     })();
   }
 
@@ -1205,9 +1095,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @deprecated Does nothing.
    */
   uploadKeys() {
-    var _this13 = this;
+    var _this12 = this;
     return _asyncToGenerator(function* () {
-      _this13.logger.warn("MatrixClient.uploadKeys is deprecated");
+      _this12.logger.warn("MatrixClient.uploadKeys is deprecated");
     })();
   }
 
@@ -1331,12 +1221,12 @@ export class MatrixClient extends TypedEventEmitter {
     return this.setDeviceVerification(userId, deviceId, null, null, known);
   }
   setDeviceVerification(userId, deviceId, verified, blocked, known) {
-    var _this14 = this;
+    var _this13 = this;
     return _asyncToGenerator(function* () {
-      if (!_this14.crypto) {
+      if (!_this13.crypto) {
         throw new Error("End-to-end encryption disabled");
       }
-      yield _this14.crypto.setDeviceVerification(userId, deviceId, verified, blocked, known);
+      yield _this13.crypto.setDeviceVerification(userId, deviceId, verified, blocked, known);
     })();
   }
 
@@ -1983,12 +1873,12 @@ export class MatrixClient extends TypedEventEmitter {
    * @deprecated Not supported for Rust Cryptography.
    */
   getEventSenderDeviceInfo(event) {
-    var _this15 = this;
+    var _this14 = this;
     return _asyncToGenerator(function* () {
-      if (!_this15.crypto) {
+      if (!_this14.crypto) {
         return null;
       }
-      return _this15.crypto.getEventSenderDeviceInfo(event);
+      return _this14.crypto.getEventSenderDeviceInfo(event);
     })();
   }
 
@@ -2003,9 +1893,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @deprecated Not supported for Rust Cryptography.
    */
   isEventSenderVerified(event) {
-    var _this16 = this;
+    var _this15 = this;
     return _asyncToGenerator(function* () {
-      var device = yield _this16.getEventSenderDeviceInfo(event);
+      var device = yield _this15.getEventSenderDeviceInfo(event);
       if (!device) {
         return false;
       }
@@ -2208,11 +2098,11 @@ export class MatrixClient extends TypedEventEmitter {
    * @deprecated Prefer {@link CryptoApi.getKeyBackupInfo}.
    */
   getKeyBackupVersion() {
-    var _this17 = this;
+    var _this16 = this;
     return _asyncToGenerator(function* () {
       var res;
       try {
-        res = yield _this17.http.authedRequest(Method.Get, "/room_keys/version", undefined, undefined, {
+        res = yield _this16.http.authedRequest(Method.Get, "/room_keys/version", undefined, undefined, {
           prefix: ClientPrefix.V3
         });
       } catch (e) {
@@ -2300,12 +2190,12 @@ export class MatrixClient extends TypedEventEmitter {
    */
   prepareKeyBackupVersion(password) {
     var _arguments2 = arguments,
-      _this18 = this;
+      _this17 = this;
     return _asyncToGenerator(function* () {
       var opts = _arguments2.length > 1 && _arguments2[1] !== undefined ? _arguments2[1] : {
         secureSecretStorage: false
       };
-      if (!_this18.crypto) {
+      if (!_this17.crypto) {
         throw new Error("End-to-end encryption disabled");
       }
 
@@ -2315,10 +2205,10 @@ export class MatrixClient extends TypedEventEmitter {
         auth_data,
         recovery_key,
         privateKey
-      } = yield _this18.crypto.backupManager.prepareKeyBackupVersion(password);
+      } = yield _this17.crypto.backupManager.prepareKeyBackupVersion(password);
       if (opts.secureSecretStorage) {
-        yield _this18.secretStorage.store("m.megolm_backup.v1", encodeBase64(privateKey));
-        _this18.logger.info("Key backup private key stored in secret storage");
+        yield _this17.secretStorage.store("m.megolm_backup.v1", encodeBase64(privateKey));
+        _this17.logger.info("Key backup private key stored in secret storage");
       }
       return {
         algorithm,
@@ -2350,12 +2240,12 @@ export class MatrixClient extends TypedEventEmitter {
    * @deprecated Use {@link Crypto.CryptoApi.resetKeyBackup | `CryptoApi.resetKeyBackup`}.
    */
   createKeyBackupVersion(info) {
-    var _this19 = this;
+    var _this18 = this;
     return _asyncToGenerator(function* () {
-      if (!_this19.crypto) {
+      if (!_this18.crypto) {
         throw new Error("End-to-end encryption disabled");
       }
-      yield _this19.crypto.backupManager.createKeyBackupVersion(info);
+      yield _this18.crypto.backupManager.createKeyBackupVersion(info);
       var data = {
         algorithm: info.algorithm,
         auth_data: info.auth_data
@@ -2365,25 +2255,25 @@ export class MatrixClient extends TypedEventEmitter {
       // older devices with cross-signing. This can probably go away very soon in
       // favour of just signing with the cross-singing master key.
       // XXX: Private member access
-      yield _this19.crypto.signObject(data.auth_data);
-      if (_this19.cryptoCallbacks.getCrossSigningKey &&
+      yield _this18.crypto.signObject(data.auth_data);
+      if (_this18.cryptoCallbacks.getCrossSigningKey &&
       // XXX: Private member access
-      _this19.crypto.crossSigningInfo.getId()) {
+      _this18.crypto.crossSigningInfo.getId()) {
         // now also sign the auth data with the cross-signing master key
         // we check for the callback explicitly here because we still want to be able
         // to create an un-cross-signed key backup if there is a cross-signing key but
         // no callback supplied.
         // XXX: Private member access
-        yield _this19.crypto.crossSigningInfo.signObject(data.auth_data, "master");
+        yield _this18.crypto.crossSigningInfo.signObject(data.auth_data, "master");
       }
-      var res = yield _this19.http.authedRequest(Method.Post, "/room_keys/version", undefined, data);
+      var res = yield _this18.http.authedRequest(Method.Post, "/room_keys/version", undefined, data);
 
       // We could assume everything's okay and enable directly, but this ensures
       // we run the same signature verification that will be used for future
       // sessions.
-      yield _this19.checkKeyBackup();
-      if (!_this19.getKeyBackupEnabled()) {
-        _this19.logger.error("Key backup not usable even though we just created it");
+      yield _this18.checkKeyBackup();
+      if (!_this18.getKeyBackupEnabled()) {
+        _this18.logger.error("Key backup not usable even though we just created it");
       }
       return res;
     })();
@@ -2393,12 +2283,12 @@ export class MatrixClient extends TypedEventEmitter {
    * @deprecated Use {@link Crypto.CryptoApi.deleteKeyBackupVersion | `CryptoApi.deleteKeyBackupVersion`}.
    */
   deleteKeyBackupVersion(version) {
-    var _this20 = this;
+    var _this19 = this;
     return _asyncToGenerator(function* () {
-      if (!_this20.cryptoBackend) {
+      if (!_this19.cryptoBackend) {
         throw new Error("End-to-end encryption disabled");
       }
-      yield _this20.cryptoBackend.deleteKeyBackupVersion(version);
+      yield _this19.cryptoBackend.deleteKeyBackupVersion(version);
     })();
   }
   makeKeyBackupPath(roomId, sessionId, version) {
@@ -2437,13 +2327,13 @@ export class MatrixClient extends TypedEventEmitter {
    */
 
   sendKeyBackup(roomId, sessionId, version, data) {
-    var _this21 = this;
+    var _this20 = this;
     return _asyncToGenerator(function* () {
-      if (!_this21.crypto) {
+      if (!_this20.crypto) {
         throw new Error("End-to-end encryption disabled");
       }
-      var path = _this21.makeKeyBackupPath(roomId, sessionId, version);
-      yield _this21.http.authedRequest(Method.Put, path.path, path.queryData, data, {
+      var path = _this20.makeKeyBackupPath(roomId, sessionId, version);
+      yield _this20.http.authedRequest(Method.Put, path.path, path.queryData, data, {
         prefix: ClientPrefix.V3
       });
     })();
@@ -2457,12 +2347,12 @@ export class MatrixClient extends TypedEventEmitter {
    * {@link CryptoApi.resetKeyBackup}, so there is probably no need to call this manually.
    */
   scheduleAllGroupSessionsForBackup() {
-    var _this22 = this;
+    var _this21 = this;
     return _asyncToGenerator(function* () {
-      if (!_this22.crypto) {
+      if (!_this21.crypto) {
         throw new Error("End-to-end encryption disabled");
       }
-      yield _this22.crypto.backupManager.scheduleAllGroupSessionsForBackup();
+      yield _this21.crypto.backupManager.scheduleAllGroupSessionsForBackup();
     })();
   }
 
@@ -2555,10 +2445,10 @@ export class MatrixClient extends TypedEventEmitter {
    * @deprecated Prefer {@link CryptoApi.restoreKeyBackupWithPassphrase | `CryptoApi.restoreKeyBackupWithPassphrase`}.
    */
   restoreKeyBackupWithPassword(password, targetRoomId, targetSessionId, backupInfo, opts) {
-    var _this23 = this;
+    var _this22 = this;
     return _asyncToGenerator(function* () {
       var privKey = yield keyFromAuthData(backupInfo.auth_data, password);
-      return _this23.restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts);
+      return _this22.restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts);
     })();
   }
 
@@ -2578,22 +2468,22 @@ export class MatrixClient extends TypedEventEmitter {
    * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
    */
   restoreKeyBackupWithSecretStorage(backupInfo, targetRoomId, targetSessionId, opts) {
-    var _this24 = this;
+    var _this23 = this;
     return _asyncToGenerator(function* () {
-      if (!_this24.cryptoBackend) {
+      if (!_this23.cryptoBackend) {
         throw new Error("End-to-end encryption disabled");
       }
-      var storedKey = yield _this24.secretStorage.get("m.megolm_backup.v1");
+      var storedKey = yield _this23.secretStorage.get("m.megolm_backup.v1");
 
       // ensure that the key is in the right format.  If not, fix the key and
       // store the fixed version
       var fixedKey = fixBackupKey(storedKey);
       if (fixedKey) {
-        var keys = yield _this24.secretStorage.getKey();
-        yield _this24.secretStorage.store("m.megolm_backup.v1", fixedKey, [keys[0]]);
+        var keys = yield _this23.secretStorage.getKey();
+        yield _this23.secretStorage.store("m.megolm_backup.v1", fixedKey, [keys[0]]);
       }
       var privKey = decodeBase64(fixedKey || storedKey);
-      return _this24.restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts);
+      return _this23.restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts);
     })();
   }
 
@@ -2651,24 +2541,24 @@ export class MatrixClient extends TypedEventEmitter {
    * @deprecated Prefer {@link CryptoApi.restoreKeyBackup | `CryptoApi.restoreKeyBackup`}.
    */
   restoreKeyBackupWithCache(targetRoomId, targetSessionId, backupInfo, opts) {
-    var _this25 = this;
+    var _this24 = this;
     return _asyncToGenerator(function* () {
-      if (!_this25.cryptoBackend) {
+      if (!_this24.cryptoBackend) {
         throw new Error("End-to-end encryption disabled");
       }
-      var privKey = yield _this25.cryptoBackend.getSessionBackupPrivateKey();
+      var privKey = yield _this24.cryptoBackend.getSessionBackupPrivateKey();
       if (!privKey) {
         throw new Error("Couldn't get key");
       }
-      return _this25.restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts);
+      return _this24.restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts);
     })();
   }
   restoreKeyBackup(privKey, targetRoomId, targetSessionId, backupInfo, opts) {
-    var _this26 = this;
+    var _this25 = this;
     return _asyncToGenerator(function* () {
       var cacheCompleteCallback = opts === null || opts === void 0 ? void 0 : opts.cacheCompleteCallback;
       var progressCallback = opts === null || opts === void 0 ? void 0 : opts.progressCallback;
-      if (!_this26.cryptoBackend) {
+      if (!_this25.cryptoBackend) {
         throw new Error("End-to-end encryption disabled");
       }
       if (!backupInfo.version) {
@@ -2678,8 +2568,8 @@ export class MatrixClient extends TypedEventEmitter {
       var totalKeyCount = 0;
       var totalFailures = 0;
       var totalImported = 0;
-      var path = _this26.makeKeyBackupPath(targetRoomId, targetSessionId, backupVersion);
-      var backupDecryptor = yield _this26.cryptoBackend.getBackupDecryptor(backupInfo, privKey);
+      var path = _this25.makeKeyBackupPath(targetRoomId, targetSessionId, backupVersion);
+      var backupDecryptor = yield _this25.cryptoBackend.getBackupDecryptor(backupInfo, privKey);
       var untrusted = !backupDecryptor.sourceTrusted;
       try {
         if (!(privKey instanceof Uint8Array)) {
@@ -2688,15 +2578,15 @@ export class MatrixClient extends TypedEventEmitter {
         }
         // Cache the key, if possible.
         // This is async.
-        _this26.cryptoBackend.storeSessionBackupPrivateKey(privKey, backupVersion).catch(e => {
-          _this26.logger.warn("Error caching session backup key:", e);
+        _this25.cryptoBackend.storeSessionBackupPrivateKey(privKey, backupVersion).catch(e => {
+          _this25.logger.warn("Error caching session backup key:", e);
         }).then(cacheCompleteCallback);
         if (progressCallback) {
           progressCallback({
             stage: "fetch"
           });
         }
-        var res = yield _this26.http.authedRequest(Method.Get, path.path, path.queryData, undefined, {
+        var res = yield _this25.http.authedRequest(Method.Get, path.path, path.queryData, undefined, {
           prefix: ClientPrefix.V3
         });
 
@@ -2710,14 +2600,14 @@ export class MatrixClient extends TypedEventEmitter {
           // We have a full backup here, it can get quite big, so we need to decrypt and import it in chunks.
 
           // Get the total count as a first pass
-          totalKeyCount = _this26.getTotalKeyCount(res);
+          totalKeyCount = _this25.getTotalKeyCount(res);
           // Now decrypt and import the keys in chunks
-          yield _this26.handleDecryptionOfAFullBackup(res, backupDecryptor, 200, /*#__PURE__*/function () {
+          yield _this25.handleDecryptionOfAFullBackup(res, backupDecryptor, 200, /*#__PURE__*/function () {
             var _ref3 = _asyncToGenerator(function* (chunk) {
               // We have a chunk of decrypted keys: import them
               try {
                 var _backupVersion = backupInfo.version;
-                yield _this26.cryptoBackend.importBackedUpRoomKeys(chunk, _backupVersion, {
+                yield _this25.cryptoBackend.importBackedUpRoomKeys(chunk, _backupVersion, {
                   untrusted
                 });
                 totalImported += chunk.length;
@@ -2749,7 +2639,7 @@ export class MatrixClient extends TypedEventEmitter {
           for (var _k of keys) {
             _k.room_id = targetRoomId;
           }
-          yield _this26.cryptoBackend.importBackedUpRoomKeys(keys, backupVersion, {
+          yield _this25.cryptoBackend.importBackedUpRoomKeys(keys, backupVersion, {
             progressCallback,
             untrusted
           });
@@ -2762,13 +2652,13 @@ export class MatrixClient extends TypedEventEmitter {
             });
             _key2.room_id = targetRoomId;
             _key2.session_id = targetSessionId;
-            yield _this26.cryptoBackend.importBackedUpRoomKeys([_key2], backupVersion, {
+            yield _this25.cryptoBackend.importBackedUpRoomKeys([_key2], backupVersion, {
               progressCallback,
               untrusted
             });
             totalImported = 1;
           } catch (e) {
-            _this26.logger.debug("Failed to decrypt megolm session from backup", e);
+            _this25.logger.debug("Failed to decrypt megolm session from backup", e);
           }
         }
       } finally {
@@ -2776,7 +2666,7 @@ export class MatrixClient extends TypedEventEmitter {
       }
 
       /// in case entering the passphrase would add a new signature?
-      yield _this26.cryptoBackend.checkKeyBackupAndEnable();
+      yield _this25.cryptoBackend.checkKeyBackupAndEnable();
       return {
         total: totalKeyCount,
         imported: totalImported
@@ -2859,10 +2749,10 @@ export class MatrixClient extends TypedEventEmitter {
     })();
   }
   deleteKeysFromBackup(roomId, sessionId, version) {
-    var _this27 = this;
+    var _this26 = this;
     return _asyncToGenerator(function* () {
-      var path = _this27.makeKeyBackupPath(roomId, sessionId, version);
-      yield _this27.http.authedRequest(Method.Delete, path.path, path.queryData, undefined, {
+      var path = _this26.makeKeyBackupPath(roomId, sessionId, version);
+      yield _this26.http.authedRequest(Method.Delete, path.path, path.queryData, undefined, {
         prefix: ClientPrefix.V3
       });
     })();
@@ -2986,10 +2876,10 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   getAccountDataFromServer(eventType) {
-    var _this28 = this;
+    var _this27 = this;
     return _asyncToGenerator(function* () {
-      if (_this28.isInitialSyncComplete()) {
-        var _event = _this28.store.getAccountData(eventType);
+      if (_this27.isInitialSyncComplete()) {
+        var _event = _this27.store.getAccountData(eventType);
         if (!_event) {
           return null;
         }
@@ -2998,11 +2888,11 @@ export class MatrixClient extends TypedEventEmitter {
         return _event.getContent();
       }
       var path = utils.encodeUri("/user/$userId/account_data/$type", {
-        $userId: _this28.credentials.userId,
+        $userId: _this27.credentials.userId,
         $type: eventType
       });
       try {
-        return yield _this28.http.authedRequest(Method.Get, path);
+        return yield _this27.http.authedRequest(Method.Get, path);
       } catch (e) {
         var _data;
         if (((_data = e.data) === null || _data === void 0 ? void 0 : _data.errcode) === "M_NOT_FOUND") {
@@ -3013,22 +2903,22 @@ export class MatrixClient extends TypedEventEmitter {
     })();
   }
   deleteAccountData(eventType) {
-    var _this29 = this;
+    var _this28 = this;
     return _asyncToGenerator(function* () {
-      var msc3391DeleteAccountDataServerSupport = _this29.canSupport.get(Feature.AccountDataDeletion);
+      var msc3391DeleteAccountDataServerSupport = _this28.canSupport.get(Feature.AccountDataDeletion);
       // if deletion is not supported overwrite with empty content
       if (msc3391DeleteAccountDataServerSupport === ServerSupport.Unsupported) {
-        yield _this29.setAccountData(eventType, {});
+        yield _this28.setAccountData(eventType, {});
         return;
       }
       var path = utils.encodeUri("/user/$userId/account_data/$type", {
-        $userId: _this29.getSafeUserId(),
+        $userId: _this28.getSafeUserId(),
         $type: eventType
       });
       var options = msc3391DeleteAccountDataServerSupport === ServerSupport.Unstable ? {
         prefix: "/_matrix/client/unstable/org.matrix.msc3391"
       } : undefined;
-      return yield _this29.http.authedRequest(Method.Delete, path, undefined, undefined, options);
+      return yield _this28.http.authedRequest(Method.Delete, path, undefined, undefined, options);
     })();
   }
 
@@ -3076,19 +2966,19 @@ export class MatrixClient extends TypedEventEmitter {
    */
   joinRoom(roomIdOrAlias) {
     var _arguments3 = arguments,
-      _this30 = this;
+      _this29 = this;
     return _asyncToGenerator(function* () {
       var opts = _arguments3.length > 1 && _arguments3[1] !== undefined ? _arguments3[1] : {};
       if (opts.syncRoom === undefined) {
         opts.syncRoom = true;
       }
-      var room = _this30.getRoom(roomIdOrAlias);
-      if (room !== null && room !== void 0 && room.hasMembershipState(_this30.credentials.userId, KnownMembership.Join)) return room;
+      var room = _this29.getRoom(roomIdOrAlias);
+      if (room !== null && room !== void 0 && room.hasMembershipState(_this29.credentials.userId, KnownMembership.Join)) return room;
       var signPromise = Promise.resolve();
       if (opts.inviteSignUrl) {
         var _url = new URL(opts.inviteSignUrl);
-        _url.searchParams.set("mxid", _this30.credentials.userId);
-        signPromise = _this30.http.requestOtherUrl(Method.Post, _url);
+        _url.searchParams.set("mxid", _this29.credentials.userId);
+        signPromise = _this29.http.requestOtherUrl(Method.Post, _url);
       }
       var queryParams = {};
       if (opts.viaServers) {
@@ -3104,14 +2994,14 @@ export class MatrixClient extends TypedEventEmitter {
       var path = utils.encodeUri("/join/$roomid", {
         $roomid: roomIdOrAlias
       });
-      var res = yield _this30.http.authedRequest(Method.Post, path, queryParams, data);
+      var res = yield _this29.http.authedRequest(Method.Post, path, queryParams, data);
       var roomId = res.room_id;
       // In case we were originally given an alias, check the room cache again
       // with the resolved ID - this method is supposed to no-op if we already
       // were in the room, after all.
-      var resolvedRoom = _this30.getRoom(roomId);
-      if (resolvedRoom !== null && resolvedRoom !== void 0 && resolvedRoom.hasMembershipState(_this30.credentials.userId, KnownMembership.Join)) return resolvedRoom;
-      var syncApi = new SyncApi(_this30, _this30.clientOpts, _this30.buildSyncApiOptions());
+      var resolvedRoom = _this29.getRoom(roomId);
+      if (resolvedRoom !== null && resolvedRoom !== void 0 && resolvedRoom.hasMembershipState(_this29.credentials.userId, KnownMembership.Join)) return resolvedRoom;
+      var syncApi = new SyncApi(_this29, _this29.clientOpts, _this29.buildSyncApiOptions());
       var syncRoom = syncApi.createRoom(roomId);
       if (opts.syncRoom) {
         // v2 will do this for us
@@ -3281,17 +3171,17 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   setPowerLevel(roomId, userId, powerLevel) {
-    var _this31 = this;
+    var _this30 = this;
     return _asyncToGenerator(function* () {
       var _content;
       var content;
-      if (_this31.clientRunning && _this31.isInitialSyncComplete()) {
-        var _this31$getRoom;
-        content = (_this31$getRoom = _this31.getRoom(roomId)) === null || _this31$getRoom === void 0 || (_this31$getRoom = _this31$getRoom.currentState) === null || _this31$getRoom === void 0 || (_this31$getRoom = _this31$getRoom.getStateEvents(EventType.RoomPowerLevels, "")) === null || _this31$getRoom === void 0 ? void 0 : _this31$getRoom.getContent();
+      if (_this30.clientRunning && _this30.isInitialSyncComplete()) {
+        var _this30$getRoom;
+        content = (_this30$getRoom = _this30.getRoom(roomId)) === null || _this30$getRoom === void 0 || (_this30$getRoom = _this30$getRoom.currentState) === null || _this30$getRoom === void 0 || (_this30$getRoom = _this30$getRoom.getStateEvents(EventType.RoomPowerLevels, "")) === null || _this30$getRoom === void 0 ? void 0 : _this30$getRoom.getContent();
       }
       if (!content) {
         try {
-          content = yield _this31.getStateEvent(roomId, EventType.RoomPowerLevels, "");
+          content = yield _this30.getStateEvent(roomId, EventType.RoomPowerLevels, "");
         } catch (e) {
           // It is possible for a Matrix room to not have a power levels event
           if (e instanceof MatrixError && e.errcode === "M_NOT_FOUND") {
@@ -3316,7 +3206,7 @@ export class MatrixClient extends TypedEventEmitter {
           content.users[user] = powerLevel;
         }
       }
-      return _this31.sendStateEvent(roomId, EventType.RoomPowerLevels, content, "");
+      return _this30.sendStateEvent(roomId, EventType.RoomPowerLevels, content, "");
     })();
   }
 
@@ -3326,9 +3216,9 @@ export class MatrixClient extends TypedEventEmitter {
    */
   // eslint-disable-next-line @typescript-eslint/naming-convention
   unstable_createLiveBeacon(roomId, beaconInfoContent) {
-    var _this32 = this;
+    var _this31 = this;
     return _asyncToGenerator(function* () {
-      return _this32.unstable_setLiveBeacon(roomId, beaconInfoContent);
+      return _this31.unstable_setLiveBeacon(roomId, beaconInfoContent);
     })();
   }
 
@@ -3340,9 +3230,9 @@ export class MatrixClient extends TypedEventEmitter {
    */
   // eslint-disable-next-line @typescript-eslint/naming-convention
   unstable_setLiveBeacon(roomId, beaconInfoContent) {
-    var _this33 = this;
+    var _this32 = this;
     return _asyncToGenerator(function* () {
-      return _this33.sendStateEvent(roomId, M_BEACON_INFO.name, beaconInfoContent, _this33.getUserId());
+      return _this32.sendStateEvent(roomId, M_BEACON_INFO.name, beaconInfoContent, _this32.getUserId());
     })();
   }
   sendEvent(roomId, threadIdOrEventType, eventTypeOrContent, contentOrTxnId, txnIdOrVoid) {
@@ -3490,18 +3380,18 @@ export class MatrixClient extends TypedEventEmitter {
    */
 
   encryptAndSendEvent(room, event, delayOpts) {
-    var _this34 = this;
+    var _this33 = this;
     return _asyncToGenerator(function* () {
       if (delayOpts) {
-        return _this34.sendEventHttpRequest(event, delayOpts);
+        return _this33.sendEventHttpRequest(event, delayOpts);
       }
       try {
         var cancelled;
-        _this34.eventsBeingEncrypted.add(event.getId());
+        _this33.eventsBeingEncrypted.add(event.getId());
         try {
-          yield _this34.encryptEventIfNeeded(event, room !== null && room !== void 0 ? room : undefined);
+          yield _this33.encryptEventIfNeeded(event, room !== null && room !== void 0 ? room : undefined);
         } finally {
-          cancelled = !_this34.eventsBeingEncrypted.delete(event.getId());
+          cancelled = !_this33.eventsBeingEncrypted.delete(event.getId());
         }
         if (cancelled) {
           // cancelled via MatrixClient::cancelPendingEvent
@@ -3511,23 +3401,23 @@ export class MatrixClient extends TypedEventEmitter {
         // encryptEventIfNeeded may have updated the status from SENDING to ENCRYPTING. If so, we need
         // to put it back.
         if (event.status === EventStatus.ENCRYPTING) {
-          _this34.updatePendingEventStatus(room, event, EventStatus.SENDING);
+          _this33.updatePendingEventStatus(room, event, EventStatus.SENDING);
         }
         var promise = null;
-        if (_this34.scheduler) {
+        if (_this33.scheduler) {
           // if this returns a promise then the scheduler has control now and will
           // resolve/reject when it is done. Internally, the scheduler will invoke
           // processFn which is set to this._sendEventHttpRequest so the same code
           // path is executed regardless.
-          promise = _this34.scheduler.queueEvent(event);
-          if (promise && _this34.scheduler.getQueueForEvent(event).length > 1) {
+          promise = _this33.scheduler.queueEvent(event);
+          if (promise && _this33.scheduler.getQueueForEvent(event).length > 1) {
             // event is processed FIFO so if the length is 2 or more we know
             // this event is stuck behind an earlier event.
-            _this34.updatePendingEventStatus(room, event, EventStatus.QUEUED);
+            _this33.updatePendingEventStatus(room, event, EventStatus.QUEUED);
           }
         }
         if (!promise) {
-          promise = _this34.sendEventHttpRequest(event);
+          promise = _this33.sendEventHttpRequest(event);
           if (room) {
             promise = promise.then(res => {
               room.updatePendingEvent(event, EventStatus.SENT, res["event_id"]);
@@ -3537,15 +3427,15 @@ export class MatrixClient extends TypedEventEmitter {
         }
         return yield promise;
       } catch (err) {
-        _this34.logger.error("Error sending event", err);
+        _this33.logger.error("Error sending event", err);
         try {
           // set the error on the event before we update the status:
           // updating the status emits the event, so the state should be
           // consistent at that point.
           event.error = err;
-          _this34.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);
+          _this33.updatePendingEventStatus(room, event, EventStatus.NOT_SENT);
         } catch (e) {
-          _this34.logger.error("Exception in error handler!", e);
+          _this33.logger.error("Exception in error handler!", e);
         }
         if (err instanceof MatrixError) {
           err.event = event;
@@ -3555,22 +3445,22 @@ export class MatrixClient extends TypedEventEmitter {
     })();
   }
   encryptEventIfNeeded(event, room) {
-    var _this35 = this;
+    var _this34 = this;
     return _asyncToGenerator(function* () {
       // If the room is unknown, we cannot encrypt for it
       if (!room) return;
-      if (!(yield _this35.shouldEncryptEventForRoom(event, room))) return;
-      if (!_this35.cryptoBackend && _this35.usingExternalCrypto) {
+      if (!(yield _this34.shouldEncryptEventForRoom(event, room))) return;
+      if (!_this34.cryptoBackend && _this34.usingExternalCrypto) {
         // The client has opted to allow sending messages to encrypted
         // rooms even if the room is encrypted, and we haven't set up
         // crypto. This is useful for users of matrix-org/pantalaimon
         return;
       }
-      if (!_this35.cryptoBackend) {
+      if (!_this34.cryptoBackend) {
         throw new Error("This room is configured to use encryption, but your client does not support encryption.");
       }
-      _this35.updatePendingEventStatus(room, event, EventStatus.ENCRYPTING);
-      yield _this35.cryptoBackend.encryptEvent(event, room);
+      _this34.updatePendingEventStatus(room, event, EventStatus.ENCRYPTING);
+      yield _this34.cryptoBackend.encryptEvent(event, room);
     })();
   }
 
@@ -3580,9 +3470,9 @@ export class MatrixClient extends TypedEventEmitter {
    * This takes into account event type and room configuration.
    */
   shouldEncryptEventForRoom(event, room) {
-    var _this36 = this;
+    var _this35 = this;
     return _asyncToGenerator(function* () {
-      var _this36$cryptoBackend;
+      var _this35$cryptoBackend;
       if (event.isEncrypted()) {
         // this event has already been encrypted; this happens if the
         // encryption step succeeded, but the send step failed on the first
@@ -3612,7 +3502,7 @@ export class MatrixClient extends TypedEventEmitter {
       if (room.hasEncryptionStateEvent()) return true;
 
       // If we have a crypto impl, and *it* thinks we should encrypt, then we should.
-      if (yield (_this36$cryptoBackend = _this36.cryptoBackend) === null || _this36$cryptoBackend === void 0 ? void 0 : _this36$cryptoBackend.isEncryptionEnabledInRoom(room.roomId)) return true;
+      if (yield (_this35$cryptoBackend = _this35.cryptoBackend) === null || _this35$cryptoBackend === void 0 ? void 0 : _this35$cryptoBackend.isEncryptionEnabledInRoom(room.roomId)) return true;
 
       // Otherwise, no need to encrypt.
       return false;
@@ -3880,13 +3770,13 @@ export class MatrixClient extends TypedEventEmitter {
    */
   // eslint-disable-next-line
   _unstable_sendDelayedEvent(roomId, delayOpts, threadId, eventType, content, txnId) {
-    var _this37 = this;
+    var _this36 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this37.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      if (!(yield _this36.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
         throw Error("Server does not support the delayed events API");
       }
-      _this37.addThreadRelationIfNeeded(content, threadId, roomId);
-      return _this37.sendCompleteEvent(roomId, threadId, {
+      _this36.addThreadRelationIfNeeded(content, threadId, roomId);
+      return _this36.sendCompleteEvent(roomId, threadId, {
         type: eventType,
         content
       }, delayOpts, txnId);
@@ -3902,11 +3792,11 @@ export class MatrixClient extends TypedEventEmitter {
   // eslint-disable-next-line
   _unstable_sendDelayedStateEvent(roomId, delayOpts, eventType, content) {
     var _arguments4 = arguments,
-      _this38 = this;
+      _this37 = this;
     return _asyncToGenerator(function* () {
       var stateKey = _arguments4.length > 4 && _arguments4[4] !== undefined ? _arguments4[4] : "";
       var opts = _arguments4.length > 5 && _arguments4[5] !== undefined ? _arguments4[5] : {};
-      if (!(yield _this38.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      if (!(yield _this37.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
         throw Error("Server does not support the delayed events API");
       }
       var pathParams = {
@@ -3918,7 +3808,7 @@ export class MatrixClient extends TypedEventEmitter {
       if (stateKey !== undefined) {
         path = utils.encodeUri(path + "/$stateKey", pathParams);
       }
-      return _this38.http.authedRequest(Method.Put, path, getUnstableDelayQueryOpts(delayOpts), content, opts);
+      return _this37.http.authedRequest(Method.Put, path, getUnstableDelayQueryOpts(delayOpts), content, opts);
     })();
   }
 
@@ -3930,15 +3820,15 @@ export class MatrixClient extends TypedEventEmitter {
    */
   // eslint-disable-next-line
   _unstable_getDelayedEvents(fromToken) {
-    var _this39 = this;
+    var _this38 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this39.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      if (!(yield _this38.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
         throw Error("Server does not support the delayed events API");
       }
       var queryDict = fromToken ? {
         from: fromToken
       } : undefined;
-      return yield _this39.http.authedRequest(Method.Get, "/delayed_events", queryDict, undefined, {
+      return yield _this38.http.authedRequest(Method.Get, "/delayed_events", queryDict, undefined, {
         prefix: "".concat(ClientPrefix.Unstable, "/").concat(UNSTABLE_MSC4140_DELAYED_EVENTS)
       });
     })();
@@ -3952,9 +3842,9 @@ export class MatrixClient extends TypedEventEmitter {
    */
   // eslint-disable-next-line
   _unstable_updateDelayedEvent(delayId, action) {
-    var _this40 = this;
+    var _this39 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this40.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
+      if (!(yield _this39.doesServerSupportUnstableFeature(UNSTABLE_MSC4140_DELAYED_EVENTS))) {
         throw Error("Server does not support the delayed events API");
       }
       var path = utils.encodeUri("/delayed_events/$delayId", {
@@ -3963,7 +3853,7 @@ export class MatrixClient extends TypedEventEmitter {
       var data = {
         action
       };
-      return yield _this40.http.authedRequest(Method.Post, path, undefined, data, {
+      return yield _this39.http.authedRequest(Method.Post, path, undefined, data, {
         prefix: "".concat(ClientPrefix.Unstable, "/").concat(UNSTABLE_MSC4140_DELAYED_EVENTS)
       });
     })();
@@ -3981,10 +3871,10 @@ export class MatrixClient extends TypedEventEmitter {
    */
   sendReceipt(event, receiptType, body) {
     var _arguments5 = arguments,
-      _this41 = this;
+      _this40 = this;
     return _asyncToGenerator(function* () {
       var unthreaded = _arguments5.length > 3 && _arguments5[3] !== undefined ? _arguments5[3] : false;
-      if (_this41.isGuest()) {
+      if (_this40.isGuest()) {
         return Promise.resolve({}); // guests cannot send receipts so don't bother.
       }
       var path = utils.encodeUri("/rooms/$roomId/receipt/$receiptType/$eventId", {
@@ -3995,14 +3885,14 @@ export class MatrixClient extends TypedEventEmitter {
 
       // Unless we're explicitly making an unthreaded receipt or we don't
       // support threads, include the `thread_id` property in the body.
-      var shouldAddThreadId = !unthreaded && _this41.supportsThreads();
+      var shouldAddThreadId = !unthreaded && _this40.supportsThreads();
       var fullBody = shouldAddThreadId ? _objectSpread(_objectSpread({}, body), {}, {
         thread_id: threadIdForReceipt(event)
       }) : body;
-      var promise = _this41.http.authedRequest(Method.Post, path, undefined, fullBody || {});
-      var room = _this41.getRoom(event.getRoomId());
-      if (room && _this41.credentials.userId) {
-        room.addLocalEchoReceipt(_this41.credentials.userId, event, receiptType, unthreaded);
+      var promise = _this40.http.authedRequest(Method.Post, path, undefined, fullBody || {});
+      var room = _this40.getRoom(event.getRoomId());
+      if (room && _this40.credentials.userId) {
+        room.addLocalEchoReceipt(_this40.credentials.userId, event, receiptType, unthreaded);
       }
       return promise;
     })();
@@ -4017,17 +3907,17 @@ export class MatrixClient extends TypedEventEmitter {
    */
   sendReadReceipt(event) {
     var _arguments6 = arguments,
-      _this42 = this;
+      _this41 = this;
     return _asyncToGenerator(function* () {
       var receiptType = _arguments6.length > 1 && _arguments6[1] !== undefined ? _arguments6[1] : ReceiptType.Read;
       var unthreaded = _arguments6.length > 2 && _arguments6[2] !== undefined ? _arguments6[2] : false;
       if (!event) return;
       var eventId = event.getId();
-      var room = _this42.getRoom(event.getRoomId());
+      var room = _this41.getRoom(event.getRoomId());
       if (room !== null && room !== void 0 && room.hasPendingEvent(eventId)) {
         throw new Error("Cannot set read receipt to a pending event (".concat(eventId, ")"));
       }
-      return _this42.sendReceipt(event, receiptType, {}, unthreaded);
+      return _this41.sendReceipt(event, receiptType, {}, unthreaded);
     })();
   }
 
@@ -4046,9 +3936,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Promise which resolves: the empty object, `{}`.
    */
   setRoomReadMarkers(roomId, rmEventId, rrEvent, rpEvent) {
-    var _this43 = this;
+    var _this42 = this;
     return _asyncToGenerator(function* () {
-      var room = _this43.getRoom(roomId);
+      var room = _this42.getRoom(roomId);
       if (room !== null && room !== void 0 && room.hasPendingEvent(rmEventId)) {
         throw new Error("Cannot set read marker to a pending event (".concat(rmEventId, ")"));
       }
@@ -4060,7 +3950,7 @@ export class MatrixClient extends TypedEventEmitter {
         if (room !== null && room !== void 0 && room.hasPendingEvent(rrEventId)) {
           throw new Error("Cannot set read receipt to a pending event (".concat(rrEventId, ")"));
         }
-        room === null || room === void 0 || room.addLocalEchoReceipt(_this43.credentials.userId, rrEvent, ReceiptType.Read);
+        room === null || room === void 0 || room.addLocalEchoReceipt(_this42.credentials.userId, rrEvent, ReceiptType.Read);
       }
 
       // Add the optional private RR update, do local echo like `sendReceipt`
@@ -4070,9 +3960,9 @@ export class MatrixClient extends TypedEventEmitter {
         if (room !== null && room !== void 0 && room.hasPendingEvent(rpEventId)) {
           throw new Error("Cannot set read receipt to a pending event (".concat(rpEventId, ")"));
         }
-        room === null || room === void 0 || room.addLocalEchoReceipt(_this43.credentials.userId, rpEvent, ReceiptType.ReadPrivate);
+        room === null || room === void 0 || room.addLocalEchoReceipt(_this42.credentials.userId, rpEvent, ReceiptType.ReadPrivate);
       }
-      return yield _this43.setRoomReadMarkersHttpRequest(roomId, rmEventId, rrEventId, rpEventId);
+      return yield _this42.setRoomReadMarkersHttpRequest(roomId, rmEventId, rrEventId, rpEventId);
     })();
   }
 
@@ -4256,13 +4146,13 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   inviteByThreePid(roomId, medium, address) {
-    var _this44 = this;
+    var _this43 = this;
     return _asyncToGenerator(function* () {
-      var _this44$identityServe;
+      var _this43$identityServe;
       var path = utils.encodeUri("/rooms/$roomId/invite", {
         $roomId: roomId
       });
-      var identityServerUrl = _this44.getIdentityServerUrl(true);
+      var identityServerUrl = _this43.getIdentityServerUrl(true);
       if (!identityServerUrl) {
         return Promise.reject(new MatrixError({
           error: "No supplied identity server URL",
@@ -4274,13 +4164,13 @@ export class MatrixClient extends TypedEventEmitter {
         medium: medium,
         address: address
       };
-      if ((_this44$identityServe = _this44.identityServer) !== null && _this44$identityServe !== void 0 && _this44$identityServe.getAccessToken) {
-        var identityAccessToken = yield _this44.identityServer.getAccessToken();
+      if ((_this43$identityServe = _this43.identityServer) !== null && _this43$identityServe !== void 0 && _this43$identityServe.getAccessToken) {
+        var identityAccessToken = yield _this43.identityServer.getAccessToken();
         if (identityAccessToken) {
           params["id_access_token"] = identityAccessToken;
         }
       }
-      return _this44.http.authedRequest(Method.Post, path, undefined, params);
+      return _this43.http.authedRequest(Method.Post, path, undefined, params);
     })();
   }
 
@@ -4349,17 +4239,17 @@ export class MatrixClient extends TypedEventEmitter {
    */
   forget(roomId) {
     var _arguments7 = arguments,
-      _this45 = this;
+      _this44 = this;
     return _asyncToGenerator(function* () {
       var deleteRoom = _arguments7.length > 1 && _arguments7[1] !== undefined ? _arguments7[1] : true;
       // API returns an empty object
       var path = utils.encodeUri("/rooms/$room_id/forget", {
         $room_id: roomId
       });
-      var response = yield _this45.http.authedRequest(Method.Post, path);
+      var response = yield _this44.http.authedRequest(Method.Post, path);
       if (deleteRoom) {
-        _this45.store.removeRoom(roomId);
-        _this45.emit(ClientEvent.DeleteRoom, roomId);
+        _this44.store.removeRoom(roomId);
+        _this44.emit(ClientEvent.DeleteRoom, roomId);
       }
       return response;
     })();
@@ -4473,13 +4363,13 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   setDisplayName(name) {
-    var _this46 = this;
+    var _this45 = this;
     return _asyncToGenerator(function* () {
-      var prom = yield _this46.setProfileInfo("displayname", {
+      var prom = yield _this45.setProfileInfo("displayname", {
         displayname: name
       });
       // XXX: synthesise a profile update for ourselves because Synapse is broken and won't
-      var user = _this46.getUser(_this46.getUserId());
+      var user = _this45.getUser(_this45.getUserId());
       if (user) {
         user.displayName = name;
         user.emit(UserEvent.DisplayName, user.events.presence, user);
@@ -4493,13 +4383,13 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   setAvatarUrl(url) {
-    var _this47 = this;
+    var _this46 = this;
     return _asyncToGenerator(function* () {
-      var prom = yield _this47.setProfileInfo("avatar_url", {
+      var prom = yield _this46.setProfileInfo("avatar_url", {
         avatar_url: url
       });
       // XXX: synthesise a profile update for ourselves because Synapse is broken and won't
-      var user = _this47.getUser(_this47.getUserId());
+      var user = _this46.getUser(_this46.getUserId());
       if (user) {
         user.avatarUrl = url;
         user.emit(UserEvent.AvatarUrl, user.events.presence, user);
@@ -4540,10 +4430,10 @@ export class MatrixClient extends TypedEventEmitter {
    * @param presence - the presence to specify to set_presence of sync calls
    */
   setSyncPresence(presence) {
-    var _this48 = this;
+    var _this47 = this;
     return _asyncToGenerator(function* () {
-      var _this48$syncApi;
-      (_this48$syncApi = _this48.syncApi) === null || _this48$syncApi === void 0 || _this48$syncApi.setPresence(presence);
+      var _this47$syncApi;
+      (_this47$syncApi = _this47.syncApi) === null || _this47$syncApi === void 0 || _this47$syncApi.setPresence(presence);
     })();
   }
 
@@ -4554,16 +4444,16 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws If 'presence' isn't a valid presence enum value.
    */
   setPresence(opts) {
-    var _this49 = this;
+    var _this48 = this;
     return _asyncToGenerator(function* () {
       var path = utils.encodeUri("/presence/$userId/status", {
-        $userId: _this49.credentials.userId
+        $userId: _this48.credentials.userId
       });
       var validStates = ["offline", "online", "unavailable"];
       if (validStates.indexOf(opts.presence) === -1) {
         throw new Error("Bad presence value: " + opts.presence);
       }
-      yield _this49.http.authedRequest(Method.Put, path, undefined, opts);
+      yield _this48.http.authedRequest(Method.Put, path, undefined, opts);
     })();
   }
 
@@ -4672,11 +4562,11 @@ export class MatrixClient extends TypedEventEmitter {
    *    {@link EventTimeline} including the given event
    */
   getEventTimeline(timelineSet, eventId) {
-    var _this50 = this;
+    var _this49 = this;
     return _asyncToGenerator(function* () {
-      var _this50$clientOpts, _ref5, _timelineSet$getTimel, _timelineSet$room$fin;
+      var _this49$clientOpts, _ref5, _timelineSet$getTimel, _timelineSet$room$fin;
       // don't allow any timeline support unless it's been enabled.
-      if (!_this50.timelineSupport) {
+      if (!_this49.timelineSupport) {
         throw new Error("timeline support is disabled. Set the 'timelineSupport'" + " parameter to true when creating MatrixClient to enable it.");
       }
       if (!(timelineSet !== null && timelineSet !== void 0 && timelineSet.room)) {
@@ -4685,22 +4575,22 @@ export class MatrixClient extends TypedEventEmitter {
       if (timelineSet.getTimelineForEvent(eventId)) {
         return timelineSet.getTimelineForEvent(eventId);
       }
-      if (timelineSet.thread && _this50.supportsThreads()) {
-        return _this50.getThreadTimeline(timelineSet, eventId);
+      if (timelineSet.thread && _this49.supportsThreads()) {
+        return _this49.getThreadTimeline(timelineSet, eventId);
       }
       var path = utils.encodeUri("/rooms/$roomId/context/$eventId", {
         $roomId: timelineSet.room.roomId,
         $eventId: eventId
       });
       var params = undefined;
-      if ((_this50$clientOpts = _this50.clientOpts) !== null && _this50$clientOpts !== void 0 && _this50$clientOpts.lazyLoadMembers) {
+      if ((_this49$clientOpts = _this49.clientOpts) !== null && _this49$clientOpts !== void 0 && _this49$clientOpts.lazyLoadMembers) {
         params = {
           filter: JSON.stringify(Filter.LAZY_LOADING_MESSAGES_FILTER)
         };
       }
 
       // TODO: we should implement a backoff (as per scrollback()) to deal more nicely with HTTP errors.
-      var res = yield _this50.http.authedRequest(Method.Get, path, params);
+      var res = yield _this49.http.authedRequest(Method.Get, path, params);
       if (!res.event) {
         throw new Error("'event' not in '/context' result - homeserver too old?");
       }
@@ -4709,10 +4599,10 @@ export class MatrixClient extends TypedEventEmitter {
       if (timelineSet.getTimelineForEvent(eventId)) {
         return timelineSet.getTimelineForEvent(eventId);
       }
-      var mapper = _this50.getEventMapper();
+      var mapper = _this49.getEventMapper();
       var event = mapper(res.event);
       if (event.isRelation(THREAD_RELATION_TYPE.name)) {
-        _this50.logger.warn("Tried loading a regular timeline at the position of a thread event");
+        _this49.logger.warn("Tried loading a regular timeline at the position of a thread event");
         return undefined;
       }
       var events = [
@@ -4733,8 +4623,8 @@ export class MatrixClient extends TypedEventEmitter {
       var [timelineEvents, threadedEvents, unknownRelations] = timelineSet.room.partitionThreadedEvents(events);
       timelineSet.addEventsToTimeline(timelineEvents, true, timeline, res.start);
       // The target event is not in a thread but process the contextual events, so we can show any threads around it.
-      _this50.processThreadEvents(timelineSet.room, threadedEvents, true);
-      _this50.processAggregatedTimelineEvents(timelineSet.room, timelineEvents);
+      _this49.processThreadEvents(timelineSet.room, threadedEvents, true);
+      _this49.processAggregatedTimelineEvents(timelineSet.room, timelineEvents);
       unknownRelations.forEach(event => timelineSet.relations.aggregateChildEvent(event));
 
       // There is no guarantee that the event ended up in "timeline" (we might have switched to a neighbouring
@@ -4746,10 +4636,10 @@ export class MatrixClient extends TypedEventEmitter {
     })();
   }
   getThreadTimeline(timelineSet, eventId) {
-    var _this51 = this;
+    var _this50 = this;
     return _asyncToGenerator(function* () {
-      var _this51$clientOpts;
-      if (!_this51.supportsThreads()) {
+      var _this50$clientOpts;
+      if (!_this50.supportsThreads()) {
         throw new Error("could not get thread timeline: no client support");
       }
       if (!timelineSet.room) {
@@ -4765,18 +4655,18 @@ export class MatrixClient extends TypedEventEmitter {
       var params = {
         limit: "0"
       };
-      if ((_this51$clientOpts = _this51.clientOpts) !== null && _this51$clientOpts !== void 0 && _this51$clientOpts.lazyLoadMembers) {
+      if ((_this50$clientOpts = _this50.clientOpts) !== null && _this50$clientOpts !== void 0 && _this50$clientOpts.lazyLoadMembers) {
         params.filter = JSON.stringify(Filter.LAZY_LOADING_MESSAGES_FILTER);
       }
 
       // TODO: we should implement a backoff (as per scrollback()) to deal more nicely with HTTP errors.
-      var res = yield _this51.http.authedRequest(Method.Get, path, params);
-      var mapper = _this51.getEventMapper();
+      var res = yield _this50.http.authedRequest(Method.Get, path, params);
+      var mapper = _this50.getEventMapper();
       var event = mapper(res.event);
       if (!timelineSet.canContain(event)) {
         return undefined;
       }
-      var recurse = _this51.canSupport.get(Feature.RelationsRecursion) !== ServerSupport.Unsupported;
+      var recurse = _this50.canSupport.get(Feature.RelationsRecursion) !== ServerSupport.Unsupported;
       if (Thread.hasServerSideSupport) {
         if (Thread.hasServerSideFwdPaginationSupport) {
           var _resOlder$next_batch, _resNewer$next_batch, _timelineSet$getTimel2;
@@ -4784,12 +4674,12 @@ export class MatrixClient extends TypedEventEmitter {
             throw new Error("could not get thread timeline: not a thread timeline");
           }
           var thread = timelineSet.thread;
-          var resOlder = yield _this51.fetchRelations(timelineSet.room.roomId, thread.id, null, null, {
+          var resOlder = yield _this50.fetchRelations(timelineSet.room.roomId, thread.id, null, null, {
             dir: Direction.Backward,
             from: res.start,
             recurse: recurse || undefined
           });
-          var resNewer = yield _this51.fetchRelations(timelineSet.room.roomId, thread.id, null, null, {
+          var resNewer = yield _this50.fetchRelations(timelineSet.room.roomId, thread.id, null, null, {
             dir: Direction.Forward,
             from: res.end,
             recurse: recurse || undefined
@@ -4814,12 +4704,12 @@ export class MatrixClient extends TypedEventEmitter {
           }
           timelineSet.addEventsToTimeline(events, true, timeline, resNewer.next_batch);
           if (!resOlder.next_batch) {
-            var originalEvent = yield _this51.fetchRoomEvent(timelineSet.room.roomId, thread.id);
+            var originalEvent = yield _this50.fetchRoomEvent(timelineSet.room.roomId, thread.id);
             timelineSet.addEventsToTimeline([mapper(originalEvent)], true, timeline, null);
           }
           timeline.setPaginationToken((_resOlder$next_batch = resOlder.next_batch) !== null && _resOlder$next_batch !== void 0 ? _resOlder$next_batch : null, Direction.Backward);
           timeline.setPaginationToken((_resNewer$next_batch = resNewer.next_batch) !== null && _resNewer$next_batch !== void 0 ? _resNewer$next_batch : null, Direction.Forward);
-          _this51.processAggregatedTimelineEvents(timelineSet.room, events);
+          _this50.processAggregatedTimelineEvents(timelineSet.room, events);
 
           // There is no guarantee that the event ended up in "timeline" (we might have switched to a neighbouring
           // timeline) - so check the room's index again. On the other hand, there's no guarantee the event ended up
@@ -4832,7 +4722,7 @@ export class MatrixClient extends TypedEventEmitter {
           // XXX: workaround for https://github.com/vector-im/element-meta/issues/150
 
           var _thread = timelineSet.thread;
-          var _resOlder = yield _this51.fetchRelations(timelineSet.room.roomId, _thread.id, THREAD_RELATION_TYPE.name, null, {
+          var _resOlder = yield _this50.fetchRelations(timelineSet.room.roomId, _thread.id, THREAD_RELATION_TYPE.name, null, {
             dir: Direction.Backward,
             from: res.start,
             recurse: recurse || undefined
@@ -4841,7 +4731,7 @@ export class MatrixClient extends TypedEventEmitter {
           var nextBatch = res.end;
           while (nextBatch) {
             var _resNewer$next_batch2;
-            var _resNewer = yield _this51.fetchRelations(timelineSet.room.roomId, _thread.id, THREAD_RELATION_TYPE.name, null, {
+            var _resNewer = yield _this50.fetchRelations(timelineSet.room.roomId, _thread.id, THREAD_RELATION_TYPE.name, null, {
               dir: Direction.Forward,
               from: nextBatch,
               recurse: recurse || undefined
@@ -4865,12 +4755,12 @@ export class MatrixClient extends TypedEventEmitter {
           _timeline.getState(EventTimeline.BACKWARDS).setUnknownStateEvents(res.state.map(mapper));
           timelineSet.addEventsToTimeline(_events, true, _timeline, null);
           if (!_resOlder.next_batch) {
-            var _originalEvent = yield _this51.fetchRoomEvent(timelineSet.room.roomId, _thread.id);
+            var _originalEvent = yield _this50.fetchRoomEvent(timelineSet.room.roomId, _thread.id);
             timelineSet.addEventsToTimeline([mapper(_originalEvent)], true, _timeline, null);
           }
           _timeline.setPaginationToken((_resOlder$next_batch2 = _resOlder.next_batch) !== null && _resOlder$next_batch2 !== void 0 ? _resOlder$next_batch2 : null, Direction.Backward);
           _timeline.setPaginationToken(null, Direction.Forward);
-          _this51.processAggregatedTimelineEvents(timelineSet.room, _events);
+          _this50.processAggregatedTimelineEvents(timelineSet.room, _events);
           return _timeline;
         }
       }
@@ -4888,10 +4778,10 @@ export class MatrixClient extends TypedEventEmitter {
    *    {@link EventTimeline} timeline with the latest events in the room
    */
   getLatestTimeline(timelineSet) {
-    var _this52 = this;
+    var _this51 = this;
     return _asyncToGenerator(function* () {
       // don't allow any timeline support unless it's been enabled.
-      if (!_this52.timelineSupport) {
+      if (!_this51.timelineSupport) {
         throw new Error("timeline support is disabled. Set the 'timelineSupport'" + " parameter to true when creating MatrixClient to enable it.");
       }
       if (!timelineSet.room) {
@@ -4900,35 +4790,35 @@ export class MatrixClient extends TypedEventEmitter {
       var event;
       if (timelineSet.threadListType !== null) {
         var _res$chunk;
-        var res = yield _this52.createThreadListMessagesRequest(timelineSet.room.roomId, null, 1, Direction.Backward, timelineSet.threadListType, timelineSet.getFilter());
+        var res = yield _this51.createThreadListMessagesRequest(timelineSet.room.roomId, null, 1, Direction.Backward, timelineSet.threadListType, timelineSet.getFilter());
         event = (_res$chunk = res.chunk) === null || _res$chunk === void 0 ? void 0 : _res$chunk[0];
       } else if (timelineSet.thread && Thread.hasServerSideSupport) {
         var _res$chunk2;
-        var recurse = _this52.canSupport.get(Feature.RelationsRecursion) !== ServerSupport.Unsupported;
-        var _res = yield _this52.fetchRelations(timelineSet.room.roomId, timelineSet.thread.id, THREAD_RELATION_TYPE.name, null, {
+        var recurse = _this51.canSupport.get(Feature.RelationsRecursion) !== ServerSupport.Unsupported;
+        var _res = yield _this51.fetchRelations(timelineSet.room.roomId, timelineSet.thread.id, THREAD_RELATION_TYPE.name, null, {
           dir: Direction.Backward,
           limit: 1,
           recurse: recurse || undefined
         });
         event = (_res$chunk2 = _res.chunk) === null || _res$chunk2 === void 0 ? void 0 : _res$chunk2[0];
       } else {
-        var _this52$clientOpts, _res2$chunk;
+        var _this51$clientOpts, _res2$chunk;
         var messagesPath = utils.encodeUri("/rooms/$roomId/messages", {
           $roomId: timelineSet.room.roomId
         });
         var params = {
           dir: "b"
         };
-        if ((_this52$clientOpts = _this52.clientOpts) !== null && _this52$clientOpts !== void 0 && _this52$clientOpts.lazyLoadMembers) {
+        if ((_this51$clientOpts = _this51.clientOpts) !== null && _this51$clientOpts !== void 0 && _this51$clientOpts.lazyLoadMembers) {
           params.filter = JSON.stringify(Filter.LAZY_LOADING_MESSAGES_FILTER);
         }
-        var _res2 = yield _this52.http.authedRequest(Method.Get, messagesPath, params);
+        var _res2 = yield _this51.http.authedRequest(Method.Get, messagesPath, params);
         event = (_res2$chunk = _res2.chunk) === null || _res2$chunk === void 0 ? void 0 : _res2$chunk[0];
       }
       if (!event) {
         throw new Error("No message returned when trying to construct getLatestTimeline");
       }
-      return _this52.getEventTimeline(timelineSet, event.event_id);
+      return _this51.getEventTimeline(timelineSet, event.event_id);
     })();
   }
 
@@ -5040,7 +4930,7 @@ export class MatrixClient extends TypedEventEmitter {
    *    events and we reached either end of the timeline; else true.
    */
   paginateEventTimeline(eventTimeline, opts) {
-    var _this53 = this;
+    var _this52 = this;
     var isNotifTimeline = eventTimeline.getTimelineSet() === this.notifTimelineSet;
     var room = this.getRoom(eventTimeline.getRoomId());
     var threadListType = eventTimeline.getTimelineSet().threadListType;
@@ -5082,11 +4972,11 @@ export class MatrixClient extends TypedEventEmitter {
           res.notifications = res.notifications.filter(noUnsafeEventProps);
           for (var i = 0; i < res.notifications.length; i++) {
             var notification = res.notifications[i];
-            var _event4 = _this53.getEventMapper()(notification.event);
+            var _event4 = _this52.getEventMapper()(notification.event);
 
             // @TODO(kerrya) reprocessing every notification is ugly
             // remove if we get server MSC3994 support
-            _this53.getPushDetailsForEvent(_event4, true);
+            _this52.getPushDetailsForEvent(_event4, true);
             _event4.event.room_id = notification.room_id; // XXX: gutwrenching
             matrixEvents[i] = _event4;
           }
@@ -5095,7 +4985,7 @@ export class MatrixClient extends TypedEventEmitter {
           // in the notification timeline set
           var timelineSet = eventTimeline.getTimelineSet();
           timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, token);
-          _this53.processAggregatedTimelineEvents(timelineSet.room, matrixEvents);
+          _this52.processAggregatedTimelineEvents(timelineSet.room, matrixEvents);
 
           // if we've hit the end of the timeline, we need to stop trying to
           // paginate. We need to keep the 'forwards' token though, to make sure
@@ -5157,7 +5047,7 @@ export class MatrixClient extends TypedEventEmitter {
         recurse: recurse || undefined
       }).then(/*#__PURE__*/function () {
         var _ref7 = _asyncToGenerator(function* (res) {
-          var mapper = _this53.getEventMapper();
+          var mapper = _this52.getEventMapper();
           var matrixEvents = res.chunk.filter(noUnsafeEventProps).filter(getRelationsThreadFilter(thread.id)).map(mapper);
 
           // Process latest events first
@@ -5173,10 +5063,10 @@ export class MatrixClient extends TypedEventEmitter {
           timelineSet.addEventsToTimeline(matrixEvents, backwards, eventTimeline, newToken !== null && newToken !== void 0 ? newToken : null);
           if (!newToken && backwards) {
             var _thread$rootEvent, _eventTimeline$getRoo3;
-            var originalEvent = (_thread$rootEvent = thread.rootEvent) !== null && _thread$rootEvent !== void 0 ? _thread$rootEvent : mapper(yield _this53.fetchRoomEvent((_eventTimeline$getRoo3 = eventTimeline.getRoomId()) !== null && _eventTimeline$getRoo3 !== void 0 ? _eventTimeline$getRoo3 : "", thread.id));
+            var originalEvent = (_thread$rootEvent = thread.rootEvent) !== null && _thread$rootEvent !== void 0 ? _thread$rootEvent : mapper(yield _this52.fetchRoomEvent((_eventTimeline$getRoo3 = eventTimeline.getRoomId()) !== null && _eventTimeline$getRoo3 !== void 0 ? _eventTimeline$getRoo3 : "", thread.id));
             timelineSet.addEventsToTimeline([originalEvent], true, eventTimeline, null);
           }
-          _this53.processAggregatedTimelineEvents(timelineSet.room, matrixEvents);
+          _this52.processAggregatedTimelineEvents(timelineSet.room, matrixEvents);
 
           // if we've hit the end of the timeline, we need to stop trying to
           // paginate. We need to keep the 'forwards' token though, to make sure
@@ -5462,10 +5352,10 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Promise which resolves: As requestEmailToken
    */
   requestTokenFromEndpoint(endpoint, params) {
-    var _this54 = this;
+    var _this53 = this;
     return _asyncToGenerator(function* () {
       var postParams = Object.assign({}, params);
-      return _this54.http.request(Method.Post, endpoint, undefined, postParams);
+      return _this53.http.request(Method.Post, endpoint, undefined, postParams);
     })();
   }
 
@@ -5760,14 +5650,14 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Filter ID
    */
   getOrCreateFilter(filterName, filter) {
-    var _this55 = this;
+    var _this54 = this;
     return _asyncToGenerator(function* () {
-      var filterId = _this55.store.getFilterIdByName(filterName);
+      var filterId = _this54.store.getFilterIdByName(filterName);
       var existingId;
       if (filterId) {
         // check that the existing filter matches our expectations
         try {
-          var existingFilter = yield _this55.getFilter(_this55.credentials.userId, filterId, true);
+          var existingFilter = yield _this54.getFilter(_this54.credentials.userId, filterId, true);
           if (existingFilter) {
             var oldDef = existingFilter.getDefinition();
             var newDef = filter.getDefinition();
@@ -5791,7 +5681,7 @@ export class MatrixClient extends TypedEventEmitter {
         }
         // if the filter doesn't exist anymore on the server, remove from store
         if (!existingId) {
-          _this55.store.setFilterIdByName(filterName, undefined);
+          _this54.store.setFilterIdByName(filterName, undefined);
         }
       }
       if (existingId) {
@@ -5799,8 +5689,8 @@ export class MatrixClient extends TypedEventEmitter {
       }
 
       // create a new filter
-      var createdFilter = yield _this55.createFilter(filter.getDefinition());
-      _this55.store.setFilterIdByName(filterName, createdFilter.filterId);
+      var createdFilter = yield _this54.createFilter(filter.getDefinition());
+      _this54.store.setFilterIdByName(filterName, createdFilter.filterId);
       return createdFilter.filterId;
     })();
   }
@@ -5848,47 +5738,47 @@ export class MatrixClient extends TypedEventEmitter {
 
   // XXX: Intended private, used in code.
   checkTurnServers() {
-    var _this56 = this;
+    var _this55 = this;
     return _asyncToGenerator(function* () {
-      if (!_this56.canSupportVoip) {
+      if (!_this55.canSupportVoip) {
         return;
       }
       var credentialsGood = false;
-      var remainingTime = _this56.turnServersExpiry - Date.now();
+      var remainingTime = _this55.turnServersExpiry - Date.now();
       if (remainingTime > TURN_CHECK_INTERVAL) {
-        _this56.logger.debug("TURN creds are valid for another " + remainingTime + " ms: not fetching new ones.");
+        _this55.logger.debug("TURN creds are valid for another " + remainingTime + " ms: not fetching new ones.");
         credentialsGood = true;
       } else {
-        _this56.logger.debug("Fetching new TURN credentials");
+        _this55.logger.debug("Fetching new TURN credentials");
         try {
-          var res = yield _this56.turnServer();
+          var res = yield _this55.turnServer();
           if (res.uris) {
-            _this56.logger.debug("Got TURN URIs: " + res.uris + " refresh in " + res.ttl + " secs");
+            _this55.logger.debug("Got TURN URIs: " + res.uris + " refresh in " + res.ttl + " secs");
             // map the response to a format that can be fed to RTCPeerConnection
             var servers = {
               urls: res.uris,
               username: res.username,
               credential: res.password
             };
-            _this56.turnServers = [servers];
+            _this55.turnServers = [servers];
             // The TTL is in seconds but we work in ms
-            _this56.turnServersExpiry = Date.now() + res.ttl * 1000;
+            _this55.turnServersExpiry = Date.now() + res.ttl * 1000;
             credentialsGood = true;
-            _this56.emit(ClientEvent.TurnServers, _this56.turnServers);
+            _this55.emit(ClientEvent.TurnServers, _this55.turnServers);
           }
         } catch (err) {
-          _this56.logger.error("Failed to get TURN URIs", err);
+          _this55.logger.error("Failed to get TURN URIs", err);
           if (err.httpStatus === 403) {
             // We got a 403, so there's no point in looping forever.
-            _this56.logger.info("TURN access unavailable for this account: stopping credentials checks");
-            if (_this56.checkTurnServersIntervalID !== null) {
-              globalThis.clearInterval(_this56.checkTurnServersIntervalID);
+            _this55.logger.info("TURN access unavailable for this account: stopping credentials checks");
+            if (_this55.checkTurnServersIntervalID !== null) {
+              globalThis.clearInterval(_this55.checkTurnServersIntervalID);
             }
-            _this56.checkTurnServersIntervalID = undefined;
-            _this56.emit(ClientEvent.TurnServersError, err, true); // fatal
+            _this55.checkTurnServersIntervalID = undefined;
+            _this55.emit(ClientEvent.TurnServersError, err, true); // fatal
           } else {
             // otherwise, if we failed for whatever reason, try again the next time we're called.
-            _this56.emit(ClientEvent.TurnServersError, err, false); // non-fatal
+            _this55.emit(ClientEvent.TurnServersError, err, false); // non-fatal
           }
         }
       }
@@ -5964,14 +5854,14 @@ export class MatrixClient extends TypedEventEmitter {
     });
   }
   fetchClientWellKnown() {
-    var _this57 = this;
+    var _this56 = this;
     return _asyncToGenerator(function* () {
-      var _this57$getDomain;
+      var _this56$getDomain;
       // `getRawClientConfig` does not throw or reject on network errors, instead
       // it absorbs errors and returns `{}`.
-      _this57.clientWellKnownPromise = AutoDiscovery.getRawClientConfig((_this57$getDomain = _this57.getDomain()) !== null && _this57$getDomain !== void 0 ? _this57$getDomain : undefined);
-      _this57.clientWellKnown = yield _this57.clientWellKnownPromise;
-      _this57.emit(ClientEvent.ClientWellKnown, _this57.clientWellKnown);
+      _this56.clientWellKnownPromise = AutoDiscovery.getRawClientConfig((_this56$getDomain = _this56.getDomain()) !== null && _this56$getDomain !== void 0 ? _this56$getDomain : undefined);
+      _this56.clientWellKnown = yield _this56.clientWellKnownPromise;
+      _this56.emit(ClientEvent.ClientWellKnown, _this56.clientWellKnown);
     })();
   }
   getClientWellKnown() {
@@ -6017,16 +5907,16 @@ export class MatrixClient extends TypedEventEmitter {
   // TODO: on spec release, rename this to getMutualRooms
   // eslint-disable-next-line
   _unstable_getSharedRooms(userId) {
-    var _this58 = this;
+    var _this57 = this;
     return _asyncToGenerator(function* () {
       // Initial variant of the MSC
-      var sharedRoomsSupport = yield _this58.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_SHARED_ROOMS);
+      var sharedRoomsSupport = yield _this57.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_SHARED_ROOMS);
 
       // Newer variant that renamed shared rooms to mutual rooms
-      var mutualRoomsSupport = yield _this58.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_MUTUAL_ROOMS);
+      var mutualRoomsSupport = yield _this57.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_MUTUAL_ROOMS);
 
       // Latest variant that changed from path elements to query elements
-      var queryMutualRoomsSupport = yield _this58.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_QUERY_MUTUAL_ROOMS);
+      var queryMutualRoomsSupport = yield _this57.doesServerSupportUnstableFeature(UNSTABLE_MSC2666_QUERY_MUTUAL_ROOMS);
       if (!sharedRoomsSupport && !mutualRoomsSupport && !queryMutualRoomsSupport) {
         throw Error("Server does not support the Mutual Rooms API");
       }
@@ -6054,7 +5944,7 @@ export class MatrixClient extends TypedEventEmitter {
         if (token != null && queryMutualRoomsSupport) {
           tokenQuery["batch_token"] = token;
         }
-        var res = yield _this58.http.authedRequest(Method.Get, path, _objectSpread(_objectSpread({}, query), tokenQuery), undefined, {
+        var res = yield _this57.http.authedRequest(Method.Get, path, _objectSpread(_objectSpread({}, query), tokenQuery), undefined, {
           prefix: ClientPrefix.Unstable
         });
         rooms.push(...res.joined);
@@ -6074,24 +5964,24 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns The server /versions response
    */
   getVersions() {
-    var _this59 = this;
+    var _this58 = this;
     return _asyncToGenerator(function* () {
-      if (_this59.serverVersionsPromise) {
-        return _this59.serverVersionsPromise;
+      if (_this58.serverVersionsPromise) {
+        return _this58.serverVersionsPromise;
       }
 
       // We send an authenticated request as of MSC4026
-      _this59.serverVersionsPromise = _this59.http.authedRequest(Method.Get, "/_matrix/client/versions", undefined, undefined, {
+      _this58.serverVersionsPromise = _this58.http.authedRequest(Method.Get, "/_matrix/client/versions", undefined, undefined, {
         prefix: ""
       }).catch(e => {
         // Need to unset this if it fails, otherwise we'll never retry
-        _this59.serverVersionsPromise = undefined;
+        _this58.serverVersionsPromise = undefined;
         // but rethrow the exception to anything that was waiting
         throw e;
       });
-      var serverVersions = yield _this59.serverVersionsPromise;
-      _this59.canSupport = yield buildFeatureSupportMap(serverVersions);
-      return _this59.serverVersionsPromise;
+      var serverVersions = yield _this58.serverVersionsPromise;
+      _this58.canSupport = yield buildFeatureSupportMap(serverVersions);
+      return _this58.serverVersionsPromise;
     })();
   }
 
@@ -6101,11 +5991,11 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Whether it is supported
    */
   isVersionSupported(version) {
-    var _this60 = this;
+    var _this59 = this;
     return _asyncToGenerator(function* () {
       var {
         versions
-      } = yield _this60.getVersions();
+      } = yield _this59.getVersions();
       return versions && versions.includes(version);
     })();
   }
@@ -6117,9 +6007,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns true if the feature is supported
    */
   doesServerSupportUnstableFeature(feature) {
-    var _this61 = this;
+    var _this60 = this;
     return _asyncToGenerator(function* () {
-      var response = yield _this61.getVersions();
+      var response = yield _this60.getVersions();
       if (!response) return false;
       var unstableFeatures = response["unstable_features"];
       return unstableFeatures && !!unstableFeatures[feature];
@@ -6134,9 +6024,9 @@ export class MatrixClient extends TypedEventEmitter {
    * for the preset.
    */
   doesServerForceEncryptionForPreset(presetName) {
-    var _this62 = this;
+    var _this61 = this;
     return _asyncToGenerator(function* () {
-      var response = yield _this62.getVersions();
+      var response = yield _this61.getVersions();
       if (!response) return false;
       var unstableFeatures = response["unstable_features"];
 
@@ -6146,9 +6036,9 @@ export class MatrixClient extends TypedEventEmitter {
     })();
   }
   doesServerSupportThread() {
-    var _this63 = this;
+    var _this62 = this;
     return _asyncToGenerator(function* () {
-      if (yield _this63.isVersionSupported("v1.4")) {
+      if (yield _this62.isVersionSupported("v1.4")) {
         return {
           threads: FeatureSupport.Stable,
           list: FeatureSupport.Stable,
@@ -6156,7 +6046,7 @@ export class MatrixClient extends TypedEventEmitter {
         };
       }
       try {
-        var [threadUnstable, threadStable, listUnstable, listStable, fwdPaginationUnstable, fwdPaginationStable] = yield Promise.all([_this63.doesServerSupportUnstableFeature("org.matrix.msc3440"), _this63.doesServerSupportUnstableFeature("org.matrix.msc3440.stable"), _this63.doesServerSupportUnstableFeature("org.matrix.msc3856"), _this63.doesServerSupportUnstableFeature("org.matrix.msc3856.stable"), _this63.doesServerSupportUnstableFeature("org.matrix.msc3715"), _this63.doesServerSupportUnstableFeature("org.matrix.msc3715.stable")]);
+        var [threadUnstable, threadStable, listUnstable, listStable, fwdPaginationUnstable, fwdPaginationStable] = yield Promise.all([_this62.doesServerSupportUnstableFeature("org.matrix.msc3440"), _this62.doesServerSupportUnstableFeature("org.matrix.msc3440.stable"), _this62.doesServerSupportUnstableFeature("org.matrix.msc3856"), _this62.doesServerSupportUnstableFeature("org.matrix.msc3856.stable"), _this62.doesServerSupportUnstableFeature("org.matrix.msc3715"), _this62.doesServerSupportUnstableFeature("org.matrix.msc3715.stable")]);
         return {
           threads: determineFeatureSupport(threadStable, threadUnstable),
           list: determineFeatureSupport(listStable, listUnstable),
@@ -6215,20 +6105,20 @@ export class MatrixClient extends TypedEventEmitter {
    */
   relations(roomId, eventId, relationType, eventType) {
     var _arguments8 = arguments,
-      _this64 = this;
+      _this63 = this;
     return _asyncToGenerator(function* () {
       var _result$next_batch, _result$prev_batch;
       var opts = _arguments8.length > 4 && _arguments8[4] !== undefined ? _arguments8[4] : {
         dir: Direction.Backward
       };
-      var fetchedEventType = eventType ? _this64.getEncryptedIfNeededEventType(roomId, eventType) : null;
-      var [eventResult, result] = yield Promise.all([_this64.fetchRoomEvent(roomId, eventId), _this64.fetchRelations(roomId, eventId, relationType, fetchedEventType, opts)]);
-      var mapper = _this64.getEventMapper();
+      var fetchedEventType = eventType ? _this63.getEncryptedIfNeededEventType(roomId, eventType) : null;
+      var [eventResult, result] = yield Promise.all([_this63.fetchRoomEvent(roomId, eventId), _this63.fetchRelations(roomId, eventId, relationType, fetchedEventType, opts)]);
+      var mapper = _this63.getEventMapper();
       var originalEvent = eventResult ? mapper(eventResult) : undefined;
       var events = result.chunk.map(mapper);
       if (fetchedEventType === EventType.RoomMessageEncrypted) {
         var allEvents = originalEvent ? events.concat(originalEvent) : events;
-        yield Promise.all(allEvents.map(e => _this64.decryptEventIfNeeded(e)));
+        yield Promise.all(allEvents.map(e => _this63.decryptEventIfNeeded(e)));
         if (eventType !== null) {
           events = events.filter(e => e.getType() === eventType);
         }
@@ -6579,22 +6469,22 @@ export class MatrixClient extends TypedEventEmitter {
    */
   logout() {
     var _arguments9 = arguments,
-      _this65 = this;
+      _this64 = this;
     return _asyncToGenerator(function* () {
-      var _this65$crypto;
+      var _this64$crypto;
       var stopClient = _arguments9.length > 0 && _arguments9[0] !== undefined ? _arguments9[0] : false;
-      if ((_this65$crypto = _this65.crypto) !== null && _this65$crypto !== void 0 && (_this65$crypto = _this65$crypto.backupManager) !== null && _this65$crypto !== void 0 && _this65$crypto.getKeyBackupEnabled()) {
+      if ((_this64$crypto = _this64.crypto) !== null && _this64$crypto !== void 0 && (_this64$crypto = _this64$crypto.backupManager) !== null && _this64$crypto !== void 0 && _this64$crypto.getKeyBackupEnabled()) {
         try {
-          while ((yield _this65.crypto.backupManager.backupPendingKeys(200)) > 0);
+          while ((yield _this64.crypto.backupManager.backupPendingKeys(200)) > 0);
         } catch (err) {
-          _this65.logger.error("Key backup request failed when logging out. Some keys may be missing from backup", err);
+          _this64.logger.error("Key backup request failed when logging out. Some keys may be missing from backup", err);
         }
       }
       if (stopClient) {
-        _this65.stopClient();
-        _this65.http.abort();
+        _this64.stopClient();
+        _this64.http.abort();
       }
-      return _this65.http.authedRequest(Method.Post, "/logout");
+      return _this64.http.authedRequest(Method.Post, "/logout");
     })();
   }
 
@@ -6632,12 +6522,12 @@ export class MatrixClient extends TypedEventEmitter {
    * or UIA auth data.
    */
   requestLoginToken(auth) {
-    var _this66 = this;
+    var _this65 = this;
     return _asyncToGenerator(function* () {
       var body = {
         auth
       };
-      return _this66.http.authedRequest(Method.Post, "/login/get_token", undefined,
+      return _this65.http.authedRequest(Method.Post, "/login/get_token", undefined,
       // no query params
       body, {
         prefix: ClientPrefix.V1
@@ -6669,23 +6559,23 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   createRoom(options) {
-    var _this67 = this;
+    var _this66 = this;
     return _asyncToGenerator(function* () {
-      var _this67$identityServe;
+      var _this66$identityServe;
       // eslint-disable-line camelcase
       // some valid options include: room_alias_name, visibility, invite
 
       // inject the id_access_token if inviting 3rd party addresses
       var invitesNeedingToken = (options.invite_3pid || []).filter(i => !i.id_access_token);
-      if (invitesNeedingToken.length > 0 && (_this67$identityServe = _this67.identityServer) !== null && _this67$identityServe !== void 0 && _this67$identityServe.getAccessToken) {
-        var identityAccessToken = yield _this67.identityServer.getAccessToken();
+      if (invitesNeedingToken.length > 0 && (_this66$identityServe = _this66.identityServer) !== null && _this66$identityServe !== void 0 && _this66$identityServe.getAccessToken) {
+        var identityAccessToken = yield _this66.identityServer.getAccessToken();
         if (identityAccessToken) {
           for (var invite of invitesNeedingToken) {
             invite.id_access_token = identityAccessToken;
           }
         }
       }
-      return _this67.http.authedRequest(Method.Post, "/createRoom", undefined, options);
+      return _this66.http.authedRequest(Method.Post, "/createRoom", undefined, options);
     })();
   }
 
@@ -6869,7 +6759,7 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Promise which resolves: the empty object, `{}`.
    */
   setRoomReadMarkersHttpRequest(roomId, rmEventId, rrEventId, rpEventId) {
-    var _this68 = this;
+    var _this67 = this;
     return _asyncToGenerator(function* () {
       var path = utils.encodeUri("/rooms/$roomId/read_markers", {
         $roomId: roomId
@@ -6878,10 +6768,10 @@ export class MatrixClient extends TypedEventEmitter {
         [ReceiptType.FullyRead]: rmEventId,
         [ReceiptType.Read]: rrEventId
       };
-      if ((yield _this68.doesServerSupportUnstableFeature("org.matrix.msc2285.stable")) || (yield _this68.isVersionSupported("v1.4"))) {
+      if ((yield _this67.doesServerSupportUnstableFeature("org.matrix.msc2285.stable")) || (yield _this67.isVersionSupported("v1.4"))) {
         content[ReceiptType.ReadPrivate] = rpEventId;
       }
-      return _this68.http.authedRequest(Method.Post, path, undefined, content);
+      return _this67.http.authedRequest(Method.Post, path, undefined, content);
     })();
   }
 
@@ -7114,9 +7004,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns `true` if supported, otherwise `false`
    */
   doesServerSupportExtendedProfiles() {
-    var _this69 = this;
+    var _this68 = this;
     return _asyncToGenerator(function* () {
-      return _this69.doesServerSupportUnstableFeature(UNSTABLE_MSC4133_EXTENDED_PROFILES);
+      return _this68.doesServerSupportUnstableFeature(UNSTABLE_MSC4133_EXTENDED_PROFILES);
     })();
   }
 
@@ -7126,9 +7016,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns The prefix for use with `authedRequest`
    */
   getExtendedProfileRequestPrefix() {
-    var _this70 = this;
+    var _this69 = this;
     return _asyncToGenerator(function* () {
-      if (yield _this70.doesServerSupportUnstableFeature("uk.tcpip.msc4133.stable")) {
+      if (yield _this69.doesServerSupportUnstableFeature("uk.tcpip.msc4133.stable")) {
         return ClientPrefix.V3;
       }
       return "/_matrix/client/unstable/uk.tcpip.msc4133";
@@ -7146,15 +7036,15 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws A M_NOT_FOUND error if the profile could not be found.
    */
   getExtendedProfile(userId) {
-    var _this71 = this;
+    var _this70 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this71.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this70.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      return _this71.http.authedRequest(Method.Get, utils.encodeUri("/profile/$userId", {
+      return _this70.http.authedRequest(Method.Get, utils.encodeUri("/profile/$userId", {
         $userId: userId
       }), undefined, undefined, {
-        prefix: yield _this71.getExtendedProfileRequestPrefix()
+        prefix: yield _this70.getExtendedProfileRequestPrefix()
       });
     })();
   }
@@ -7171,16 +7061,16 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws A M_NOT_FOUND error if the key was not set OR the profile could not be found.
    */
   getExtendedProfileProperty(userId, key) {
-    var _this72 = this;
+    var _this71 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this72.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this71.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      var profile = yield _this72.http.authedRequest(Method.Get, utils.encodeUri("/profile/$userId/$key", {
+      var profile = yield _this71.http.authedRequest(Method.Get, utils.encodeUri("/profile/$userId/$key", {
         $userId: userId,
         $key: key
       }), undefined, undefined, {
-        prefix: yield _this72.getExtendedProfileRequestPrefix()
+        prefix: yield _this71.getExtendedProfileRequestPrefix()
       });
       return profile[key];
     })();
@@ -7196,19 +7086,19 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.
    */
   setExtendedProfileProperty(key, value) {
-    var _this73 = this;
+    var _this72 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this73.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this72.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      var userId = _this73.getUserId();
-      yield _this73.http.authedRequest(Method.Put, utils.encodeUri("/profile/$userId/$key", {
+      var userId = _this72.getUserId();
+      yield _this72.http.authedRequest(Method.Put, utils.encodeUri("/profile/$userId/$key", {
         $userId: userId,
         $key: key
       }), undefined, {
         [key]: value
       }, {
-        prefix: yield _this73.getExtendedProfileRequestPrefix()
+        prefix: yield _this72.getExtendedProfileRequestPrefix()
       });
     })();
   }
@@ -7222,17 +7112,17 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.
    */
   deleteExtendedProfileProperty(key) {
-    var _this74 = this;
+    var _this73 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this74.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this73.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      var userId = _this74.getUserId();
-      yield _this74.http.authedRequest(Method.Delete, utils.encodeUri("/profile/$userId/$key", {
+      var userId = _this73.getUserId();
+      yield _this73.http.authedRequest(Method.Delete, utils.encodeUri("/profile/$userId/$key", {
         $userId: userId,
         $key: key
       }), undefined, undefined, {
-        prefix: yield _this74.getExtendedProfileRequestPrefix()
+        prefix: yield _this73.getExtendedProfileRequestPrefix()
       });
     })();
   }
@@ -7248,16 +7138,16 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.
    */
   patchExtendedProfile(profile) {
-    var _this75 = this;
+    var _this74 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this75.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this74.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      var userId = _this75.getUserId();
-      return _this75.http.authedRequest(Method.Patch, utils.encodeUri("/profile/$userId", {
+      var userId = _this74.getUserId();
+      return _this74.http.authedRequest(Method.Patch, utils.encodeUri("/profile/$userId", {
         $userId: userId
       }), {}, profile, {
-        prefix: yield _this75.getExtendedProfileRequestPrefix()
+        prefix: yield _this74.getExtendedProfileRequestPrefix()
       });
     })();
   }
@@ -7272,16 +7162,16 @@ export class MatrixClient extends TypedEventEmitter {
    * @throws An error if the server does not support MSC4133 OR the server disallows editing the user profile.
    */
   setExtendedProfile(profile) {
-    var _this76 = this;
+    var _this75 = this;
     return _asyncToGenerator(function* () {
-      if (!(yield _this76.doesServerSupportExtendedProfiles())) {
+      if (!(yield _this75.doesServerSupportExtendedProfiles())) {
         throw new Error("Server does not support extended profiles");
       }
-      var userId = _this76.getUserId();
-      yield _this76.http.authedRequest(Method.Put, utils.encodeUri("/profile/$userId", {
+      var userId = _this75.getUserId();
+      yield _this75.http.authedRequest(Method.Put, utils.encodeUri("/profile/$userId", {
         $userId: userId
       }), {}, profile, {
-        prefix: yield _this76.getExtendedProfileRequestPrefix()
+        prefix: yield _this75.getExtendedProfileRequestPrefix()
       });
     })();
   }
@@ -7304,10 +7194,10 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   addThreePidOnly(data) {
-    var _this77 = this;
+    var _this76 = this;
     return _asyncToGenerator(function* () {
       var path = "/account/3pid/add";
-      return _this77.http.authedRequest(Method.Post, path, undefined, data);
+      return _this76.http.authedRequest(Method.Post, path, undefined, data);
     })();
   }
 
@@ -7323,10 +7213,10 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   bindThreePid(data) {
-    var _this78 = this;
+    var _this77 = this;
     return _asyncToGenerator(function* () {
       var path = "/account/3pid/bind";
-      return _this78.http.authedRequest(Method.Post, path, undefined, data);
+      return _this77.http.authedRequest(Method.Post, path, undefined, data);
     })();
   }
 
@@ -7344,15 +7234,15 @@ export class MatrixClient extends TypedEventEmitter {
   unbindThreePid(medium, address
   // eslint-disable-next-line camelcase
   ) {
-    var _this79 = this;
+    var _this78 = this;
     return _asyncToGenerator(function* () {
       var path = "/account/3pid/unbind";
       var data = {
         medium,
         address,
-        id_server: _this79.getIdentityServerUrl(true)
+        id_server: _this78.getIdentityServerUrl(true)
       };
-      return _this79.http.authedRequest(Method.Post, path, undefined, data);
+      return _this78.http.authedRequest(Method.Post, path, undefined, data);
     })();
   }
 
@@ -7474,13 +7364,13 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   getPushers() {
-    var _this80 = this;
+    var _this79 = this;
     return _asyncToGenerator(function* () {
-      var response = yield _this80.http.authedRequest(Method.Get, "/pushers");
+      var response = yield _this79.http.authedRequest(Method.Get, "/pushers");
 
       // Migration path for clients that connect to a homeserver that does not support
       // MSC3881 yet, see https://github.com/matrix-org/matrix-spec-proposals/blob/kerry/remote-push-toggle/proposals/3881-remote-push-notification-toggling.md#migration
-      if (!(yield _this80.doesServerSupportUnstableFeature("org.matrix.msc3881"))) {
+      if (!(yield _this79.doesServerSupportUnstableFeature("org.matrix.msc3881"))) {
         response.pushers = response.pushers.map(pusher => {
           if (!pusher.hasOwnProperty(PUSHER_ENABLED.name)) {
             pusher[PUSHER_ENABLED.name] = true;
@@ -7910,7 +7800,7 @@ export class MatrixClient extends TypedEventEmitter {
    * found MXIDs. Results where no user could be found will not be listed.
    */
   identityHashedLookup(addressPairs, identityAccessToken) {
-    var _this81 = this;
+    var _this80 = this;
     return _asyncToGenerator(function* () {
       var params = {
         // addresses: ["email@example.org", "10005550000"],
@@ -7919,7 +7809,7 @@ export class MatrixClient extends TypedEventEmitter {
       };
 
       // Get hash information first before trying to do a lookup
-      var hashes = yield _this81.getIdentityHashDetails(identityAccessToken);
+      var hashes = yield _this80.getIdentityHashDetails(identityAccessToken);
       if (!hashes || !hashes["lookup_pepper"] || !hashes["algorithms"]) {
         throw new Error("Unsupported identity server: bad response");
       }
@@ -7962,7 +7852,7 @@ export class MatrixClient extends TypedEventEmitter {
       } else {
         throw new Error("Unsupported identity server: unknown hash algorithm");
       }
-      var response = yield _this81.http.idServerRequest(Method.Post, "/lookup", params, IdentityPrefix.V2, identityAccessToken);
+      var response = yield _this80.http.idServerRequest(Method.Post, "/lookup", params, IdentityPrefix.V2, identityAccessToken);
       if (!(response !== null && response !== void 0 && response["mappings"])) return []; // no results
 
       var foundAddresses = [];
@@ -7996,12 +7886,12 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   lookupThreePid(medium, address, identityAccessToken) {
-    var _this82 = this;
+    var _this81 = this;
     return _asyncToGenerator(function* () {
       // Note: we're using the V2 API by calling this function, but our
       // function contract requires a V1 response. We therefore have to
       // convert it manually.
-      var response = yield _this82.identityHashedLookup([[address, medium]], identityAccessToken);
+      var response = yield _this81.identityHashedLookup([[address, medium]], identityAccessToken);
       var result = response.find(p => p.address === address);
       if (!result) {
         return {};
@@ -8033,12 +7923,12 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: with an error response.
    */
   bulkLookupThreePids(query, identityAccessToken) {
-    var _this83 = this;
+    var _this82 = this;
     return _asyncToGenerator(function* () {
       // Note: we're using the V2 API by calling this function, but our
       // function contract requires a V1 response. We therefore have to
       // convert it manually.
-      var response = yield _this83.identityHashedLookup(
+      var response = yield _this82.identityHashedLookup(
       // We have to reverse the query order to get [address, medium] pairs
       query.map(p => [p[1], p[0]]), identityAccessToken);
       var v1results = [];
@@ -8239,16 +8129,16 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Promise which resolves to the created space.
    */
   unstableCreateFileTree(name) {
-    var _this84 = this;
+    var _this83 = this;
     return _asyncToGenerator(function* () {
       var {
         room_id: roomId
-      } = yield _this84.createRoom({
+      } = yield _this83.createRoom({
         name: name,
         preset: Preset.PrivateChat,
         power_level_content_override: _objectSpread(_objectSpread({}, DEFAULT_TREE_POWER_LEVELS_TEMPLATE), {}, {
           users: {
-            [_this84.getUserId()]: 100
+            [_this83.getUserId()]: 100
           }
         }),
         creation_content: {
@@ -8268,7 +8158,7 @@ export class MatrixClient extends TypedEventEmitter {
           }
         }]
       });
-      return new MSC3089TreeSpace(_this84, roomId);
+      return new MSC3089TreeSpace(_this83, roomId);
     })();
   }
 
@@ -8345,7 +8235,7 @@ export class MatrixClient extends TypedEventEmitter {
    * @param via - The list of servers which know about the room if only an ID was provided.
    */
   getRoomSummary(roomIdOrAlias, via) {
-    var _this85 = this;
+    var _this84 = this;
     return _asyncToGenerator(function* () {
       var paramOpts = {
         prefix: "/_matrix/client/unstable/im.nheko.summary"
@@ -8354,7 +8244,7 @@ export class MatrixClient extends TypedEventEmitter {
         var path = utils.encodeUri("/summary/$roomid", {
           $roomid: roomIdOrAlias
         });
-        return yield _this85.http.authedRequest(Method.Get, path, {
+        return yield _this84.http.authedRequest(Method.Get, path, {
           via
         }, undefined, paramOpts);
       } catch (e) {
@@ -8362,7 +8252,7 @@ export class MatrixClient extends TypedEventEmitter {
           var _path = utils.encodeUri("/rooms/$roomid/summary", {
             $roomid: roomIdOrAlias
           });
-          return yield _this85.http.authedRequest(Method.Get, _path, {
+          return yield _this84.http.authedRequest(Method.Get, _path, {
             via
           }, undefined, paramOpts);
         } else {
@@ -8414,9 +8304,9 @@ export class MatrixClient extends TypedEventEmitter {
    * Fetches information about the user for the configured access token.
    */
   whoami() {
-    var _this86 = this;
+    var _this85 = this;
     return _asyncToGenerator(function* () {
-      return _this86.http.authedRequest(Method.Get, "/account/whoami");
+      return _this85.http.authedRequest(Method.Get, "/account/whoami");
     })();
   }
 
@@ -8427,7 +8317,7 @@ export class MatrixClient extends TypedEventEmitter {
    * @returns Rejects: when the request fails (module:http-api.MatrixError)
    */
   timestampToEvent(roomId, timestamp, dir) {
-    var _this87 = this;
+    var _this86 = this;
     return _asyncToGenerator(function* () {
       var path = utils.encodeUri("/rooms/$roomId/timestamp_to_event", {
         $roomId: roomId
@@ -8437,7 +8327,7 @@ export class MatrixClient extends TypedEventEmitter {
         dir: dir
       };
       try {
-        return yield _this87.http.authedRequest(Method.Get, path, queryParams, undefined, {
+        return yield _this86.http.authedRequest(Method.Get, path, queryParams, undefined, {
           prefix: ClientPrefix.V1
         });
       } catch (err) {
@@ -8453,7 +8343,7 @@ export class MatrixClient extends TypedEventEmitter {
         // both indicate that this endpoint+verb combination is
         // not supported.
         err.httpStatus === 404 || err.httpStatus === 405)) {
-          return yield _this87.http.authedRequest(Method.Get, path, queryParams, undefined, {
+          return yield _this86.http.authedRequest(Method.Get, path, queryParams, undefined, {
             prefix: "/_matrix/client/unstable/org.matrix.msc3030"
           });
         }
@@ -8469,9 +8359,9 @@ export class MatrixClient extends TypedEventEmitter {
    * @experimental - part of MSC2965
    */
   getAuthIssuer() {
-    var _this88 = this;
+    var _this87 = this;
     return _asyncToGenerator(function* () {
-      return _this88.http.request(Method.Get, "/auth_issuer", undefined, undefined, {
+      return _this87.http.request(Method.Get, "/auth_issuer", undefined, undefined, {
         prefix: ClientPrefix.Unstable + "/org.matrix.msc2965"
       });
     })();