@openclaw/matrix 2026.7.1-beta.2 → 2026.7.1-beta.5

package/node_modules/matrix-js-sdk/lib/models/room.js

@@ -1,8 +1,5 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _objectSpread from "@babel/runtime/helpers/objectSpread2";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 /*
 Copyright 2015 - 2023 The Matrix.org Foundation C.I.C.
 
@@ -46,6 +43,7 @@ import { compareEventOrdering } from "./compare-event-ordering.js";
 import { KnownMembership } from "../@types/membership.js";
 import { RoomVersionStability } from "../serverCapabilities.js";
 import { RoomStickyEventsStore, RoomStickyEventsEvent } from "./room-sticky-events.js";
+import { RoomRetentionPolicy } from "./room-retention.js";
 
 // These constants are used as sane defaults when the homeserver doesn't support
 // the m.room_versions capability. In practice, KNOWN_SAFE_ROOM_VERSION should be
@@ -53,8 +51,8 @@ import { RoomStickyEventsStore, RoomStickyEventsEvent } from "./room-sticky-even
 // room versions which are considered okay for people to run without being asked
 // to upgrade (ie: "stable"). Eventually, we should remove these when all homeservers
 // return an m.room_versions capability.
-export var KNOWN_SAFE_ROOM_VERSION = "10";
-var SAFE_ROOM_VERSIONS = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"];
+export const KNOWN_SAFE_ROOM_VERSION = "10";
+const SAFE_ROOM_VERSIONS = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"];
 // When inserting a visibility event affecting event `eventId`, we
 // need to scan through existing visibility events for `eventId`.
 // In theory, this could take an unlimited amount of time if:
@@ -69,13 +67,13 @@ var SAFE_ROOM_VERSIONS = ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"];
 // expecting that a broken visibility change for a single event in
 // an extremely uncommon case (possibly a DoS) is a small
 // price to pay to keep matrix-js-sdk responsive.
-var MAX_NUMBER_OF_VISIBILITY_EVENTS_TO_SCAN_THROUGH = 30;
-export var NotificationCountType = /*#__PURE__*/function (NotificationCountType) {
+const MAX_NUMBER_OF_VISIBILITY_EVENTS_TO_SCAN_THROUGH = 30;
+export let NotificationCountType = /*#__PURE__*/function (NotificationCountType) {
   NotificationCountType["Highlight"] = "highlight";
   NotificationCountType["Total"] = "total";
   return NotificationCountType;
 }({});
-export var RoomEvent = /*#__PURE__*/function (RoomEvent) {
+export let RoomEvent = /*#__PURE__*/function (RoomEvent) {
   RoomEvent["MyMembership"] = "Room.myMembership";
   RoomEvent["Tags"] = "Room.tags";
   RoomEvent["AccountData"] = "Room.accountData";
@@ -118,13 +116,12 @@ export class Room extends ReadReceipt {
    * @param myUserId - Required. The ID of the syncing user.
    * @param opts - Configuration options
    */
-  constructor(roomId, client, myUserId) {
-    var _this;
-    var opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  constructor(roomId, client, myUserId, opts = {}) {
+    super();
+
     // In some cases, we add listeners for every displayed Matrix event, so it's
     // common to have quite a few more than the default limit.
-    super();
-    _this = this;
+    _defineProperty(this, "reEmitter", void 0);
     _defineProperty(this, "txnToEvent", new Map());
     // Pending in-flight requests { string: MatrixEvent }
     _defineProperty(this, "notificationCounts", {});
@@ -138,6 +135,7 @@ export class Room extends ReadReceipt {
      * This is useful in determining whether a user has read a thread or not
      */
     _defineProperty(this, "unthreadedReceipts", new Map());
+    _defineProperty(this, "timelineSets", void 0);
     _defineProperty(this, "polls", new Map());
     /**
      * Empty array if the timeline sets have not been initialised. After initialisation:
@@ -149,6 +147,10 @@ export class Room extends ReadReceipt {
     _defineProperty(this, "filteredTimelineSets", {});
     // filter_id: timelineSet
     _defineProperty(this, "timelineNeedsRefresh", false);
+    _defineProperty(this, "pendingEventList", void 0);
+    // read by megolm via getter; boolean value - null indicates "use global value"
+    _defineProperty(this, "blacklistUnverifiedDevices", void 0);
+    _defineProperty(this, "selfMembership", void 0);
     /**
      * A `Hero` is a stripped `m.room.member` event which contains the important renderable fields from the event.
      *
@@ -161,6 +163,16 @@ export class Room extends ReadReceipt {
     _defineProperty(this, "heroes", null);
     // flags to stop logspam about missing m.room.create events
     _defineProperty(this, "getTypeWarning", false);
+    _defineProperty(this, "membersPromise", void 0);
+    // XXX: These should be read-only
+    /**
+     * The human-readable display name for this room.
+     */
+    _defineProperty(this, "name", void 0);
+    /**
+     * The un-homoglyphed name for this room.
+     */
+    _defineProperty(this, "normalizedName", void 0);
     /**
      * Dict of room tags; the keys are the tag name and the values
      * are any metadata associated with the tag - e.g. `{ "fav" : { order: 1 } }`
@@ -177,6 +189,21 @@ export class Room extends ReadReceipt {
      * The room summary.
      */
     _defineProperty(this, "summary", null);
+    /**
+     * oldState The state of the room at the time of the oldest event in the live timeline.
+     *
+     * @deprecated Present for backwards compatibility.
+     *             Use getLiveTimeline().getState(EventTimeline.BACKWARDS) instead
+     */
+    _defineProperty(this, "oldState", void 0);
+    /**
+     * currentState The state of the room at the time of the newest event in the timeline.
+     *
+     * @deprecated Present for backwards compatibility.
+     *             Use getLiveTimeline().getState(EventTimeline.FORWARDS) instead.
+     */
+    _defineProperty(this, "currentState", void 0);
+    _defineProperty(this, "relations", void 0);
     /**
      * A collection of events known by the client
      * This is not a comprehensive list of the threads that exist in this room
@@ -208,15 +235,38 @@ export class Room extends ReadReceipt {
      * Stores and tracks sticky events
      */
     _defineProperty(this, "stickyEvents", new RoomStickyEventsStore());
+    _defineProperty(this, "retention", void 0);
     _defineProperty(this, "threadTimelineSetsPromise", null);
+    _defineProperty(this, "onReceipt", event => {
+      if (this.hasEncryptionStateEvent()) {
+        this.clearNotificationsOnReceipt(event);
+      }
+    });
     _defineProperty(this, "threadsReady", false);
+    _defineProperty(this, "onThreadUpdate", thread => {
+      this.updateThreadRootEvents(thread, false, false);
+    });
+    _defineProperty(this, "onThreadReply", thread => {
+      this.updateThreadRootEvents(thread, false, true);
+    });
+    _defineProperty(this, "onThreadDelete", thread => {
+      this.threads.delete(thread.id);
+      const timeline = this.getTimelineForEvent(thread.id);
+      const roomEvent = timeline?.getEvents()?.find(it => it.getId() === thread.id);
+      if (roomEvent) {
+        thread.clearEventMetadata(roomEvent);
+      } else {
+        logger.debug("onThreadDelete: Could not find root event in room timeline");
+      }
+      for (const timelineSet of this.threadsTimelineSets) {
+        timelineSet.removeEvent(thread.id);
+      }
+    });
     _defineProperty(this, "updateThreadRootEvents", (thread, toStartOfTimeline, recreateEvent) => {
       if (thread.length) {
-        var _this$threadsTimeline;
-        this.updateThreadRootEvent((_this$threadsTimeline = this.threadsTimelineSets) === null || _this$threadsTimeline === void 0 ? void 0 : _this$threadsTimeline[0], thread, toStartOfTimeline, recreateEvent);
+        this.updateThreadRootEvent(this.threadsTimelineSets?.[0], thread, toStartOfTimeline, recreateEvent);
         if (thread.hasCurrentUserParticipated) {
-          var _this$threadsTimeline2;
-          this.updateThreadRootEvent((_this$threadsTimeline2 = this.threadsTimelineSets) === null || _this$threadsTimeline2 === void 0 ? void 0 : _this$threadsTimeline2[1], thread, toStartOfTimeline, recreateEvent);
+          this.updateThreadRootEvent(this.threadsTimelineSets?.[1], thread, toStartOfTimeline, recreateEvent);
         }
       }
     });
@@ -248,10 +298,10 @@ export class Room extends ReadReceipt {
       // if they wish to. Also this may be needed to trigger an update.
 
       if (event.isRedaction()) {
-        var redactId = event.event.redacts;
+        const redactId = event.event.redacts;
 
         // if we know about this event, redact its contents now.
-        var redactedEvent = redactId ? this.findEventById(redactId) : undefined;
+        const redactedEvent = redactId ? this.findEventById(redactId) : undefined;
         if (redactId) {
           try {
             this.stickyEvents.handleRedaction(redactedEvent || redactId);
@@ -264,17 +314,17 @@ export class Room extends ReadReceipt {
           this.applyEventAsRedaction(event, redactedEvent);
         }
       } else if (event.getType() === EventType.RoomMember) {
-        var membership = event.getContent()["membership"];
+        const membership = event.getContent()["membership"];
         if (membership !== KnownMembership.Ban && !(membership === KnownMembership.Leave && event.getStateKey() !== event.getSender())) {
           // Not a ban or kick, therefore not a membership event we care about here.
           return;
         }
-        var redactEvents = event.getContent()["org.matrix.msc4293.redact_events"];
+        const redactEvents = event.getContent()["org.matrix.msc4293.redact_events"];
         if (redactEvents !== true) {
           // Invalid or not set - nothing to redact.
           return;
         }
-        var state = this.getLiveTimeline().getState(Direction.Forward);
+        const state = this.getLiveTimeline().getState(Direction.Forward);
         if (!state.maySendRedactionForEvent(event, event.getSender())) {
           // If the sender can't redact the membership event, then they won't be able to
           // redact any of the target's events either, so skip.
@@ -282,14 +332,14 @@ export class Room extends ReadReceipt {
         }
 
         // The redaction is possible, so let's find all the events and apply it.
-        var events = this.getTimelineSets().map(s => s.getTimelines()).reduce((p, c) => {
+        const events = this.getTimelineSets().map(s => s.getTimelines()).reduce((p, c) => {
           p.push(...c);
           return p;
         }, []).map(t => t.getEvents().filter(e => e.getSender() === event.getStateKey())).reduce((p, c) => {
           p.push(...c);
           return c;
         }, []);
-        for (var toRedact of events) {
+        for (const toRedact of events) {
           this.applyEventAsRedaction(event, toRedact);
         }
       }
@@ -318,20 +368,15 @@ export class Room extends ReadReceipt {
     if (this.opts.pendingEventOrdering === PendingEventOrdering.Detached) {
       this.pendingEventList = [];
       this.client.store.getPendingEvents(this.roomId).then(events => {
-        var mapper = this.client.getEventMapper({
+        const mapper = this.client.getEventMapper({
           decrypt: false
         });
-        events.forEach(/*#__PURE__*/function () {
-          var _ref = _asyncToGenerator(function* (serializedEvent) {
-            var event = mapper(serializedEvent);
-            yield client.decryptEventIfNeeded(event);
-            event.setStatus(EventStatus.NOT_SENT);
-            _this.addPendingEvent(event, event.getTxnId());
-          });
-          return function (_x) {
-            return _ref.apply(this, arguments);
-          };
-        }());
+        events.forEach(async serializedEvent => {
+          const event = mapper(serializedEvent);
+          await client.decryptEventIfNeeded(event);
+          event.setStatus(EventStatus.NOT_SENT);
+          this.addPendingEvent(event, event.getTxnId());
+        });
       });
     }
 
@@ -341,28 +386,27 @@ export class Room extends ReadReceipt {
     } else {
       this.membersPromise = undefined;
     }
+    if (this.client?._unstable_shouldApplyMessageRetention) {
+      this.retention = new RoomRetentionPolicy(this, client.retentionPolicyService, client.store);
+    }
   }
-  createThreadsTimelineSets() {
-    var _this2 = this;
-    return _asyncToGenerator(function* () {
-      var _this2$client;
-      if (_this2.threadTimelineSetsPromise) {
-        return _this2.threadTimelineSetsPromise;
-      }
-      if ((_this2$client = _this2.client) !== null && _this2$client !== void 0 && _this2$client.supportsThreads()) {
-        try {
-          _this2.threadTimelineSetsPromise = Promise.all([_this2.createThreadTimelineSet(), _this2.createThreadTimelineSet(ThreadFilterType.My)]);
-          var timelineSets = yield _this2.threadTimelineSetsPromise;
-          _this2.threadsTimelineSets[0] = timelineSets[0];
-          _this2.threadsTimelineSets[1] = timelineSets[1];
-          return timelineSets;
-        } catch (_unused) {
-          _this2.threadTimelineSetsPromise = null;
-          return null;
-        }
+  async createThreadsTimelineSets() {
+    if (this.threadTimelineSetsPromise) {
+      return this.threadTimelineSetsPromise;
+    }
+    if (this.client?.supportsThreads()) {
+      try {
+        this.threadTimelineSetsPromise = Promise.all([this.createThreadTimelineSet(), this.createThreadTimelineSet(ThreadFilterType.My)]);
+        const timelineSets = await this.threadTimelineSetsPromise;
+        this.threadsTimelineSets[0] = timelineSets[0];
+        this.threadsTimelineSets[1] = timelineSets[1];
+        return timelineSets;
+      } catch {
+        this.threadTimelineSetsPromise = null;
+        return null;
       }
-      return null;
-    })();
+    }
+    return null;
   }
 
   /**
@@ -376,18 +420,15 @@ export class Room extends ReadReceipt {
    *
    * @returns Signals when all events have been decrypted
    */
-  decryptCriticalEvents() {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this3.client.getCrypto()) return;
-      var readReceiptEventId = _this3.getEventReadUpTo(_this3.client.getUserId(), true);
-      var events = _this3.getLiveTimeline().getEvents();
-      var readReceiptTimelineIndex = events.findIndex(matrixEvent => {
-        return matrixEvent.event.event_id === readReceiptEventId;
-      });
-      var decryptionPromises = events.slice(readReceiptTimelineIndex).reverse().map(event => _this3.client.decryptEventIfNeeded(event));
-      yield Promise.allSettled(decryptionPromises);
-    })();
+  async decryptCriticalEvents() {
+    if (!this.client.getCrypto()) return;
+    const readReceiptEventId = this.getEventReadUpTo(this.client.getUserId(), true);
+    const events = this.getLiveTimeline().getEvents();
+    const readReceiptTimelineIndex = events.findIndex(matrixEvent => {
+      return matrixEvent.event.event_id === readReceiptEventId;
+    });
+    const decryptionPromises = events.slice(readReceiptTimelineIndex).reverse().map(event => this.client.decryptEventIfNeeded(event));
+    await Promise.allSettled(decryptionPromises);
   }
 
   /**
@@ -395,14 +436,11 @@ export class Room extends ReadReceipt {
    *
    * @returns Signals when all events have been decrypted
    */
-  decryptAllEvents() {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this4.client.getCrypto()) return;
-      var decryptionPromises = _this4.getUnfilteredTimelineSet().getLiveTimeline().getEvents().slice(0) // copy before reversing
-      .reverse().map(event => _this4.client.decryptEventIfNeeded(event));
-      yield Promise.allSettled(decryptionPromises);
-    })();
+  async decryptAllEvents() {
+    if (!this.client.getCrypto()) return;
+    const decryptionPromises = this.getUnfilteredTimelineSet().getLiveTimeline().getEvents().slice(0) // copy before reversing
+    .reverse().map(event => this.client.decryptEventIfNeeded(event));
+    await Promise.allSettled(decryptionPromises);
   }
 
   /**
@@ -410,9 +448,8 @@ export class Room extends ReadReceipt {
    * @returns The creator of the room, or null if it could not be determined
    */
   getCreator() {
-    var _createEvent$getSende;
-    var createEvent = this.currentState.getStateEvents(EventType.RoomCreate, "");
-    return (_createEvent$getSende = createEvent === null || createEvent === void 0 ? void 0 : createEvent.getSender()) !== null && _createEvent$getSende !== void 0 ? _createEvent$getSende : null;
+    const createEvent = this.currentState.getStateEvents(EventType.RoomCreate, "");
+    return createEvent?.getSender() ?? null;
   }
 
   /**
@@ -434,53 +471,50 @@ export class Room extends ReadReceipt {
    * @returns
    * Resolves to the version the room should be upgraded to.
    */
-  getRecommendedVersion() {
-    var _this5 = this;
-    return _asyncToGenerator(function* () {
-      var capabilities = {};
+  async getRecommendedVersion() {
+    let capabilities = {};
+    try {
+      capabilities = await this.client.getCapabilities();
+    } catch {}
+    let versionCap = capabilities["m.room_versions"];
+    if (!versionCap) {
+      versionCap = {
+        default: KNOWN_SAFE_ROOM_VERSION,
+        available: {}
+      };
+      for (const safeVer of SAFE_ROOM_VERSIONS) {
+        versionCap.available[safeVer] = RoomVersionStability.Stable;
+      }
+    }
+    let result = this.checkVersionAgainstCapability(versionCap);
+    if (result.urgent && result.needsUpgrade) {
+      // Something doesn't feel right: we shouldn't need to update
+      // because the version we're on should be in the protocol's
+      // namespace. This usually means that the server was updated
+      // before the client was, making us think the newest possible
+      // room version is not stable. As a solution, we'll refresh
+      // the capability we're using to determine this.
+      logger.warn("Refreshing room version capability because the server looks " + "to be supporting a newer room version we don't know about.");
       try {
-        capabilities = yield _this5.client.getCapabilities();
-      } catch (_unused2) {}
-      var versionCap = capabilities["m.room_versions"];
-      if (!versionCap) {
-        versionCap = {
-          default: KNOWN_SAFE_ROOM_VERSION,
-          available: {}
-        };
-        for (var safeVer of SAFE_ROOM_VERSIONS) {
-          versionCap.available[safeVer] = RoomVersionStability.Stable;
-        }
+        capabilities = await this.client.fetchCapabilities();
+      } catch (e) {
+        logger.warn("Failed to refresh room version capabilities", e);
       }
-      var result = _this5.checkVersionAgainstCapability(versionCap);
-      if (result.urgent && result.needsUpgrade) {
-        // Something doesn't feel right: we shouldn't need to update
-        // because the version we're on should be in the protocol's
-        // namespace. This usually means that the server was updated
-        // before the client was, making us think the newest possible
-        // room version is not stable. As a solution, we'll refresh
-        // the capability we're using to determine this.
-        logger.warn("Refreshing room version capability because the server looks " + "to be supporting a newer room version we don't know about.");
-        try {
-          capabilities = yield _this5.client.fetchCapabilities();
-        } catch (e) {
-          logger.warn("Failed to refresh room version capabilities", e);
-        }
-        versionCap = capabilities["m.room_versions"];
-        if (!versionCap) {
-          logger.warn("No room version capability - assuming upgrade required.");
-          return result;
-        } else {
-          result = _this5.checkVersionAgainstCapability(versionCap);
-        }
+      versionCap = capabilities["m.room_versions"];
+      if (!versionCap) {
+        logger.warn("No room version capability - assuming upgrade required.");
+        return result;
+      } else {
+        result = this.checkVersionAgainstCapability(versionCap);
       }
-      return result;
-    })();
+    }
+    return result;
   }
   checkVersionAgainstCapability(versionCap) {
-    var currentVersion = this.getVersion();
-    logger.log("[".concat(this.roomId, "] Current version: ").concat(currentVersion));
-    logger.log("[".concat(this.roomId, "] Version capability: "), versionCap);
-    var result = {
+    const currentVersion = this.getVersion();
+    logger.log(`[${this.roomId}] Current version: ${currentVersion}`);
+    logger.log(`[${this.roomId}] Version capability: `, versionCap);
+    const result = {
       version: currentVersion,
       needsUpgrade: false,
       urgent: false
@@ -488,7 +522,7 @@ export class Room extends ReadReceipt {
 
     // If the room is on the default version then nothing needs to change
     if (currentVersion === versionCap.default) return result;
-    var stableVersions = Object.keys(versionCap.available).filter(v => versionCap.available[v] === "stable");
+    const stableVersions = Object.keys(versionCap.available).filter(v => versionCap.available[v] === "stable");
 
     // Check if the room is on an unstable version. We determine urgency based
     // off the version being in the Matrix spec namespace or not (if the version
@@ -498,9 +532,9 @@ export class Room extends ReadReceipt {
       result.needsUpgrade = true;
       result.urgent = !!this.getVersion().match(/^[0-9]+[0-9.]*$/g);
       if (result.urgent) {
-        logger.warn("URGENT upgrade required on ".concat(this.roomId));
+        logger.warn(`URGENT upgrade required on ${this.roomId}`);
       } else {
-        logger.warn("Non-urgent upgrade required on ".concat(this.roomId));
+        logger.warn(`Non-urgent upgrade required on ${this.roomId}`);
       }
       return result;
     }
@@ -543,7 +577,7 @@ export class Room extends ReadReceipt {
     if (!this.pendingEventList) {
       throw new Error("Cannot call removePendingEvent with pendingEventOrdering == " + this.opts.pendingEventOrdering);
     }
-    var removed = removeElement(this.pendingEventList, function (ev) {
+    const removed = removeElement(this.pendingEventList, function (ev) {
       return ev.getId() == eventId;
     }, false);
     this.savePendingEvents();
@@ -557,8 +591,7 @@ export class Room extends ReadReceipt {
    * @param eventId - The event ID to check for.
    */
   hasPendingEvent(eventId) {
-    var _this$pendingEventLis, _this$pendingEventLis2;
-    return (_this$pendingEventLis = (_this$pendingEventLis2 = this.pendingEventList) === null || _this$pendingEventLis2 === void 0 ? void 0 : _this$pendingEventLis2.some(event => event.getId() === eventId)) !== null && _this$pendingEventLis !== void 0 ? _this$pendingEventLis : false;
+    return this.pendingEventList?.some(event => event.getId() === eventId) ?? false;
   }
 
   /**
@@ -567,8 +600,7 @@ export class Room extends ReadReceipt {
    * @param eventId - The event ID to check for.
    */
   getPendingEvent(eventId) {
-    var _this$pendingEventLis3, _this$pendingEventLis4;
-    return (_this$pendingEventLis3 = (_this$pendingEventLis4 = this.pendingEventList) === null || _this$pendingEventLis4 === void 0 ? void 0 : _this$pendingEventLis4.find(event => event.getId() === eventId)) !== null && _this$pendingEventLis3 !== void 0 ? _this$pendingEventLis3 : null;
+    return this.pendingEventList?.find(event => event.getId() === eventId) ?? null;
   }
 
   /**
@@ -596,10 +628,10 @@ export class Room extends ReadReceipt {
    * @returns the timestamp of the last message in the room
    */
   getLastActiveTimestamp() {
-    var timeline = this.getLiveTimeline();
-    var events = timeline.getEvents();
+    const timeline = this.getLiveTimeline();
+    const events = timeline.getEvents();
     if (events.length) {
-      var lastEvent = events[events.length - 1];
+      const lastEvent = events[events.length - 1];
       return lastEvent.getTs();
     } else {
       return Number.MIN_SAFE_INTEGER;
@@ -617,13 +649,12 @@ export class Room extends ReadReceipt {
    * @returns MatrixEvent if there is a last event; else undefined.
    */
   getLastLiveEvent() {
-    var _lastRoomEvent$getTs, _lastThreadEvent$getT;
-    var roomEvents = this.getLiveTimeline().getEvents();
-    var lastRoomEvent = roomEvents[roomEvents.length - 1];
-    var lastThread = this.getLastThread();
+    const roomEvents = this.getLiveTimeline().getEvents();
+    const lastRoomEvent = roomEvents[roomEvents.length - 1];
+    const lastThread = this.getLastThread();
     if (!lastThread) return lastRoomEvent;
-    var lastThreadEvent = lastThread.events[lastThread.events.length - 1];
-    return ((_lastRoomEvent$getTs = lastRoomEvent === null || lastRoomEvent === void 0 ? void 0 : lastRoomEvent.getTs()) !== null && _lastRoomEvent$getTs !== void 0 ? _lastRoomEvent$getTs : 0) > ((_lastThreadEvent$getT = lastThreadEvent === null || lastThreadEvent === void 0 ? void 0 : lastThreadEvent.getTs()) !== null && _lastThreadEvent$getT !== void 0 ? _lastThreadEvent$getT : 0) ? lastRoomEvent : lastThreadEvent;
+    const lastThreadEvent = lastThread.events[lastThread.events.length - 1];
+    return (lastRoomEvent?.getTs() ?? 0) > (lastThreadEvent?.getTs() ?? 0) ? lastRoomEvent : lastThreadEvent;
   }
 
   /**
@@ -637,11 +668,10 @@ export class Room extends ReadReceipt {
    */
   getLastThread() {
     return this.getThreads().reduce((lastThread, thread) => {
-      var _threadEvent$getTs, _lastThreadEvent$getT2;
       if (!lastThread) return thread;
-      var threadEvent = thread.events[thread.events.length - 1];
-      var lastThreadEvent = lastThread.events[lastThread.events.length - 1];
-      if (((_threadEvent$getTs = threadEvent === null || threadEvent === void 0 ? void 0 : threadEvent.getTs()) !== null && _threadEvent$getTs !== void 0 ? _threadEvent$getTs : 0) >= ((_lastThreadEvent$getT2 = lastThreadEvent === null || lastThreadEvent === void 0 ? void 0 : lastThreadEvent.getTs()) !== null && _lastThreadEvent$getT2 !== void 0 ? _lastThreadEvent$getT2 : 0)) {
+      const threadEvent = thread.events[thread.events.length - 1];
+      const lastThreadEvent = lastThread.events[lastThread.events.length - 1];
+      if ((threadEvent?.getTs() ?? 0) >= (lastThreadEvent?.getTs() ?? 0)) {
         // Last message of current thread is newer → new last thread.
         // Equal also means newer, because it was added to the thread map later.
         return thread;
@@ -654,8 +684,7 @@ export class Room extends ReadReceipt {
    * @returns the membership type (join | leave | invite | knock) for the logged in user
    */
   getMyMembership() {
-    var _this$selfMembership;
-    return (_this$selfMembership = this.selfMembership) !== null && _this$selfMembership !== void 0 ? _this$selfMembership : KnownMembership.Leave;
+    return this.selfMembership ?? KnownMembership.Leave;
   }
 
   /**
@@ -664,16 +693,15 @@ export class Room extends ReadReceipt {
    * @returns user id of the inviter
    */
   getDMInviter() {
-    var me = this.getMember(this.myUserId);
+    const me = this.getMember(this.myUserId);
     if (me) {
       return me.getDMInviter();
     }
     if (this.selfMembership === KnownMembership.Invite) {
       // fall back to summary information
-      var memberCount = this.getInvitedAndJoinedMemberCount();
+      const memberCount = this.getInvitedAndJoinedMemberCount();
       if (memberCount === 2) {
-        var _this$heroes;
-        return (_this$heroes = this.heroes) === null || _this$heroes === void 0 || (_this$heroes = _this$heroes[0]) === null || _this$heroes === void 0 ? void 0 : _this$heroes.userId;
+        return this.heroes?.[0]?.userId;
       }
     }
   }
@@ -683,9 +711,9 @@ export class Room extends ReadReceipt {
    * @returns user id of the other member (could be syncing user)
    */
   guessDMUserId() {
-    var me = this.getMember(this.myUserId);
+    const me = this.getMember(this.myUserId);
     if (me) {
-      var inviterId = me.getDMInviter();
+      const inviterId = me.getDMInviter();
       if (inviterId) {
         return inviterId;
       }
@@ -694,8 +722,8 @@ export class Room extends ReadReceipt {
     if (Array.isArray(this.heroes) && this.heroes.length) {
       return this.heroes[0].userId;
     }
-    var members = this.currentState.getMembers();
-    var anyMember = members.find(m => m.userId !== this.myUserId);
+    const members = this.currentState.getMembers();
+    const anyMember = members.find(m => m.userId !== this.myUserId);
     if (anyMember) {
       return anyMember.userId;
     }
@@ -714,18 +742,17 @@ export class Room extends ReadReceipt {
    * @see https://github.com/element-hq/element-meta/blob/develop/spec/functional_members.md.
    */
   getFunctionalMembers() {
-    var mFunctionalMembers = this.currentState.getStateEvents(UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, "");
-    if (Array.isArray(mFunctionalMembers === null || mFunctionalMembers === void 0 ? void 0 : mFunctionalMembers.getContent().service_members)) {
+    const mFunctionalMembers = this.currentState.getStateEvents(UNSTABLE_ELEMENT_FUNCTIONAL_USERS.name, "");
+    if (Array.isArray(mFunctionalMembers?.getContent().service_members)) {
       return mFunctionalMembers.getContent().service_members;
     }
     return [];
   }
   getAvatarFallbackMember() {
-    var _this$heroes2;
-    var functionalMembers = this.getFunctionalMembers();
+    const functionalMembers = this.getFunctionalMembers();
 
     // Only generate a fallback avatar if the conversation is with a single specific other user (a "DM").
-    var nonFunctionalMemberCount = 0;
+    let nonFunctionalMemberCount = 0;
     this.getMembers().forEach(m => {
       if (m.membership !== "join" && m.membership !== "invite") return;
       if (functionalMembers.includes(m.userId)) return;
@@ -734,17 +761,17 @@ export class Room extends ReadReceipt {
     if (nonFunctionalMemberCount > 2) return;
 
     // Prefer the list of heroes, if present. It should only include the single other user in the DM.
-    var nonFunctionalHeroes = (_this$heroes2 = this.heroes) === null || _this$heroes2 === void 0 ? void 0 : _this$heroes2.filter(h => !functionalMembers.includes(h.userId));
-    var hasHeroes = Array.isArray(nonFunctionalHeroes) && nonFunctionalHeroes.length;
+    const nonFunctionalHeroes = this.heroes?.filter(h => !functionalMembers.includes(h.userId));
+    const hasHeroes = Array.isArray(nonFunctionalHeroes) && nonFunctionalHeroes.length;
     if (hasHeroes) {
       // use first hero that has a display name or avatar url, or whose user ID
       // can be looked up as a member of the room
-      for (var hero of nonFunctionalHeroes) {
+      for (const hero of nonFunctionalHeroes) {
         // If the hero was from a legacy sync (`/v3/sync`), we will need to look the user ID up in the room
         // the display name and avatar URL will not be set.
         if (!hero.fromMSC4186) {
           // attempt to look up renderable fields from the m.room.member event if it exists
-          var member = this.getMember(hero.userId);
+          const member = this.getMember(hero.userId);
           if (member) {
             return member;
           }
@@ -753,7 +780,7 @@ export class Room extends ReadReceipt {
           // TODO: It's unfortunate that this function, which clearly only cares about the
           //       avatar url, returns the entire RoomMember event. We need to fake an event
           //       to meet this API shape.
-          var heroMember = new RoomMember(this.roomId, hero.userId);
+          const heroMember = new RoomMember(this.roomId, hero.userId);
           // set the display name and avatar url
           heroMember.setMembershipEvent(new MatrixEvent({
             // ensure it's unique even if we hit the same millisecond
@@ -768,7 +795,7 @@ export class Room extends ReadReceipt {
           return heroMember;
         }
       }
-      var availableMember = nonFunctionalHeroes.map(hero => {
+      const availableMember = nonFunctionalHeroes.map(hero => {
         return this.getMember(hero.userId);
       }).find(member => !!member);
       if (availableMember) {
@@ -778,27 +805,27 @@ export class Room extends ReadReceipt {
 
     // Consider *all*, including previous, members, to generate the avatar for DMs where the other user left.
     // Needed to generate a matching avatar for rooms named "Empty Room (was Alice)".
-    var members = this.getMembers();
-    var nonFunctionalMembers = members === null || members === void 0 ? void 0 : members.filter(m => !functionalMembers.includes(m.userId));
+    const members = this.getMembers();
+    const nonFunctionalMembers = members?.filter(m => !functionalMembers.includes(m.userId));
     if (nonFunctionalMembers.length <= 2) {
-      var _availableMember = nonFunctionalMembers.find(m => {
+      const availableMember = nonFunctionalMembers.find(m => {
         return m.userId !== this.myUserId;
       });
-      if (_availableMember) {
-        return _availableMember;
+      if (availableMember) {
+        return availableMember;
       }
     }
 
     // If all else failed, but the homeserver gave us heroes that previously could not be found in the room members,
     // trust and try falling back to a hero, creating a one-off member for it
     if (hasHeroes) {
-      var availableUser = nonFunctionalHeroes.map(hero => {
+      const availableUser = nonFunctionalHeroes.map(hero => {
         return this.client.getUser(hero.userId);
       }).find(user => !!user);
       if (availableUser) {
-        var _member = new RoomMember(this.roomId, availableUser.userId);
-        _member.user = availableUser;
-        return _member;
+        const member = new RoomMember(this.roomId, availableUser.userId);
+        member.user = availableUser;
+        return member;
       }
     }
   }
@@ -808,7 +835,7 @@ export class Room extends ReadReceipt {
    * @param membership - join | leave | invite
    */
   updateMyMembership(membership) {
-    var prevMembership = this.selfMembership;
+    const prevMembership = this.selfMembership;
     this.selfMembership = membership;
     if (prevMembership !== membership) {
       if (membership === KnownMembership.Leave) {
@@ -817,36 +844,30 @@ export class Room extends ReadReceipt {
       this.emit(RoomEvent.MyMembership, this, membership, prevMembership);
     }
   }
-  loadMembersFromServer() {
-    var _this6 = this;
-    return _asyncToGenerator(function* () {
-      var lastSyncToken = _this6.client.store.getSyncToken();
-      var response = yield _this6.client.members(_this6.roomId, undefined, KnownMembership.Leave, lastSyncToken !== null && lastSyncToken !== void 0 ? lastSyncToken : undefined);
-      return response.chunk;
-    })();
-  }
-  loadMembers() {
-    var _this7 = this;
-    return _asyncToGenerator(function* () {
-      // were the members loaded from the server?
-      var fromServer = false;
-      var rawMembersEvents = yield _this7.client.store.getOutOfBandMembers(_this7.roomId);
-      // If the room is encrypted, we always fetch members from the server at
-      // least once, in case the latest state wasn't persisted properly. Note
-      // that this function is only called once (unless loading the members
-      // fails), since loadMembersIfNeeded always returns this.membersPromise
-      // if set, which will be the result of the first (successful) call.
-      if (rawMembersEvents === null || _this7.hasEncryptionStateEvent()) {
-        fromServer = true;
-        rawMembersEvents = yield _this7.loadMembersFromServer();
-        logger.log("LL: got ".concat(rawMembersEvents.length, " ") + "members from server for room ".concat(_this7.roomId));
-      }
-      var memberEvents = rawMembersEvents.filter(noUnsafeEventProps).map(_this7.client.getEventMapper());
-      return {
-        memberEvents,
-        fromServer
-      };
-    })();
+  async loadMembersFromServer() {
+    const lastSyncToken = this.client.store.getSyncToken();
+    const response = await this.client.members(this.roomId, undefined, KnownMembership.Leave, lastSyncToken ?? undefined);
+    return response.chunk;
+  }
+  async loadMembers() {
+    // were the members loaded from the server?
+    let fromServer = false;
+    let rawMembersEvents = await this.client.store.getOutOfBandMembers(this.roomId);
+    // If the room is encrypted, we always fetch members from the server at
+    // least once, in case the latest state wasn't persisted properly. Note
+    // that this function is only called once (unless loading the members
+    // fails), since loadMembersIfNeeded always returns this.membersPromise
+    // if set, which will be the result of the first (successful) call.
+    if (rawMembersEvents === null || this.hasEncryptionStateEvent()) {
+      fromServer = true;
+      rawMembersEvents = await this.loadMembersFromServer();
+      logger.log(`LL: got ${rawMembersEvents.length} ` + `members from server for room ${this.roomId}`);
+    }
+    const memberEvents = rawMembersEvents.filter(noUnsafeEventProps).map(this.client.getEventMapper());
+    return {
+      memberEvents,
+      fromServer
+    };
   }
 
   /**
@@ -879,7 +900,7 @@ export class Room extends ReadReceipt {
     // the request is in flight get marked as superseding
     // the OOB members
     this.currentState.markOutOfBandMembersStarted();
-    var inMemoryUpdate = this.loadMembers().then(result => {
+    const inMemoryUpdate = this.loadMembers().then(result => {
       this.currentState.setOutOfBandMembers(result.memberEvents);
       // recalculate the room name: it may have been based on members, so may have changed
       this.recalculate();
@@ -893,12 +914,9 @@ export class Room extends ReadReceipt {
     // update members in storage, but don't wait for it
     inMemoryUpdate.then(fromServer => {
       if (fromServer) {
-        var oobMembers = this.currentState.getMembers().filter(m => m.isOutOfBand()).map(m => {
-          var _m$events$member;
-          return (_m$events$member = m.events.member) === null || _m$events$member === void 0 ? void 0 : _m$events$member.event;
-        });
-        logger.log("LL: telling store to write ".concat(oobMembers.length) + " members for room ".concat(this.roomId));
-        var store = this.client.store;
+        const oobMembers = this.currentState.getMembers().filter(m => m.isOutOfBand()).map(m => m.events.member?.event);
+        logger.log(`LL: telling store to write ${oobMembers.length}` + ` members for room ${this.roomId}`);
+        const store = this.client.store;
         return store.setOutOfBandMembers(this.roomId, oobMembers)
         // swallow any IDB error as we don't want to fail
         // because of this
@@ -918,16 +936,13 @@ export class Room extends ReadReceipt {
   /**
    * Removes the lazily loaded members from storage if needed
    */
-  clearLoadedMembersIfNeeded() {
-    var _this8 = this;
-    return _asyncToGenerator(function* () {
-      if (_this8.opts.lazyLoadMembers && _this8.membersPromise) {
-        yield _this8.loadMembersIfNeeded();
-        yield _this8.client.store.clearOutOfBandMembers(_this8.roomId);
-        _this8.currentState.clearOutOfBandMembers();
-        _this8.membersPromise = undefined;
-      }
-    })();
+  async clearLoadedMembersIfNeeded() {
+    if (this.opts.lazyLoadMembers && this.membersPromise) {
+      await this.loadMembersIfNeeded();
+      await this.client.store.clearOutOfBandMembers(this.roomId);
+      this.currentState.clearOutOfBandMembers();
+      this.membersPromise = undefined;
+    }
   }
 
   /**
@@ -936,7 +951,7 @@ export class Room extends ReadReceipt {
    */
   cleanupAfterLeaving() {
     this.clearLoadedMembersIfNeeded().catch(err => {
-      logger.error("error after clearing loaded members from " + "room ".concat(this.roomId, " after leaving"));
+      logger.error(`error after clearing loaded members from ` + `room ${this.roomId} after leaving`);
       logger.log(err);
     });
   }
@@ -954,81 +969,78 @@ export class Room extends ReadReceipt {
    * valid marker and can check the needs refresh status via
    * `room.getTimelineNeedsRefresh()`.
    */
-  refreshLiveTimeline() {
-    var _this9 = this;
-    return _asyncToGenerator(function* () {
-      var liveTimelineBefore = _this9.getLiveTimeline();
-      var forwardPaginationToken = liveTimelineBefore.getPaginationToken(EventTimeline.FORWARDS);
-      var backwardPaginationToken = liveTimelineBefore.getPaginationToken(EventTimeline.BACKWARDS);
-      var eventsBefore = liveTimelineBefore.getEvents();
-      var mostRecentEventInTimeline = eventsBefore[eventsBefore.length - 1];
-      logger.log("[refreshLiveTimeline for ".concat(_this9.roomId, "] at ") + "mostRecentEventInTimeline=".concat(mostRecentEventInTimeline && mostRecentEventInTimeline.getId(), " ") + "liveTimelineBefore=".concat(liveTimelineBefore.toString(), " ") + "forwardPaginationToken=".concat(forwardPaginationToken, " ") + "backwardPaginationToken=".concat(backwardPaginationToken));
-
-      // Get the main TimelineSet
-      var timelineSet = _this9.getUnfilteredTimelineSet();
-      var newTimeline = null;
-      // If there isn't any event in the timeline, let's go fetch the latest
-      // event and construct a timeline from it.
-      //
-      // This should only really happen if the user ran into an error
-      // with refreshing the timeline before which left them in a blank
-      // timeline from `resetLiveTimeline`.
-      if (!mostRecentEventInTimeline) {
-        newTimeline = yield _this9.client.getLatestTimeline(timelineSet);
-      } else {
-        // Empty out all of `this.timelineSets`. But we also need to keep the
-        // same `timelineSet` references around so the React code updates
-        // properly and doesn't ignore the room events we emit because it checks
-        // that the `timelineSet` references are the same. We need the
-        // `timelineSet` empty so that the `client.getEventTimeline(...)` call
-        // later, will call `/context` and create a new timeline instead of
-        // returning the same one.
-        _this9.resetLiveTimeline(null, null);
-
-        // Make the UI timeline show the new blank live timeline we just
-        // reset so that if the network fails below it's showing the
-        // accurate state of what we're working with instead of the
-        // disconnected one in the TimelineWindow which is just hanging
-        // around by reference.
-        _this9.emit(RoomEvent.TimelineRefresh, _this9, timelineSet);
-
-        // Use `client.getEventTimeline(...)` to construct a new timeline from a
-        // `/context` response state and events for the most recent event before
-        // we reset everything. The `timelineSet` we pass in needs to be empty
-        // in order for this function to call `/context` and generate a new
-        // timeline.
-        newTimeline = yield _this9.client.getEventTimeline(timelineSet, mostRecentEventInTimeline.getId());
-      }
-
-      // If a racing `/sync` beat us to creating a new timeline, use that
-      // instead because it's the latest in the room and any new messages in
-      // the scrollback will include the history.
-      var liveTimeline = timelineSet.getLiveTimeline();
-      if (!liveTimeline || liveTimeline.getPaginationToken(Direction.Forward) === null && liveTimeline.getPaginationToken(Direction.Backward) === null && liveTimeline.getEvents().length === 0) {
-        logger.log("[refreshLiveTimeline for ".concat(_this9.roomId, "] using our new live timeline"));
-        // Set the pagination token back to the live sync token (`null`) instead
-        // of using the `/context` historical token (ex. `t12-13_0_0_0_0_0_0_0_0`)
-        // so that it matches the next response from `/sync` and we can properly
-        // continue the timeline.
-        newTimeline.setPaginationToken(forwardPaginationToken, EventTimeline.FORWARDS);
-
-        // Set our new fresh timeline as the live timeline to continue syncing
-        // forwards and back paginating from.
-        timelineSet.setLiveTimeline(newTimeline);
-        // Fixup `this.oldstate` so that `scrollback` has the pagination tokens
-        // available
-        _this9.fixUpLegacyTimelineFields();
-      } else {
-        logger.log("[refreshLiveTimeline for ".concat(_this9.roomId, "] `/sync` or some other request beat us to creating a new ") + "live timeline after we reset it. We'll use that instead since any events in the scrollback from " + "this timeline will include the history.");
-      }
+  async refreshLiveTimeline() {
+    const liveTimelineBefore = this.getLiveTimeline();
+    const forwardPaginationToken = liveTimelineBefore.getPaginationToken(EventTimeline.FORWARDS);
+    const backwardPaginationToken = liveTimelineBefore.getPaginationToken(EventTimeline.BACKWARDS);
+    const eventsBefore = liveTimelineBefore.getEvents();
+    const mostRecentEventInTimeline = eventsBefore[eventsBefore.length - 1];
+    logger.log(`[refreshLiveTimeline for ${this.roomId}] at ` + `mostRecentEventInTimeline=${mostRecentEventInTimeline && mostRecentEventInTimeline.getId()} ` + `liveTimelineBefore=${liveTimelineBefore.toString()} ` + `forwardPaginationToken=${forwardPaginationToken} ` + `backwardPaginationToken=${backwardPaginationToken}`);
+
+    // Get the main TimelineSet
+    const timelineSet = this.getUnfilteredTimelineSet();
+    let newTimeline = null;
+    // If there isn't any event in the timeline, let's go fetch the latest
+    // event and construct a timeline from it.
+    //
+    // This should only really happen if the user ran into an error
+    // with refreshing the timeline before which left them in a blank
+    // timeline from `resetLiveTimeline`.
+    if (!mostRecentEventInTimeline) {
+      newTimeline = await this.client.getLatestTimeline(timelineSet);
+    } else {
+      // Empty out all of `this.timelineSets`. But we also need to keep the
+      // same `timelineSet` references around so the React code updates
+      // properly and doesn't ignore the room events we emit because it checks
+      // that the `timelineSet` references are the same. We need the
+      // `timelineSet` empty so that the `client.getEventTimeline(...)` call
+      // later, will call `/context` and create a new timeline instead of
+      // returning the same one.
+      this.resetLiveTimeline(null, null);
+
+      // Make the UI timeline show the new blank live timeline we just
+      // reset so that if the network fails below it's showing the
+      // accurate state of what we're working with instead of the
+      // disconnected one in the TimelineWindow which is just hanging
+      // around by reference.
+      this.emit(RoomEvent.TimelineRefresh, this, timelineSet);
+
+      // Use `client.getEventTimeline(...)` to construct a new timeline from a
+      // `/context` response state and events for the most recent event before
+      // we reset everything. The `timelineSet` we pass in needs to be empty
+      // in order for this function to call `/context` and generate a new
+      // timeline.
+      newTimeline = await this.client.getEventTimeline(timelineSet, mostRecentEventInTimeline.getId());
+    }
+
+    // If a racing `/sync` beat us to creating a new timeline, use that
+    // instead because it's the latest in the room and any new messages in
+    // the scrollback will include the history.
+    const liveTimeline = timelineSet.getLiveTimeline();
+    if (!liveTimeline || liveTimeline.getPaginationToken(Direction.Forward) === null && liveTimeline.getPaginationToken(Direction.Backward) === null && liveTimeline.getEvents().length === 0) {
+      logger.log(`[refreshLiveTimeline for ${this.roomId}] using our new live timeline`);
+      // Set the pagination token back to the live sync token (`null`) instead
+      // of using the `/context` historical token (ex. `t12-13_0_0_0_0_0_0_0_0`)
+      // so that it matches the next response from `/sync` and we can properly
+      // continue the timeline.
+      newTimeline.setPaginationToken(forwardPaginationToken, EventTimeline.FORWARDS);
+
+      // Set our new fresh timeline as the live timeline to continue syncing
+      // forwards and back paginating from.
+      timelineSet.setLiveTimeline(newTimeline);
+      // Fixup `this.oldstate` so that `scrollback` has the pagination tokens
+      // available
+      this.fixUpLegacyTimelineFields();
+    } else {
+      logger.log(`[refreshLiveTimeline for ${this.roomId}] \`/sync\` or some other request beat us to creating a new ` + `live timeline after we reset it. We'll use that instead since any events in the scrollback from ` + `this timeline will include the history.`);
+    }
 
-      // The timeline has now been refreshed ✅
-      _this9.setTimelineNeedsRefresh(false);
+    // The timeline has now been refreshed ✅
+    this.setTimelineNeedsRefresh(false);
 
-      // Emit an event which clients can react to and re-load the timeline
-      // from the SDK
-      _this9.emit(RoomEvent.TimelineRefresh, _this9, timelineSet);
-    })();
+    // Emit an event which clients can react to and re-load the timeline
+    // from the SDK
+    this.emit(RoomEvent.TimelineRefresh, this, timelineSet);
   }
 
   /**
@@ -1043,10 +1055,10 @@ export class Room extends ReadReceipt {
    * Removing just the old live timeline whilst preserving previous ones is not supported.
    */
   resetLiveTimeline(backPaginationToken, forwardPaginationToken) {
-    for (var timelineSet of this.timelineSets) {
-      timelineSet.resetLiveTimeline(backPaginationToken !== null && backPaginationToken !== void 0 ? backPaginationToken : undefined, forwardPaginationToken !== null && forwardPaginationToken !== void 0 ? forwardPaginationToken : undefined);
+    for (const timelineSet of this.timelineSets) {
+      timelineSet.resetLiveTimeline(backPaginationToken ?? undefined, forwardPaginationToken ?? undefined);
     }
-    for (var thread of this.threads.values()) {
+    for (const thread of this.threads.values()) {
       thread.resetLiveTimeline(backPaginationToken, forwardPaginationToken);
     }
     this.fixUpLegacyTimelineFields();
@@ -1058,8 +1070,8 @@ export class Room extends ReadReceipt {
    * @internal
    */
   fixUpLegacyTimelineFields() {
-    var previousOldState = this.oldState;
-    var previousCurrentState = this.currentState;
+    const previousOldState = this.oldState;
+    const previousCurrentState = this.currentState;
 
     // maintain this.oldState and this.currentState as references to the
     // state at the start and end of that timeline. These are more
@@ -1083,11 +1095,6 @@ export class Room extends ReadReceipt {
       this.reEmitter.reEmit(this.currentState, [RoomStateEvent.Events, RoomStateEvent.Members, RoomStateEvent.NewMember, RoomStateEvent.Update, RoomStateEvent.Marker, BeaconEvent.New, BeaconEvent.Update, BeaconEvent.Destroy, BeaconEvent.LivenessChange]);
     }
   }
-  onReceipt(event) {
-    if (this.hasEncryptionStateEvent()) {
-      this.clearNotificationsOnReceipt(event);
-    }
-  }
   clearNotificationsOnReceipt(event) {
     // Like above, we have to listen for read receipts from ourselves in order to
     // correctly handle notification counts on encrypted rooms.
@@ -1097,22 +1104,16 @@ export class Room extends ReadReceipt {
     // We need to work out what threads we've just recieved receipts for, so we
     // know which ones to update. If we've received an unthreaded receipt, we'll
     // need to update all threads.
-    var threadIds = [];
-    var hasUnthreadedReceipt = false;
-    var content = event.getContent();
-    for (var receiptGroup of Object.values(content)) {
-      for (var _ref4 of Object.entries(receiptGroup)) {
-        var _ref3 = _slicedToArray(_ref4, 2);
-        var receiptType = _ref3[0];
-        var userReceipt = _ref3[1];
+    let threadIds = [];
+    let hasUnthreadedReceipt = false;
+    const content = event.getContent();
+    for (const receiptGroup of Object.values(content)) {
+      for (const [receiptType, userReceipt] of Object.entries(receiptGroup)) {
         if (!utils.isSupportedReceiptType(receiptType)) continue;
         if (!userReceipt) continue;
-        for (var _ref7 of Object.entries(userReceipt)) {
-          var _ref6 = _slicedToArray(_ref7, 2);
-          var userId = _ref6[0];
-          var singleReceipt = _ref6[1];
+        for (const [userId, singleReceipt] of Object.entries(userReceipt)) {
           if (!singleReceipt || typeof singleReceipt !== "object") continue;
-          var typedSingleReceipt = singleReceipt;
+          const typedSingleReceipt = singleReceipt;
           if (userId !== this.client.getUserId()) continue;
           if (typedSingleReceipt.thread_id === undefined) {
             hasUnthreadedReceipt = true;
@@ -1129,30 +1130,28 @@ export class Room extends ReadReceipt {
       threadIds = this.getThreads().filter(thread => this.getThreadUnreadNotificationCount(thread.id, NotificationCountType.Total) > 0 || this.getThreadUnreadNotificationCount(thread.id, NotificationCountType.Highlight) > 0).map(thread => thread.id);
       threadIds.push("main");
     }
-    for (var threadId of threadIds) {
-      var _this$getThread;
+    for (const threadId of threadIds) {
       // Work backwards to determine how many events are unread. We also set
       // a limit for how back we'll look to avoid spinning CPU for too long.
       // If we hit the limit, we assume the count is unchanged.
-      var maxHistory = 20;
-      var timeline = threadId === "main" ? this.getLiveTimeline() : (_this$getThread = this.getThread(threadId)) === null || _this$getThread === void 0 ? void 0 : _this$getThread.liveTimeline;
+      const maxHistory = 20;
+      const timeline = threadId === "main" ? this.getLiveTimeline() : this.getThread(threadId)?.liveTimeline;
       if (!timeline) {
-        logger.warn("Couldn't find timeline for thread ID ".concat(threadId, " in room ").concat(this.roomId));
+        logger.warn(`Couldn't find timeline for thread ID ${threadId} in room ${this.roomId}`);
         continue;
       }
-      var events = timeline.getEvents();
-      var highlightCount = 0;
-      for (var i = events.length - 1; i >= 0; i--) {
-        var _pushActions$tweaks;
+      const events = timeline.getEvents();
+      let highlightCount = 0;
+      for (let i = events.length - 1; i >= 0; i--) {
         if (i === events.length - maxHistory) return; // limit reached
 
-        var _event = events[i];
-        if (this.hasUserReadEvent(this.client.getUserId(), _event.getId())) {
+        const event = events[i];
+        if (this.hasUserReadEvent(this.client.getUserId(), event.getId())) {
           // If the user has read the event, then the counting is done.
           break;
         }
-        var pushActions = this.client.getPushActionsForEvent(_event);
-        highlightCount += pushActions !== null && pushActions !== void 0 && (_pushActions$tweaks = pushActions.tweaks) !== null && _pushActions$tweaks !== void 0 && _pushActions$tweaks.highlight ? 1 : 0;
+        const pushActions = this.client.getPushActionsForEvent(event);
+        highlightCount += pushActions?.tweaks?.highlight ? 1 : 0;
       }
 
       // Note: we don't need to handle 'total' notifications because the counts
@@ -1189,8 +1188,8 @@ export class Room extends ReadReceipt {
    * the given event, or null if unknown
    */
   getTimelineForEvent(eventId) {
-    var event = this.findEventById(eventId);
-    var thread = this.findThreadForEvent(event);
+    const event = this.findEventById(eventId);
+    const thread = this.findThreadForEvent(event);
     if (thread) {
       return thread.timelineSet.getTimelineForEvent(eventId);
     } else {
@@ -1232,11 +1231,11 @@ export class Room extends ReadReceipt {
    * @returns the given event, or undefined if unknown
    */
   findEventById(eventId) {
-    var event = this.getUnfilteredTimelineSet().findEventById(eventId);
+    let event = this.getUnfilteredTimelineSet().findEventById(eventId);
     if (!event) {
-      var threads = this.getThreads();
-      for (var i = 0; i < threads.length; i++) {
-        var thread = threads[i];
+      const threads = this.getThreads();
+      for (let i = 0; i < threads.length; i++) {
+        const thread = threads[i];
         event = thread.findEventById(eventId);
         if (event) {
           return event;
@@ -1252,12 +1251,10 @@ export class Room extends ReadReceipt {
    * @returns The notification count, or undefined if there is no count
    *                  for this type.
    */
-  getUnreadNotificationCount() {
-    var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : NotificationCountType.Total;
-    var count = this.getRoomUnreadNotificationCount(type);
-    for (var threadNotification of this.threadNotifications.values()) {
-      var _threadNotification$t;
-      count += (_threadNotification$t = threadNotification[type]) !== null && _threadNotification$t !== void 0 ? _threadNotification$t : 0;
+  getUnreadNotificationCount(type = NotificationCountType.Total) {
+    let count = this.getRoomUnreadNotificationCount(type);
+    for (const threadNotification of this.threadNotifications.values()) {
+      count += threadNotification[type] ?? 0;
     }
     return count;
   }
@@ -1265,12 +1262,9 @@ export class Room extends ReadReceipt {
   /**
    * Get the notification for the event context (room or thread timeline)
    */
-  getUnreadCountForEventContext() {
-    var _ref8;
-    var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : NotificationCountType.Total;
-    var event = arguments.length > 1 ? arguments[1] : undefined;
-    var isThreadEvent = !!event.threadRootId && !event.isThreadRoot;
-    return (_ref8 = isThreadEvent ? this.getThreadUnreadNotificationCount(event.threadRootId, type) : this.getRoomUnreadNotificationCount(type)) !== null && _ref8 !== void 0 ? _ref8 : 0;
+  getUnreadCountForEventContext(type = NotificationCountType.Total, event) {
+    const isThreadEvent = !!event.threadRootId && !event.isThreadRoot;
+    return (isThreadEvent ? this.getThreadUnreadNotificationCount(event.threadRootId, type) : this.getRoomUnreadNotificationCount(type)) ?? 0;
   }
 
   /**
@@ -1279,10 +1273,8 @@ export class Room extends ReadReceipt {
    * @returns The notification count, or undefined if there is no count
    *                  for this type.
    */
-  getRoomUnreadNotificationCount() {
-    var _this$notificationCou;
-    var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : NotificationCountType.Total;
-    return (_this$notificationCou = this.notificationCounts[type]) !== null && _this$notificationCou !== void 0 ? _this$notificationCou : 0;
+  getRoomUnreadNotificationCount(type = NotificationCountType.Total) {
+    return this.notificationCounts[type] ?? 0;
   }
 
   /**
@@ -1292,10 +1284,8 @@ export class Room extends ReadReceipt {
    * @returns The notification count, or undefined if there is no count
    *          for this type.
    */
-  getThreadUnreadNotificationCount(threadId) {
-    var _this$threadNotificat, _this$threadNotificat2;
-    var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : NotificationCountType.Total;
-    return (_this$threadNotificat = (_this$threadNotificat2 = this.threadNotifications.get(threadId)) === null || _this$threadNotificat2 === void 0 ? void 0 : _this$threadNotificat2[type]) !== null && _this$threadNotificat !== void 0 ? _this$threadNotificat : 0;
+  getThreadUnreadNotificationCount(threadId, type = NotificationCountType.Total) {
+    return this.threadNotifications.get(threadId)?.[type] ?? 0;
   }
 
   /**
@@ -1303,9 +1293,8 @@ export class Room extends ReadReceipt {
    * @returns
    */
   hasThreadUnreadNotification() {
-    for (var notification of this.threadNotifications.values()) {
-      var _notification$highlig, _notification$total;
-      if (((_notification$highlig = notification.highlight) !== null && _notification$highlig !== void 0 ? _notification$highlig : 0) > 0 || ((_notification$total = notification.total) !== null && _notification$total !== void 0 ? _notification$total : 0) > 0) {
+    for (const notification of this.threadNotifications.values()) {
+      if ((notification.highlight ?? 0) > 0 || (notification.total ?? 0) > 0) {
         return true;
       }
     }
@@ -1319,13 +1308,11 @@ export class Room extends ReadReceipt {
    * @returns
    */
   setThreadUnreadNotificationCount(threadId, type, count) {
-    var _this$threadNotificat3, _this$threadNotificat4;
-    var notification = _objectSpread({
-      highlight: (_this$threadNotificat3 = this.threadNotifications.get(threadId)) === null || _this$threadNotificat3 === void 0 ? void 0 : _this$threadNotificat3.highlight,
-      total: (_this$threadNotificat4 = this.threadNotifications.get(threadId)) === null || _this$threadNotificat4 === void 0 ? void 0 : _this$threadNotificat4.total
-    }, {
+    const notification = {
+      highlight: this.threadNotifications.get(threadId)?.highlight,
+      total: this.threadNotifications.get(threadId)?.total,
       [type]: count
-    });
+    };
     this.threadNotifications.set(threadId, notification);
     this.emit(RoomEvent.UnreadNotifications, notification, threadId);
   }
@@ -1334,12 +1321,11 @@ export class Room extends ReadReceipt {
    * @returns the notification count type for all the threads in the room
    */
   get threadsAggregateNotificationType() {
-    var type = null;
-    for (var threadNotification of this.threadNotifications.values()) {
-      var _threadNotification$h, _threadNotification$t2;
-      if (((_threadNotification$h = threadNotification.highlight) !== null && _threadNotification$h !== void 0 ? _threadNotification$h : 0) > 0) {
+    let type = null;
+    for (const threadNotification of this.threadNotifications.values()) {
+      if ((threadNotification.highlight ?? 0) > 0) {
         return NotificationCountType.Highlight;
-      } else if (((_threadNotification$t2 = threadNotification.total) !== null && _threadNotification$t2 !== void 0 ? _threadNotification$t2 : 0) > 0 && !type) {
+      } else if ((threadNotification.total ?? 0) > 0 && !type) {
         type = NotificationCountType.Total;
       }
     }
@@ -1360,13 +1346,9 @@ export class Room extends ReadReceipt {
    *
    * @param exceptThreadIds - The thread IDs to exclude from the reset.
    */
-  resetThreadUnreadNotificationCountFromSync() {
-    var exceptThreadIds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    var isEncrypted = this.hasEncryptionStateEvent();
-    for (var _ref1 of this.threadNotifications) {
-      var _ref0 = _slicedToArray(_ref1, 2);
-      var threadId = _ref0[0];
-      var notifs = _ref0[1];
+  resetThreadUnreadNotificationCountFromSync(exceptThreadIds = []) {
+    const isEncrypted = this.hasEncryptionStateEvent();
+    for (const [threadId, notifs] of this.threadNotifications) {
       if (!exceptThreadIds.includes(threadId)) {
         notifs.total = 0;
         if (!isEncrypted) {
@@ -1414,13 +1396,12 @@ export class Room extends ReadReceipt {
    * @param summary - The room summary to update the room with
    */
   setSummary(summary) {
-    var _summary$mHeroes;
-    var heroes = (_summary$mHeroes = summary["m.heroes"]) === null || _summary$mHeroes === void 0 ? void 0 : _summary$mHeroes.map(h => ({
+    const heroes = summary["m.heroes"]?.map(h => ({
       userId: h,
       fromMSC4186: false
     }));
-    var joinedCount = summary["m.joined_member_count"];
-    var invitedCount = summary["m.invited_member_count"];
+    const joinedCount = summary["m.joined_member_count"];
+    const invitedCount = summary["m.invited_member_count"];
     if (Number.isInteger(joinedCount)) {
       this.currentState.setJoinedMemberCount(joinedCount);
     }
@@ -1504,10 +1485,8 @@ export class Room extends ReadReceipt {
    * implies allowRedirects. Defaults to false (unauthenticated endpoints).
    * @returns the avatar URL or null.
    */
-  getAvatarUrl(baseUrl, width, height, resizeMethod) {
-    var allowDefault = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
-    var useAuthentication = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
-    var mainUrl = this.getMxcAvatarUrl();
+  getAvatarUrl(baseUrl, width, height, resizeMethod, allowDefault = true, useAuthentication = false) {
+    const mainUrl = this.getMxcAvatarUrl();
     if (!mainUrl && !allowDefault) {
       return null;
     }
@@ -1522,8 +1501,7 @@ export class Room extends ReadReceipt {
    * @returns the mxc avatar url or falsy
    */
   getMxcAvatarUrl() {
-    var _this$currentState$ge;
-    var url = (_this$currentState$ge = this.currentState.getStateEvents(EventType.RoomAvatar, "")) === null || _this$currentState$ge === void 0 ? void 0 : _this$currentState$ge.getContent().url;
+    const url = this.currentState.getStateEvents(EventType.RoomAvatar, "")?.getContent().url;
     return url && typeof url === "string" ? url : null;
   }
 
@@ -1534,8 +1512,7 @@ export class Room extends ReadReceipt {
    * @returns The room's canonical alias, or null if there is none
    */
   getCanonicalAlias() {
-    var _this$currentState$ge2;
-    var canonicalAlias = (_this$currentState$ge2 = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, "")) === null || _this$currentState$ge2 === void 0 ? void 0 : _this$currentState$ge2.getContent().alias;
+    const canonicalAlias = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, "")?.getContent().alias;
     return canonicalAlias && typeof canonicalAlias === "string" ? canonicalAlias : null;
   }
 
@@ -1544,8 +1521,7 @@ export class Room extends ReadReceipt {
    * @returns The room's alternative aliases, or an empty array
    */
   getAltAliases() {
-    var _this$currentState$ge3;
-    var altAliases = (_this$currentState$ge3 = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, "")) === null || _this$currentState$ge3 === void 0 ? void 0 : _this$currentState$ge3.getContent().alt_aliases;
+    const altAliases = this.currentState.getStateEvents(EventType.RoomCanonicalAlias, "")?.getContent().alt_aliases;
     if (Array.isArray(altAliases)) {
       return altAliases.filter(alias => typeof alias === "string");
     }
@@ -1572,6 +1548,8 @@ export class Room extends ReadReceipt {
    * Fires {@link RoomEvent.Timeline}
    */
   addEventsToTimeline(events, toStartOfTimeline, addToState, timeline, paginationToken) {
+    // ALWAYS filter out any events that are past retention
+    events = events.filter(e => this.retention?.shouldEventBeRetained(e) ?? true);
     timeline.getTimelineSet().addEventsToTimeline(events, toStartOfTimeline, addToState, timeline, paginationToken);
   }
 
@@ -1581,8 +1559,7 @@ export class Room extends ReadReceipt {
    * @returns a thread instance if known
    */
   getThread(eventId) {
-    var _this$threads$get;
-    return (_this$threads$get = this.threads.get(eventId)) !== null && _this$threads$get !== void 0 ? _this$threads$get : null;
+    return this.threads.get(eventId) ?? null;
   }
 
   /**
@@ -1661,16 +1638,13 @@ export class Room extends ReadReceipt {
    * @returns A list of members who
    * we should encrypt messages for in this room.
    */
-  getEncryptionTargetMembers() {
-    var _this0 = this;
-    return _asyncToGenerator(function* () {
-      yield _this0.loadMembersIfNeeded();
-      var members = _this0.getMembersWithMembership(KnownMembership.Join);
-      if (_this0.shouldEncryptForInvitedMembers()) {
-        members = members.concat(_this0.getMembersWithMembership(KnownMembership.Invite));
-      }
-      return members;
-    })();
+  async getEncryptionTargetMembers() {
+    await this.loadMembersIfNeeded();
+    let members = this.getMembersWithMembership(KnownMembership.Join);
+    if (this.shouldEncryptForInvitedMembers()) {
+      members = members.concat(this.getMembersWithMembership(KnownMembership.Invite));
+    }
+    return members;
   }
 
   /**
@@ -1678,9 +1652,8 @@ export class Room extends ReadReceipt {
    * @returns if we should encrypt messages for invited users
    */
   shouldEncryptForInvitedMembers() {
-    var _ev$getContent;
-    var ev = this.currentState.getStateEvents(EventType.RoomHistoryVisibility, "");
-    return (ev === null || ev === void 0 || (_ev$getContent = ev.getContent()) === null || _ev$getContent === void 0 ? void 0 : _ev$getContent.history_visibility) !== "joined";
+    const ev = this.currentState.getStateEvents(EventType.RoomHistoryVisibility, "");
+    return ev?.getContent()?.history_visibility !== "joined";
   }
 
   /**
@@ -1701,7 +1674,7 @@ export class Room extends ReadReceipt {
    * @returns True if this user_id has the given membership state.
    */
   hasMembershipState(userId, membership) {
-    var member = this.getMember(userId);
+    const member = this.getMember(userId);
     if (!member) {
       return false;
     }
@@ -1714,28 +1687,25 @@ export class Room extends ReadReceipt {
    * @param opts - Configuration options
    * @returns The timelineSet
    */
-  getOrCreateFilteredTimelineSet(filter) {
-    var _ref10 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-      _ref10$prepopulateTim = _ref10.prepopulateTimeline,
-      prepopulateTimeline = _ref10$prepopulateTim === void 0 ? true : _ref10$prepopulateTim,
-      _ref10$useSyncEvents = _ref10.useSyncEvents,
-      useSyncEvents = _ref10$useSyncEvents === void 0 ? true : _ref10$useSyncEvents,
-      _ref10$pendingEvents = _ref10.pendingEvents,
-      pendingEvents = _ref10$pendingEvents === void 0 ? true : _ref10$pendingEvents;
+  getOrCreateFilteredTimelineSet(filter, {
+    prepopulateTimeline = true,
+    useSyncEvents = true,
+    pendingEvents = true
+  } = {}) {
     if (this.filteredTimelineSets[filter.filterId]) {
       return this.filteredTimelineSets[filter.filterId];
     }
-    var opts = Object.assign({
+    const opts = Object.assign({
       filter,
       pendingEvents
     }, this.opts);
-    var timelineSet = new EventTimelineSet(this, opts);
+    const timelineSet = new EventTimelineSet(this, opts);
     this.reEmitter.reEmit(timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
     if (useSyncEvents) {
       this.filteredTimelineSets[filter.filterId] = timelineSet;
       this.timelineSets.push(timelineSet);
     }
-    var unfilteredLiveTimeline = this.getLiveTimeline();
+    const unfilteredLiveTimeline = this.getLiveTimeline();
     // Not all filter are possible to replicate client-side only
     // When that's the case we do not want to prepopulate from the live timeline
     // as we would get incorrect results compared to what the server would send back
@@ -1754,13 +1724,13 @@ export class Room extends ReadReceipt {
       });
 
       // find the earliest unfiltered timeline
-      var timeline = unfilteredLiveTimeline;
+      let timeline = unfilteredLiveTimeline;
       while (timeline.getNeighbouringTimeline(EventTimeline.BACKWARDS)) {
         timeline = timeline.getNeighbouringTimeline(EventTimeline.BACKWARDS);
       }
       timelineSet.getLiveTimeline().setPaginationToken(timeline.getPaginationToken(EventTimeline.BACKWARDS), EventTimeline.BACKWARDS);
     } else if (useSyncEvents) {
-      var livePaginationToken = unfilteredLiveTimeline.getPaginationToken(Direction.Forward);
+      const livePaginationToken = unfilteredLiveTimeline.getPaginationToken(Direction.Forward);
       timelineSet.getLiveTimeline().setPaginationToken(livePaginationToken, Direction.Backward);
     }
 
@@ -1774,73 +1744,63 @@ export class Room extends ReadReceipt {
 
     return timelineSet;
   }
-  getThreadListFilter() {
-    var _arguments = arguments,
-      _this1 = this;
-    return _asyncToGenerator(function* () {
-      var filterType = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : ThreadFilterType.All;
-      var myUserId = _this1.client.getUserId();
-      var filter = new Filter(myUserId);
-      var definition = {
-        room: {
-          timeline: {
-            [FILTER_RELATED_BY_REL_TYPES.name]: [THREAD_RELATION_TYPE.name]
-          }
+  async getThreadListFilter(filterType = ThreadFilterType.All) {
+    const myUserId = this.client.getUserId();
+    const filter = new Filter(myUserId);
+    const definition = {
+      room: {
+        timeline: {
+          [FILTER_RELATED_BY_REL_TYPES.name]: [THREAD_RELATION_TYPE.name]
         }
-      };
-      if (filterType === ThreadFilterType.My) {
-        definition.room.timeline[FILTER_RELATED_BY_SENDERS.name] = [myUserId];
-      }
-      filter.setDefinition(definition);
-      var filterId = yield _this1.client.getOrCreateFilter("THREAD_PANEL_".concat(_this1.roomId, "_").concat(filterType), filter);
-      filter.filterId = filterId;
-      return filter;
-    })();
-  }
-  createThreadTimelineSet(filterType) {
-    var _this10 = this;
-    return _asyncToGenerator(function* () {
-      var timelineSet;
-      if (Thread.hasServerSideListSupport) {
-        timelineSet = new EventTimelineSet(_this10, _objectSpread(_objectSpread({}, _this10.opts), {}, {
-          pendingEvents: false
-        }), undefined, undefined, filterType !== null && filterType !== void 0 ? filterType : ThreadFilterType.All);
-        _this10.reEmitter.reEmit(timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
-      } else if (Thread.hasServerSideSupport) {
-        var filter = yield _this10.getThreadListFilter(filterType);
-        timelineSet = _this10.getOrCreateFilteredTimelineSet(filter, {
-          prepopulateTimeline: false,
-          useSyncEvents: false,
-          pendingEvents: false
-        });
-      } else {
-        timelineSet = new EventTimelineSet(_this10, {
-          pendingEvents: false
+      }
+    };
+    if (filterType === ThreadFilterType.My) {
+      definition.room.timeline[FILTER_RELATED_BY_SENDERS.name] = [myUserId];
+    }
+    filter.setDefinition(definition);
+    const filterId = await this.client.getOrCreateFilter(`THREAD_PANEL_${this.roomId}_${filterType}`, filter);
+    filter.filterId = filterId;
+    return filter;
+  }
+  async createThreadTimelineSet(filterType) {
+    let timelineSet;
+    if (Thread.hasServerSideListSupport) {
+      timelineSet = new EventTimelineSet(this, _objectSpread(_objectSpread({}, this.opts), {}, {
+        pendingEvents: false
+      }), undefined, undefined, filterType ?? ThreadFilterType.All);
+      this.reEmitter.reEmit(timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
+    } else if (Thread.hasServerSideSupport) {
+      const filter = await this.getThreadListFilter(filterType);
+      timelineSet = this.getOrCreateFilteredTimelineSet(filter, {
+        prepopulateTimeline: false,
+        useSyncEvents: false,
+        pendingEvents: false
+      });
+    } else {
+      timelineSet = new EventTimelineSet(this, {
+        pendingEvents: false
+      });
+      Array.from(this.threads).forEach(([, thread]) => {
+        if (thread.length === 0) return;
+        const currentUserParticipated = thread.timeline.some(event => {
+          return event.getSender() === this.client.getUserId();
         });
-        Array.from(_this10.threads).forEach(_ref11 => {
-          var _ref12 = _slicedToArray(_ref11, 2),
-            thread = _ref12[1];
-          if (thread.length === 0) return;
-          var currentUserParticipated = thread.timeline.some(event => {
-            return event.getSender() === _this10.client.getUserId();
+        if (filterType !== ThreadFilterType.My || currentUserParticipated) {
+          timelineSet.getLiveTimeline().addEvent(thread.rootEvent, {
+            toStartOfTimeline: false,
+            addToState: false
           });
-          if (filterType !== ThreadFilterType.My || currentUserParticipated) {
-            timelineSet.getLiveTimeline().addEvent(thread.rootEvent, {
-              toStartOfTimeline: false,
-              addToState: false
-            });
-          }
-        });
-      }
-      return timelineSet;
-    })();
+        }
+      });
+    }
+    return timelineSet;
   }
   /**
    * Takes the given thread root events and creates threads for them.
    */
   processThreadRoots(events, toStartOfTimeline) {
     if (!this.client.supportsThreads()) return;
-    for (var rootEvent of events) {
+    for (const rootEvent of events) {
       EventTimeline.setEventMetadata(rootEvent, this.currentState, toStartOfTimeline);
       if (!this.getThread(rootEvent.getId())) {
         this.createThread(rootEvent.getId(), rootEvent, [], toStartOfTimeline);
@@ -1853,61 +1813,57 @@ export class Room extends ReadReceipt {
    * With server support that means fetching one page.
    * Without server support that means fetching as much at once as the server allows us to.
    */
-  fetchRoomThreads() {
-    var _this11 = this;
-    return _asyncToGenerator(function* () {
-      if (_this11.threadsReady || !_this11.client.supportsThreads()) {
-        return;
-      }
-      if (Thread.hasServerSideListSupport) {
-        yield Promise.all([_this11.fetchRoomThreadList(ThreadFilterType.All), _this11.fetchRoomThreadList(ThreadFilterType.My)]);
-      } else {
-        var allThreadsFilter = yield _this11.getThreadListFilter();
-        var _yield$_this11$client = yield _this11.client.createMessagesRequest(_this11.roomId, "", Number.MAX_SAFE_INTEGER, Direction.Backward, allThreadsFilter),
-          events = _yield$_this11$client.chunk;
-        if (!events.length) return;
-
-        // Sorted by last_reply origin_server_ts
-        var threadRoots = events.map(_this11.client.getEventMapper()).sort((eventA, eventB) => {
-          /**
-           * `origin_server_ts` in a decentralised world is far from ideal
-           * but for lack of any better, we will have to use this
-           * Long term the sorting should be handled by homeservers and this
-           * is only meant as a short term patch
-           */
-          var threadAMetadata = eventA.getServerAggregatedRelation(THREAD_RELATION_TYPE.name);
-          var threadBMetadata = eventB.getServerAggregatedRelation(THREAD_RELATION_TYPE.name);
-          return threadAMetadata.latest_event.origin_server_ts - threadBMetadata.latest_event.origin_server_ts;
-        });
-        var latestMyThreadsRootEvent;
-        var roomState = _this11.getLiveTimeline().getState(EventTimeline.FORWARDS);
-        for (var rootEvent of threadRoots) {
-          var _this11$threadsTimeli;
-          var _opts = {
-            duplicateStrategy: DuplicateStrategy.Ignore,
-            fromCache: false,
-            addToState: false,
-            roomState
-          };
-          (_this11$threadsTimeli = _this11.threadsTimelineSets[0]) === null || _this11$threadsTimeli === void 0 || _this11$threadsTimeli.addLiveEvent(rootEvent, _opts);
-          var threadRelationship = rootEvent.getServerAggregatedRelation(THREAD_RELATION_TYPE.name);
-          if (threadRelationship !== null && threadRelationship !== void 0 && threadRelationship.current_user_participated) {
-            var _this11$threadsTimeli2;
-            (_this11$threadsTimeli2 = _this11.threadsTimelineSets[1]) === null || _this11$threadsTimeli2 === void 0 || _this11$threadsTimeli2.addLiveEvent(rootEvent, _opts);
-            latestMyThreadsRootEvent = rootEvent;
-          }
-        }
-        _this11.processThreadRoots(threadRoots, true);
-        _this11.client.decryptEventIfNeeded(threadRoots[threadRoots.length - 1]);
-        if (latestMyThreadsRootEvent) {
-          _this11.client.decryptEventIfNeeded(latestMyThreadsRootEvent);
+  async fetchRoomThreads() {
+    if (this.threadsReady || !this.client.supportsThreads()) {
+      return;
+    }
+    if (Thread.hasServerSideListSupport) {
+      await Promise.all([this.fetchRoomThreadList(ThreadFilterType.All), this.fetchRoomThreadList(ThreadFilterType.My)]);
+    } else {
+      const allThreadsFilter = await this.getThreadListFilter();
+      const {
+        chunk: events
+      } = await this.client.createMessagesRequest(this.roomId, "", Number.MAX_SAFE_INTEGER, Direction.Backward, allThreadsFilter);
+      if (!events.length) return;
+
+      // Sorted by last_reply origin_server_ts
+      const threadRoots = events.map(this.client.getEventMapper()).sort((eventA, eventB) => {
+        /**
+         * `origin_server_ts` in a decentralised world is far from ideal
+         * but for lack of any better, we will have to use this
+         * Long term the sorting should be handled by homeservers and this
+         * is only meant as a short term patch
+         */
+        const threadAMetadata = eventA.getServerAggregatedRelation(THREAD_RELATION_TYPE.name);
+        const threadBMetadata = eventB.getServerAggregatedRelation(THREAD_RELATION_TYPE.name);
+        return threadAMetadata.latest_event.origin_server_ts - threadBMetadata.latest_event.origin_server_ts;
+      });
+      let latestMyThreadsRootEvent;
+      const roomState = this.getLiveTimeline().getState(EventTimeline.FORWARDS);
+      for (const rootEvent of threadRoots) {
+        const opts = {
+          duplicateStrategy: DuplicateStrategy.Ignore,
+          fromCache: false,
+          addToState: false,
+          roomState
+        };
+        this.threadsTimelineSets[0]?.addLiveEvent(rootEvent, opts);
+        const threadRelationship = rootEvent.getServerAggregatedRelation(THREAD_RELATION_TYPE.name);
+        if (threadRelationship?.current_user_participated) {
+          this.threadsTimelineSets[1]?.addLiveEvent(rootEvent, opts);
+          latestMyThreadsRootEvent = rootEvent;
         }
       }
-      _this11.on(ThreadEvent.NewReply, _this11.onThreadReply);
-      _this11.on(ThreadEvent.Update, _this11.onThreadUpdate);
-      _this11.on(ThreadEvent.Delete, _this11.onThreadDelete);
-      _this11.threadsReady = true;
-    })();
+      this.processThreadRoots(threadRoots, true);
+      this.client.decryptEventIfNeeded(threadRoots[threadRoots.length - 1]);
+      if (latestMyThreadsRootEvent) {
+        this.client.decryptEventIfNeeded(latestMyThreadsRootEvent);
+      }
+    }
+    this.on(ThreadEvent.NewReply, this.onThreadReply);
+    this.on(ThreadEvent.Update, this.onThreadUpdate);
+    this.on(ThreadEvent.Delete, this.onThreadDelete);
+    this.threadsReady = true;
   }
 
   /**
@@ -1915,25 +1871,22 @@ export class Room extends ReadReceipt {
    *
    * @param events - List of events
    */
-  processPollEvents(events) {
-    var _this12 = this;
-    return _asyncToGenerator(function* () {
-      for (var event of events) {
-        try {
-          // Continue if the event is a clear text, non-poll event.
-          if (!event.isEncrypted() && !isPollEvent(event)) continue;
-
-          /**
-           * Try to decrypt the event. Promise resolution does not guarantee a successful decryption.
-           * Retry is handled in {@link processPollEvent}.
-           */
-          yield _this12.client.decryptEventIfNeeded(event);
-          _this12.processPollEvent(event);
-        } catch (err) {
-          logger.warn("Error processing poll event", event.getId(), err);
-        }
+  async processPollEvents(events) {
+    for (const event of events) {
+      try {
+        // Continue if the event is a clear text, non-poll event.
+        if (!event.isEncrypted() && !isPollEvent(event)) continue;
+
+        /**
+         * Try to decrypt the event. Promise resolution does not guarantee a successful decryption.
+         * Retry is handled in {@link processPollEvent}.
+         */
+        await this.client.decryptEventIfNeeded(event);
+        this.processPollEvent(event);
+      } catch (err) {
+        logger.warn("Error processing poll event", event.getId(), err);
       }
-    })();
+    }
   }
 
   /**
@@ -1946,95 +1899,69 @@ export class Room extends ReadReceipt {
    *
    * @param event - Event that could be a poll event
    */
-  processPollEvent(event) {
-    var _this13 = this;
-    return _asyncToGenerator(function* () {
-      if (event.isDecryptionFailure()) {
-        event.once(MatrixEventEvent.Decrypted, maybeDecryptedEvent => {
-          _this13.processPollEvent(maybeDecryptedEvent);
-        });
-        return;
-      }
-      if (M_POLL_START.matches(event.getType())) {
-        try {
-          var poll = new Poll(event, _this13.client, _this13);
-          _this13.polls.set(event.getId(), poll);
-          _this13.emit(PollEvent.New, poll);
+  async processPollEvent(event) {
+    if (event.isDecryptionFailure()) {
+      event.once(MatrixEventEvent.Decrypted, maybeDecryptedEvent => {
+        this.processPollEvent(maybeDecryptedEvent);
+      });
+      return;
+    }
+    if (M_POLL_START.matches(event.getType())) {
+      try {
+        const poll = new Poll(event, this.client, this);
+        this.polls.set(event.getId(), poll);
+        this.emit(PollEvent.New, poll);
 
-          // remove the poll when redacted
-          event.once(MatrixEventEvent.BeforeRedaction, redactedEvent => {
-            _this13.polls.delete(redactedEvent.getId());
-          });
-        } catch (_unused3) {}
-        // poll creation can fail for malformed poll start events
-        return;
-      }
-      var relationEventId = event.relationEventId;
-      if (relationEventId && _this13.polls.has(relationEventId)) {
-        var _poll = _this13.polls.get(relationEventId);
-        _poll === null || _poll === void 0 || _poll.onNewRelation(event);
-      }
-    })();
+        // remove the poll when redacted
+        event.once(MatrixEventEvent.BeforeRedaction, redactedEvent => {
+          this.polls.delete(redactedEvent.getId());
+        });
+      } catch {}
+      // poll creation can fail for malformed poll start events
+      return;
+    }
+    const relationEventId = event.relationEventId;
+    if (relationEventId && this.polls.has(relationEventId)) {
+      const poll = this.polls.get(relationEventId);
+      poll?.onNewRelation(event);
+    }
   }
 
   /**
    * Fetch a single page of threadlist messages for the specific thread filter
    * @internal
    */
-  fetchRoomThreadList(filter) {
-    var _this14 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this14.client.supportsThreads()) return;
-      if (_this14.threadsTimelineSets.length === 0) return;
-      var timelineSet = filter === ThreadFilterType.My ? _this14.threadsTimelineSets[1] : _this14.threadsTimelineSets[0];
-      var _yield$_this14$client = yield _this14.client.createThreadListMessagesRequest(_this14.roomId, null, undefined, Direction.Backward, timelineSet.threadListType, timelineSet.getFilter()),
-        events = _yield$_this14$client.chunk,
-        end = _yield$_this14$client.end;
-      timelineSet.getLiveTimeline().setPaginationToken(end !== null && end !== void 0 ? end : null, Direction.Backward);
-      if (!events.length) return;
-      var matrixEvents = events.map(_this14.client.getEventMapper());
-      _this14.processThreadRoots(matrixEvents, true);
-      var roomState = _this14.getLiveTimeline().getState(EventTimeline.FORWARDS);
-      for (var rootEvent of matrixEvents) {
-        timelineSet.addLiveEvent(rootEvent, {
-          duplicateStrategy: DuplicateStrategy.Replace,
-          fromCache: false,
-          roomState,
-          addToState: false
-        });
-      }
-    })();
-  }
-  onThreadUpdate(thread) {
-    this.updateThreadRootEvents(thread, false, false);
-  }
-  onThreadReply(thread) {
-    this.updateThreadRootEvents(thread, false, true);
-  }
-  onThreadDelete(thread) {
-    var _timeline$getEvents;
-    this.threads.delete(thread.id);
-    var timeline = this.getTimelineForEvent(thread.id);
-    var roomEvent = timeline === null || timeline === void 0 || (_timeline$getEvents = timeline.getEvents()) === null || _timeline$getEvents === void 0 ? void 0 : _timeline$getEvents.find(it => it.getId() === thread.id);
-    if (roomEvent) {
-      thread.clearEventMetadata(roomEvent);
-    } else {
-      logger.debug("onThreadDelete: Could not find root event in room timeline");
-    }
-    for (var timelineSet of this.threadsTimelineSets) {
-      timelineSet.removeEvent(thread.id);
+  async fetchRoomThreadList(filter) {
+    if (!this.client.supportsThreads()) return;
+    if (this.threadsTimelineSets.length === 0) return;
+    const timelineSet = filter === ThreadFilterType.My ? this.threadsTimelineSets[1] : this.threadsTimelineSets[0];
+    const {
+      chunk: events,
+      end
+    } = await this.client.createThreadListMessagesRequest(this.roomId, null, undefined, Direction.Backward, timelineSet.threadListType, timelineSet.getFilter());
+    timelineSet.getLiveTimeline().setPaginationToken(end ?? null, Direction.Backward);
+    if (!events.length) return;
+    const matrixEvents = events.map(this.client.getEventMapper());
+    this.processThreadRoots(matrixEvents, true);
+    const roomState = this.getLiveTimeline().getState(EventTimeline.FORWARDS);
+    for (const rootEvent of matrixEvents) {
+      timelineSet.addLiveEvent(rootEvent, {
+        duplicateStrategy: DuplicateStrategy.Replace,
+        fromCache: false,
+        roomState,
+        addToState: false
+      });
     }
   }
-
   /**
    * Forget the timelineSet for this room with the given filter
    *
    * @param filter - the filter whose timelineSet is to be forgotten
    */
   removeFilteredTimelineSet(filter) {
-    var timelineSet = this.filteredTimelineSets[filter.filterId];
+    const timelineSet = this.filteredTimelineSets[filter.filterId];
     delete this.filteredTimelineSets[filter.filterId];
-    var i = this.timelineSets.indexOf(timelineSet);
+    const i = this.timelineSets.indexOf(timelineSet);
     if (i > -1) {
       this.timelineSets.splice(i, 1);
     }
@@ -2055,8 +1982,7 @@ export class Room extends ReadReceipt {
    * This will change if MSC3389 is merged.
    */
   eventShouldLiveIn(event, events, roots) {
-    var _this$client;
-    if (!((_this$client = this.client) !== null && _this$client !== void 0 && _this$client.supportsThreads())) {
+    if (!this.client?.supportsThreads()) {
       return {
         shouldLiveInRoom: true,
         shouldLiveInThread: false
@@ -2064,28 +1990,27 @@ export class Room extends ReadReceipt {
     }
 
     // A thread root is the only event shown in both timelines
-    if (event.isThreadRoot || roots !== null && roots !== void 0 && roots.has(event.getId())) {
+    if (event.isThreadRoot || roots?.has(event.getId())) {
       return {
         shouldLiveInRoom: true,
         shouldLiveInThread: true,
         threadId: event.getId()
       };
     }
-    var isThreadRelation = event.isRelation(THREAD_RELATION_TYPE.name);
-    var parentEventId = event.getAssociatedId();
-    var threadRootId = event.threadRootId;
+    const isThreadRelation = event.isRelation(THREAD_RELATION_TYPE.name);
+    const parentEventId = event.getAssociatedId();
+    const threadRootId = event.threadRootId;
 
     // Where the parent is the thread root and this is a non-thread relation this should live only in the main timeline
-    if (!!parentEventId && !isThreadRelation && (threadRootId === parentEventId || roots !== null && roots !== void 0 && roots.has(parentEventId))) {
+    if (!!parentEventId && !isThreadRelation && (threadRootId === parentEventId || roots?.has(parentEventId))) {
       return {
         shouldLiveInRoom: true,
         shouldLiveInThread: false
       };
     }
-    var parentEvent;
+    let parentEvent;
     if (parentEventId) {
-      var _this$findEventById;
-      parentEvent = (_this$findEventById = this.findEventById(parentEventId)) !== null && _this$findEventById !== void 0 ? _this$findEventById : events === null || events === void 0 ? void 0 : events.find(e => e.getId() === parentEventId);
+      parentEvent = this.findEventById(parentEventId) ?? events?.find(e => e.getId() === parentEventId);
     }
 
     // Treat non-thread-relations, redactions, and replies as extensions of their parents so evaluate parentEvent instead
@@ -2122,18 +2047,17 @@ export class Room extends ReadReceipt {
   }
   findThreadForEvent(event) {
     if (!event) return null;
-    var _this$eventShouldLive = this.eventShouldLiveIn(event),
-      threadId = _this$eventShouldLive.threadId;
+    const {
+      threadId
+    } = this.eventShouldLiveIn(event);
     return threadId ? this.getThread(threadId) : null;
   }
-  addThreadedEvents(threadId, events) {
-    var toStartOfTimeline = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    var thread = this.getThread(threadId);
+  addThreadedEvents(threadId, events, toStartOfTimeline = false) {
+    const thread = this.getThread(threadId);
     if (thread) {
       thread.addEvents(events, toStartOfTimeline);
     } else {
-      var _this$findEventById2;
-      var rootEvent = (_this$findEventById2 = this.findEventById(threadId)) !== null && _this$findEventById2 !== void 0 ? _this$findEventById2 : events.find(e => e.getId() === threadId);
+      const rootEvent = this.findEventById(threadId) ?? events.find(e => e.getId() === threadId);
       this.createThread(threadId, rootEvent, events, toStartOfTimeline);
     }
   }
@@ -2142,45 +2066,39 @@ export class Room extends ReadReceipt {
    * Adds events to a thread's timeline. Will fire "Thread.update"
    */
   processThreadedEvents(events, toStartOfTimeline) {
+    // ALWAYS filter out any events that are past retention
+    events = events.filter(e => this.retention?.shouldEventBeRetained(e) ?? true);
     events.forEach(this.tryApplyRedaction);
-    var eventsByThread = {};
-    for (var event of events) {
-      var _eventsByThread;
-      var _this$eventShouldLive2 = this.eventShouldLiveIn(event),
-        threadId = _this$eventShouldLive2.threadId,
-        shouldLiveInThread = _this$eventShouldLive2.shouldLiveInThread;
+    const eventsByThread = {};
+    for (const event of events) {
+      const {
+        threadId,
+        shouldLiveInThread
+      } = this.eventShouldLiveIn(event);
       if (shouldLiveInThread && !eventsByThread[threadId]) {
         eventsByThread[threadId] = [];
       }
-      (_eventsByThread = eventsByThread[threadId]) === null || _eventsByThread === void 0 || _eventsByThread.push(event);
+      eventsByThread[threadId]?.push(event);
     }
-    Object.entries(eventsByThread).map(_ref13 => {
-      var _ref14 = _slicedToArray(_ref13, 2),
-        threadId = _ref14[0],
-        threadEvents = _ref14[1];
-      return this.addThreadedEvents(threadId, threadEvents, toStartOfTimeline);
-    });
+    Object.entries(eventsByThread).map(([threadId, threadEvents]) => this.addThreadedEvents(threadId, threadEvents, toStartOfTimeline));
   }
-  createThread(threadId, rootEvent) {
-    var _this$cachedThreadRea;
-    var events = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-    var toStartOfTimeline = arguments.length > 3 ? arguments[3] : undefined;
+  createThread(threadId, rootEvent, events = [], toStartOfTimeline) {
     if (this.threads.has(threadId)) {
       return this.threads.get(threadId);
     }
     if (rootEvent) {
-      var relatedEvents = this.relations.getAllChildEventsForEvent(rootEvent.getId());
-      if (relatedEvents !== null && relatedEvents !== void 0 && relatedEvents.length) {
+      const relatedEvents = this.relations.getAllChildEventsForEvent(rootEvent.getId());
+      if (relatedEvents?.length) {
         // Include all relations of the root event, given it'll be visible in both timelines,
         // except `m.replace` as that will already be applied atop the event using `MatrixEvent::makeReplaced`
         events = events.concat(relatedEvents.filter(e => !e.isRelation(RelationType.Replace)));
       }
     }
-    var thread = new Thread(threadId, rootEvent, {
+    const thread = new Thread(threadId, rootEvent, {
       room: this,
       client: this.client,
       pendingEventOrdering: this.opts.pendingEventOrdering,
-      receipts: (_this$cachedThreadRea = this.cachedThreadReadReceipts.get(threadId)) !== null && _this$cachedThreadRea !== void 0 ? _this$cachedThreadRea : []
+      receipts: this.cachedThreadReadReceipts.get(threadId) ?? []
     });
 
     // Add the re-emitter before we start adding events to the thread so we don't miss events
@@ -2221,13 +2139,13 @@ export class Room extends ReadReceipt {
    * @private
    */
   applyEventAsRedaction(redactionEvent, redactedEvent) {
-    var threadRootId = redactedEvent.threadRootId;
+    const threadRootId = redactedEvent.threadRootId;
     redactedEvent.makeRedacted(redactionEvent, this);
 
     // If this is in the current state, replace it with the redacted version
     if (redactedEvent.isState()) {
-      var currentStateEvent = this.currentState.getStateEvents(redactedEvent.getType(), redactedEvent.getStateKey());
-      if ((currentStateEvent === null || currentStateEvent === void 0 ? void 0 : currentStateEvent.getId()) === redactedEvent.getId()) {
+      const currentStateEvent = this.currentState.getStateEvents(redactedEvent.getType(), redactedEvent.getStateKey());
+      if (currentStateEvent?.getId() === redactedEvent.getId()) {
         this.currentState.setStateEvents([redactedEvent]);
       }
     }
@@ -2265,17 +2183,14 @@ export class Room extends ReadReceipt {
     // to check the event ID against the list of pending events if there is no transaction ID
     // field. Only do this for events sent by us though as it's potentially expensive to loop
     // the pending events map.
-    var txnId = event.getUnsigned().transaction_id;
+    const txnId = event.getUnsigned().transaction_id;
     if (!txnId && event.getSender() === this.myUserId) {
       // check the txn map for a matching event ID
-      for (var _ref17 of this.txnToEvent) {
-        var _ref16 = _slicedToArray(_ref17, 2);
-        var tid = _ref16[0];
-        var localEvent = _ref16[1];
+      for (const [tid, localEvent] of this.txnToEvent) {
         if (localEvent.getId() === event.getId()) {
           logger.debug("processLiveEvent: found sent event without txn ID: ", tid, event.getId());
           // update the unsigned field so we can re-use the same codepaths
-          var unsigned = event.getUnsigned();
+          const unsigned = event.getUnsigned();
           unsigned.transaction_id = tid;
           event.setUnsigned(unsigned);
           break;
@@ -2296,13 +2211,15 @@ export class Room extends ReadReceipt {
    * Fires {@link RoomEvent.Timeline}
    */
   addLiveEvent(event, addLiveEventOptions) {
-    var duplicateStrategy = addLiveEventOptions.duplicateStrategy,
-      timelineWasEmpty = addLiveEventOptions.timelineWasEmpty,
-      fromCache = addLiveEventOptions.fromCache,
-      addToState = addLiveEventOptions.addToState;
+    const {
+      duplicateStrategy,
+      timelineWasEmpty,
+      fromCache,
+      addToState
+    } = addLiveEventOptions;
 
     // add to our timeline sets
-    for (var timelineSet of this.timelineSets) {
+    for (const timelineSet of this.timelineSets) {
       timelineSet.addLiveEvent(event, {
         duplicateStrategy,
         fromCache,
@@ -2372,8 +2289,8 @@ export class Room extends ReadReceipt {
         this.aggregateNonLiveRelation(event);
       }
       if (event.isRedaction()) {
-        var redactId = event.event.redacts;
-        var redactedEvent = this.pendingEventList.find(e => e.getId() === redactId);
+        const redactId = event.event.redacts;
+        let redactedEvent = this.pendingEventList.find(e => e.getId() === redactId);
         if (!redactedEvent && redactId) {
           redactedEvent = this.findEventById(redactId);
         }
@@ -2383,7 +2300,7 @@ export class Room extends ReadReceipt {
         }
       }
     } else {
-      for (var timelineSet of this.timelineSets) {
+      for (const timelineSet of this.timelineSets) {
         if (timelineSet.getFilter()) {
           if (timelineSet.getFilter().filterRoomTimeline([event]).length) {
             timelineSet.addEventToTimeline(event, timelineSet.getLiveTimeline(), {
@@ -2417,14 +2334,14 @@ export class Room extends ReadReceipt {
    */
   savePendingEvents() {
     if (this.pendingEventList) {
-      var pendingEvents = this.pendingEventList.map(event => {
+      const pendingEvents = this.pendingEventList.map(event => {
         return _objectSpread(_objectSpread({}, event.event), {}, {
           txn_id: event.getTxnId()
         });
       }).filter(event => {
         // Filter out the unencrypted messages if the room is encrypted
-        var isEventEncrypted = event.type === EventType.RoomMessageEncrypted;
-        var isRoomEncrypted = this.hasEncryptionStateEvent();
+        const isEventEncrypted = event.type === EventType.RoomMessageEncrypted;
+        const isRoomEncrypted = this.hasEncryptionStateEvent();
         return isEventEncrypted || !isRoomEncrypted;
       });
       this.client.store.setPendingEvents(this.roomId, pendingEvents);
@@ -2465,10 +2382,10 @@ export class Room extends ReadReceipt {
    * Fires {@link RoomEvent.LocalEchoUpdated}
    */
   handleRemoteEcho(remoteEvent, localEvent) {
-    var oldEventId = localEvent.getId();
-    var newEventId = remoteEvent.getId();
-    var oldStatus = localEvent.status;
-    logger.debug("Got remote echo for event ".concat(oldEventId, " -> ").concat(newEventId, " old status ").concat(oldStatus));
+    const oldEventId = localEvent.getId();
+    const newEventId = remoteEvent.getId();
+    const oldStatus = localEvent.status;
+    logger.debug(`Got remote echo for event ${oldEventId} -> ${newEventId} old status ${oldStatus}`);
 
     // no longer pending
     this.txnToEvent.delete(remoteEvent.getUnsigned().transaction_id);
@@ -2481,14 +2398,15 @@ export class Room extends ReadReceipt {
     // replace the event source (this will preserve the plaintext payload if
     // any, which is good, because we don't want to try decoding it again).
     localEvent.handleRemoteEcho(remoteEvent.event);
-    var _this$eventShouldLive3 = this.eventShouldLiveIn(remoteEvent),
-      shouldLiveInRoom = _this$eventShouldLive3.shouldLiveInRoom,
-      threadId = _this$eventShouldLive3.threadId;
-    var thread = threadId ? this.getThread(threadId) : null;
-    thread === null || thread === void 0 || thread.setEventMetadata(localEvent);
-    thread === null || thread === void 0 || thread.timelineSet.handleRemoteEcho(localEvent, oldEventId, newEventId);
+    const {
+      shouldLiveInRoom,
+      threadId
+    } = this.eventShouldLiveIn(remoteEvent);
+    const thread = threadId ? this.getThread(threadId) : null;
+    thread?.setEventMetadata(localEvent);
+    thread?.timelineSet.handleRemoteEcho(localEvent, oldEventId, newEventId);
     if (shouldLiveInRoom) {
-      for (var timelineSet of this.timelineSets) {
+      for (const timelineSet of this.timelineSets) {
         // if it's already in the timeline, update the timeline map. If it's not, add it.
         timelineSet.handleRemoteEcho(localEvent, oldEventId, newEventId);
       }
@@ -2510,7 +2428,7 @@ export class Room extends ReadReceipt {
    * Fires {@link RoomEvent.LocalEchoUpdated}
    */
   updatePendingEvent(event, newStatus, newEventId) {
-    logger.log("setting pendingEvent status to ".concat(newStatus, " in ").concat(event.getRoomId(), " ") + "event ID ".concat(event.getId(), " -> ").concat(newEventId));
+    logger.log(`setting pendingEvent status to ${newStatus} in ${event.getRoomId()} ` + `event ID ${event.getId()} -> ${newEventId}`);
 
     // if the message was sent, we expect an event id
     if (newStatus == EventStatus.SENT && !newEventId) {
@@ -2519,18 +2437,18 @@ export class Room extends ReadReceipt {
 
     // SENT races against /sync, so we have to special-case it.
     if (newStatus == EventStatus.SENT) {
-      var timeline = this.getTimelineForEvent(newEventId);
+      const timeline = this.getTimelineForEvent(newEventId);
       if (timeline) {
         // we've already received the event via the event stream.
         // nothing more to do here, assuming the transaction ID was correctly matched.
         // Let's check that.
-        var remoteEvent = this.findEventById(newEventId);
-        var remoteTxnId = remoteEvent === null || remoteEvent === void 0 ? void 0 : remoteEvent.getUnsigned().transaction_id;
+        const remoteEvent = this.findEventById(newEventId);
+        const remoteTxnId = remoteEvent?.getUnsigned().transaction_id;
         if (!remoteTxnId && remoteEvent) {
           // This code path is mostly relevant for the Sliding Sync proxy.
           // The remote event did not contain a transaction ID, so we did not handle
           // the remote echo yet. Handle it now.
-          var unsigned = remoteEvent.getUnsigned();
+          const unsigned = remoteEvent.getUnsigned();
           unsigned.transaction_id = event.getTxnId();
           remoteEvent.setUnsigned(unsigned);
           // the remote event is _already_ in the timeline, so we need to remove it so
@@ -2541,39 +2459,40 @@ export class Room extends ReadReceipt {
         return;
       }
     }
-    var oldStatus = event.status;
-    var oldEventId = event.getId();
+    const oldStatus = event.status;
+    const oldEventId = event.getId();
     if (!oldStatus) {
       throw new Error("updatePendingEventStatus called on an event which is not a local echo.");
     }
-    var allowed = ALLOWED_TRANSITIONS[oldStatus];
-    if (!(allowed !== null && allowed !== void 0 && allowed.includes(newStatus))) {
-      throw new Error("Invalid EventStatus transition ".concat(oldStatus, "->").concat(newStatus));
+    const allowed = ALLOWED_TRANSITIONS[oldStatus];
+    if (!allowed?.includes(newStatus)) {
+      throw new Error(`Invalid EventStatus transition ${oldStatus}->${newStatus}`);
     }
     event.setStatus(newStatus);
     if (newStatus == EventStatus.SENT) {
       // update the event id
       event.replaceLocalEventId(newEventId);
-      var _this$eventShouldLive4 = this.eventShouldLiveIn(event),
-        shouldLiveInRoom = _this$eventShouldLive4.shouldLiveInRoom,
-        threadId = _this$eventShouldLive4.threadId;
-      var thread = threadId ? this.getThread(threadId) : undefined;
-      thread === null || thread === void 0 || thread.setEventMetadata(event);
-      thread === null || thread === void 0 || thread.timelineSet.replaceEventId(oldEventId, newEventId);
+      const {
+        shouldLiveInRoom,
+        threadId
+      } = this.eventShouldLiveIn(event);
+      const thread = threadId ? this.getThread(threadId) : undefined;
+      thread?.setEventMetadata(event);
+      thread?.timelineSet.replaceEventId(oldEventId, newEventId);
       if (shouldLiveInRoom) {
         // if the event was already in the timeline (which will be the case if
         // opts.pendingEventOrdering==chronological), we need to update the
         // timeline map.
-        for (var timelineSet of this.timelineSets) {
+        for (const timelineSet of this.timelineSets) {
           timelineSet.replaceEventId(oldEventId, newEventId);
         }
       }
     } else if (newStatus == EventStatus.CANCELLED) {
       // remove it from the pending event list, or the timeline.
       if (this.pendingEventList) {
-        var removedEvent = this.getPendingEvent(oldEventId);
+        const removedEvent = this.getPendingEvent(oldEventId);
         this.removePendingEvent(oldEventId);
-        if (removedEvent !== null && removedEvent !== void 0 && removedEvent.isRedaction()) {
+        if (removedEvent?.isRedaction()) {
           this.revertRedactionLocalEcho(removedEvent);
         }
       }
@@ -2583,11 +2502,11 @@ export class Room extends ReadReceipt {
     this.emit(RoomEvent.LocalEchoUpdated, event, this, oldEventId, oldStatus);
   }
   revertRedactionLocalEcho(redactionEvent) {
-    var redactId = redactionEvent.event.redacts;
+    const redactId = redactionEvent.event.redacts;
     if (!redactId) {
       return;
     }
-    var redactedEvent = this.getUnfilteredTimelineSet().findEventById(redactId);
+    const redactedEvent = this.getUnfilteredTimelineSet().findEventById(redactId);
     if (redactedEvent) {
       redactedEvent.unmarkLocallyRedacted();
       // re-render after undoing redaction
@@ -2599,13 +2518,13 @@ export class Room extends ReadReceipt {
     }
   }
   assertTimelineSetsAreLive() {
-    for (var i = 0; i < this.timelineSets.length; i++) {
-      var liveTimeline = this.timelineSets[i].getLiveTimeline();
+    for (let i = 0; i < this.timelineSets.length; i++) {
+      const liveTimeline = this.timelineSets[i].getLiveTimeline();
       if (liveTimeline.getPaginationToken(EventTimeline.FORWARDS)) {
         throw new Error("live timeline " + i + " is no longer live - it has a pagination token " + "(" + liveTimeline.getPaginationToken(EventTimeline.FORWARDS) + ")");
       }
       if (liveTimeline.getNeighbouringTimeline(EventTimeline.FORWARDS)) {
-        throw new Error("live timeline ".concat(i, " is no longer live - it has a neighbouring timeline"));
+        throw new Error(`live timeline ${i} is no longer live - it has a neighbouring timeline`);
       }
     }
   }
@@ -2619,102 +2538,100 @@ export class Room extends ReadReceipt {
    * @param addLiveEventOptions - addLiveEvent options
    * @throws If `duplicateStrategy` is not falsey, 'replace' or 'ignore'.
    */
-  addLiveEvents(events, addLiveEventOptions) {
-    var _this15 = this;
-    return _asyncToGenerator(function* () {
-      var duplicateStrategy = addLiveEventOptions.duplicateStrategy,
-        fromCache = addLiveEventOptions.fromCache,
-        _addLiveEventOptions$ = addLiveEventOptions.timelineWasEmpty,
-        timelineWasEmpty = _addLiveEventOptions$ === void 0 ? false : _addLiveEventOptions$,
-        addToState = addLiveEventOptions.addToState;
-      if (duplicateStrategy && ["replace", "ignore"].indexOf(duplicateStrategy) === -1) {
-        throw new Error("duplicateStrategy MUST be either 'replace' or 'ignore'");
-      }
-
-      // sanity check that the live timeline is still live
-      _this15.assertTimelineSetsAreLive();
-      var threadRoots = _this15.findThreadRoots(events);
-      var eventsByThread = {};
-      var options = {
-        duplicateStrategy,
-        fromCache,
-        timelineWasEmpty,
-        addToState
-      };
+  async addLiveEvents(events, addLiveEventOptions) {
+    const {
+      duplicateStrategy,
+      fromCache,
+      timelineWasEmpty = false,
+      addToState
+    } = addLiveEventOptions;
+    if (duplicateStrategy && ["replace", "ignore"].indexOf(duplicateStrategy) === -1) {
+      throw new Error("duplicateStrategy MUST be either 'replace' or 'ignore'");
+    }
+
+    // ALWAYS filter out any events that are past retention
+    events = events.filter(e => this.retention?.shouldEventBeRetained(e) ?? true);
+
+    // sanity check that the live timeline is still live
+    this.assertTimelineSetsAreLive();
+    const threadRoots = this.findThreadRoots(events);
+    const eventsByThread = {};
+    const options = {
+      duplicateStrategy,
+      fromCache,
+      timelineWasEmpty,
+      addToState
+    };
 
-      // List of extra events to check for being parents of any relations encountered
-      var neighbouringEvents = [...events];
-      for (var event of events) {
-        var _eventsByThread$threa;
-        // TODO: We should have a filter to say "only add state event types X Y Z to the timeline".
-        _this15.processLiveEvent(event);
-        if (event.getUnsigned().transaction_id) {
-          var existingEvent = _this15.txnToEvent.get(event.getUnsigned().transaction_id);
-          if (existingEvent) {
-            // remote echo of an event we sent earlier
-            _this15.handleRemoteEcho(event, existingEvent);
-            continue; // we can skip adding the event to the timeline sets, it is already there
-          }
+    // List of extra events to check for being parents of any relations encountered
+    const neighbouringEvents = [...events];
+    for (const event of events) {
+      // TODO: We should have a filter to say "only add state event types X Y Z to the timeline".
+      this.processLiveEvent(event);
+      if (event.getUnsigned().transaction_id) {
+        const existingEvent = this.txnToEvent.get(event.getUnsigned().transaction_id);
+        if (existingEvent) {
+          // remote echo of an event we sent earlier
+          this.handleRemoteEcho(event, existingEvent);
+          continue; // we can skip adding the event to the timeline sets, it is already there
         }
-        var _this15$eventShouldLi = _this15.eventShouldLiveIn(event, neighbouringEvents, threadRoots),
-          shouldLiveInRoom = _this15$eventShouldLi.shouldLiveInRoom,
-          shouldLiveInThread = _this15$eventShouldLi.shouldLiveInThread,
-          _this15$eventShouldLi2 = _this15$eventShouldLi.threadId,
-          threadId = _this15$eventShouldLi2 === void 0 ? "" : _this15$eventShouldLi2;
-        if (!shouldLiveInThread && !shouldLiveInRoom && event.isRelation()) {
-          try {
-            var parentEvent = new MatrixEvent(yield _this15.client.fetchRoomEvent(_this15.roomId, event.relationEventId));
-            neighbouringEvents.push(parentEvent);
-            if (parentEvent.threadRootId) {
-              threadRoots.add(parentEvent.threadRootId);
-              var unsigned = event.getUnsigned();
-              unsigned[UNSIGNED_THREAD_ID_FIELD.name] = parentEvent.threadRootId;
-              event.setUnsigned(unsigned);
-            }
-            var _this15$eventShouldLi3 = _this15.eventShouldLiveIn(event, neighbouringEvents, threadRoots);
-            shouldLiveInRoom = _this15$eventShouldLi3.shouldLiveInRoom;
-            shouldLiveInThread = _this15$eventShouldLi3.shouldLiveInThread;
-            var _this15$eventShouldLi4 = _this15$eventShouldLi3.threadId;
-            threadId = _this15$eventShouldLi4 === void 0 ? "" : _this15$eventShouldLi4;
-          } catch (e) {
-            logger.error("Failed to load parent event of unhandled relation", e);
+      }
+      let {
+        shouldLiveInRoom,
+        shouldLiveInThread,
+        threadId = ""
+      } = this.eventShouldLiveIn(event, neighbouringEvents, threadRoots);
+      if (!shouldLiveInThread && !shouldLiveInRoom && event.isRelation()) {
+        try {
+          const parentEvent = new MatrixEvent(await this.client.fetchRoomEvent(this.roomId, event.relationEventId));
+          neighbouringEvents.push(parentEvent);
+          if (parentEvent.threadRootId) {
+            threadRoots.add(parentEvent.threadRootId);
+            const unsigned = event.getUnsigned();
+            unsigned[UNSIGNED_THREAD_ID_FIELD.name] = parentEvent.threadRootId;
+            event.setUnsigned(unsigned);
           }
-        }
-        if (shouldLiveInThread && !eventsByThread[threadId]) {
-          eventsByThread[threadId] = [];
-        }
-        (_eventsByThread$threa = eventsByThread[threadId]) === null || _eventsByThread$threa === void 0 || _eventsByThread$threa.push(event);
-        if (shouldLiveInRoom) {
-          _this15.addLiveEvent(event, options);
-        } else if (!shouldLiveInThread && event.isRelation()) {
-          _this15.relations.aggregateChildEvent(event);
+          ({
+            shouldLiveInRoom,
+            shouldLiveInThread,
+            threadId = ""
+          } = this.eventShouldLiveIn(event, neighbouringEvents, threadRoots));
+        } catch (e) {
+          logger.error("Failed to load parent event of unhandled relation", e);
         }
       }
-      Object.entries(eventsByThread).forEach(_ref18 => {
-        var _ref19 = _slicedToArray(_ref18, 2),
-          threadId = _ref19[0],
-          threadEvents = _ref19[1];
-        _this15.addThreadedEvents(threadId, threadEvents, false);
-      });
-    })();
+      if (shouldLiveInThread && !eventsByThread[threadId]) {
+        eventsByThread[threadId] = [];
+      }
+      eventsByThread[threadId]?.push(event);
+      if (shouldLiveInRoom) {
+        this.addLiveEvent(event, options);
+      } else if (!shouldLiveInThread && event.isRelation()) {
+        this.relations.aggregateChildEvent(event);
+      }
+    }
+    Object.entries(eventsByThread).forEach(([threadId, threadEvents]) => {
+      this.addThreadedEvents(threadId, threadEvents, false);
+    });
   }
   partitionThreadedEvents(events) {
     // Indices to the events array, for readability
-    var ROOM = 0;
-    var THREAD = 1;
-    var UNKNOWN_RELATION = 2;
+    const ROOM = 0;
+    const THREAD = 1;
+    const UNKNOWN_RELATION = 2;
     if (this.client.supportsThreads()) {
-      var threadRoots = this.findThreadRoots(events);
+      const threadRoots = this.findThreadRoots(events);
       return events.reduce((memo, event) => {
-        var _this$eventShouldLive5 = this.eventShouldLiveIn(event, events, threadRoots),
-          shouldLiveInRoom = _this$eventShouldLive5.shouldLiveInRoom,
-          shouldLiveInThread = _this$eventShouldLive5.shouldLiveInThread,
-          threadId = _this$eventShouldLive5.threadId;
+        const {
+          shouldLiveInRoom,
+          shouldLiveInThread,
+          threadId
+        } = this.eventShouldLiveIn(event, events, threadRoots);
         if (shouldLiveInRoom) {
           memo[ROOM].push(event);
         }
         if (shouldLiveInThread) {
-          event.setThreadId(threadId !== null && threadId !== void 0 ? threadId : "");
+          event.setThreadId(threadId ?? "");
           memo[THREAD].push(event);
         }
         if (!shouldLiveInThread && !shouldLiveInRoom) {
@@ -2732,9 +2649,9 @@ export class Room extends ReadReceipt {
    * Given some events, find the IDs of all the thread roots that are referred to by them.
    */
   findThreadRoots(events) {
-    var threadRoots = new Set();
-    for (var event of events) {
-      var threadRootId = event.threadRootId;
+    const threadRoots = new Set();
+    for (const event of events) {
+      const threadRootId = event.threadRootId;
       if (threadRootId != undefined) {
         threadRoots.add(threadRootId);
       }
@@ -2747,19 +2664,17 @@ export class Room extends ReadReceipt {
    * @param event - The m.receipt event.
    * @param synthetic - True if this event is implicit.
    */
-  addReceipt(event) {
-    var synthetic = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    var content = event.getContent();
+  addReceipt(event, synthetic = false) {
+    const content = event.getContent();
     this.roomReceipts.add(content, synthetic);
 
     // TODO: delete the following code when it has been replaced by RoomReceipts
     Object.keys(content).forEach(eventId => {
       Object.keys(content[eventId]).forEach(receiptType => {
         Object.keys(content[eventId][receiptType]).forEach(userId => {
-          var _receipt$thread_id, _this$unthreadedRecei, _this$unthreadedRecei2;
-          var receipt = content[eventId][receiptType][userId];
-          var receiptForMainTimeline = !receipt.thread_id || receipt.thread_id === MAIN_ROOM_TIMELINE;
-          var receiptDestination = receiptForMainTimeline ? this : this.threads.get((_receipt$thread_id = receipt.thread_id) !== null && _receipt$thread_id !== void 0 ? _receipt$thread_id : "");
+          const receipt = content[eventId][receiptType][userId];
+          const receiptForMainTimeline = !receipt.thread_id || receipt.thread_id === MAIN_ROOM_TIMELINE;
+          const receiptDestination = receiptForMainTimeline ? this : this.threads.get(receipt.thread_id ?? "");
           if (receiptDestination) {
             receiptDestination.addReceiptToStructure(eventId, receiptType, userId, receipt, synthetic);
 
@@ -2777,18 +2692,17 @@ export class Room extends ReadReceipt {
             // an event during the sync. More explanation at:
             // https://github.com/matrix-org/matrix-js-sdk/issues/3684
             if (!synthetic && this.client.isInitialSyncComplete() && userId === this.client.getUserId()) {
-              var lastEvent = receiptDestination.timeline[receiptDestination.timeline.length - 1];
+              const lastEvent = receiptDestination.timeline[receiptDestination.timeline.length - 1];
               if (lastEvent && eventId === lastEvent.getId() && userId === lastEvent.getSender()) {
                 receiptDestination.setUnread(NotificationCountType.Total, 0);
                 receiptDestination.setUnread(NotificationCountType.Highlight, 0);
               }
             }
           } else {
-            var _this$cachedThreadRea2;
             // The thread does not exist locally, keep the read receipt
             // in a cache locally, and re-apply  the `addReceipt` logic
             // when the thread is created
-            this.cachedThreadReadReceipts.set(receipt.thread_id, [...((_this$cachedThreadRea2 = this.cachedThreadReadReceipts.get(receipt.thread_id)) !== null && _this$cachedThreadRea2 !== void 0 ? _this$cachedThreadRea2 : []), {
+            this.cachedThreadReadReceipts.set(receipt.thread_id, [...(this.cachedThreadReadReceipts.get(receipt.thread_id) ?? []), {
               eventId,
               receiptType,
               userId,
@@ -2796,14 +2710,14 @@ export class Room extends ReadReceipt {
               synthetic
             }]);
           }
-          var me = this.client.getUserId();
+          const me = this.client.getUserId();
           // Track the time of the current user's oldest threaded receipt in the room.
           if (userId === me && !receiptForMainTimeline && receipt.ts < this.oldestThreadedReceiptTs) {
             this.oldestThreadedReceiptTs = receipt.ts;
           }
 
           // Track each user's unthreaded read receipt.
-          if (!receipt.thread_id && receipt.ts > ((_this$unthreadedRecei = (_this$unthreadedRecei2 = this.unthreadedReceipts.get(userId)) === null || _this$unthreadedRecei2 === void 0 ? void 0 : _this$unthreadedRecei2.ts) !== null && _this$unthreadedRecei !== void 0 ? _this$unthreadedRecei : 0)) {
+          if (!receipt.thread_id && receipt.ts > (this.unthreadedReceipts.get(userId)?.ts ?? 0)) {
             this.unthreadedReceipts.set(userId, receipt);
           }
         });
@@ -2821,7 +2735,7 @@ export class Room extends ReadReceipt {
    * @param events - A list of events to process
    */
   addEphemeralEvents(events) {
-    for (var event of events) {
+    for (const event of events) {
       if (event.getType() === EventType.Typing) {
         this.currentState.setTypingEvent(event);
       } else if (event.getType() === EventType.Receipt) {
@@ -2835,7 +2749,7 @@ export class Room extends ReadReceipt {
    * @param eventIds - A list of eventIds to remove.
    */
   removeEvents(eventIds) {
-    for (var eventId of eventIds) {
+    for (const eventId of eventIds) {
       this.removeEvent(eventId);
     }
   }
@@ -2848,9 +2762,9 @@ export class Room extends ReadReceipt {
    * @returns true if the event was removed from any of the room's timeline sets
    */
   removeEvent(eventId) {
-    var removedAny = false;
-    for (var timelineSet of this.timelineSets) {
-      var removed = timelineSet.removeEvent(eventId);
+    let removedAny = false;
+    for (const timelineSet of this.timelineSets) {
+      const removed = timelineSet.removeEvent(eventId);
       if (removed) {
         if (removed.isRedaction()) {
           this.revertRedactionLocalEcho(removed);
@@ -2872,14 +2786,14 @@ export class Room extends ReadReceipt {
   recalculate() {
     // set fake stripped state events if this is an invite room so logic remains
     // consistent elsewhere.
-    var membershipEvent = this.currentState.getStateEvents(EventType.RoomMember, this.myUserId);
+    const membershipEvent = this.currentState.getStateEvents(EventType.RoomMember, this.myUserId);
     if (membershipEvent) {
-      var membership = membershipEvent.getContent().membership;
+      const membership = membershipEvent.getContent().membership;
       this.updateMyMembership(membership);
       if (membership === KnownMembership.Invite) {
-        var strippedStateEvents = membershipEvent.getUnsigned().invite_room_state || [];
+        const strippedStateEvents = membershipEvent.getUnsigned().invite_room_state || [];
         strippedStateEvents.forEach(strippedEvent => {
-          var existingEvent = this.currentState.getStateEvents(strippedEvent.type, strippedEvent.state_key);
+          const existingEvent = this.currentState.getStateEvents(strippedEvent.type, strippedEvent.state_key);
           if (!existingEvent) {
             // set the fake stripped event instead
             this.currentState.setStateEvents([new MatrixEvent({
@@ -2894,7 +2808,7 @@ export class Room extends ReadReceipt {
         });
       }
     }
-    var oldName = this.name;
+    const oldName = this.name;
     this.name = this.calculateRoomName(this.myUserId);
     this.normalizedName = normalize(this.name);
     this.summary = new RoomSummary(this.roomId, {
@@ -2931,12 +2845,12 @@ export class Room extends ReadReceipt {
    * @param events - an array of account_data events to add
    */
   addAccountData(events) {
-    for (var event of events) {
+    for (const event of events) {
       if (event.getType() === "m.tag") {
         this.addTags(event);
       }
-      var eventType = event.getType();
-      var lastEvent = this.accountData.get(eventType);
+      const eventType = event.getType();
+      const lastEvent = this.accountData.get(eventType);
       this.accountData.set(eventType, event);
       this.emit(RoomEvent.AccountData, event, this, lastEvent);
     }
@@ -2990,6 +2904,8 @@ export class Room extends ReadReceipt {
    */
   // eslint-disable-next-line
   _unstable_addStickyEvents(events) {
+    // ALWAYS filter out any events that are past retention
+    events = events.filter(e => this.retention?.shouldEventBeRetained(e) ?? true);
     return this.stickyEvents.addStickyEvents(events);
   }
 
@@ -3008,10 +2924,10 @@ export class Room extends ReadReceipt {
    * @returns true if the user should be permitted to issue invites for this room.
    */
   canInvite(userId) {
-    var canInvite = this.getMyMembership() === KnownMembership.Join;
-    var powerLevelsEvent = this.currentState.getStateEvents(EventType.RoomPowerLevels, "");
-    var powerLevels = powerLevelsEvent && powerLevelsEvent.getContent();
-    var me = this.getMember(userId);
+    let canInvite = this.getMyMembership() === KnownMembership.Join;
+    const powerLevelsEvent = this.currentState.getStateEvents(EventType.RoomPowerLevels, "");
+    const powerLevels = powerLevelsEvent && powerLevelsEvent.getContent();
+    const me = this.getMember(userId);
     if (powerLevels && me && powerLevels.invite > me.powerLevel) {
       canInvite = false;
     }
@@ -3047,7 +2963,7 @@ export class Room extends ReadReceipt {
    * @returns the type of the room.
    */
   getType() {
-    var createEvent = this.currentState.getStateEvents(EventType.RoomCreate, "");
+    const createEvent = this.currentState.getStateEvents(EventType.RoomCreate, "");
     if (!createEvent) {
       if (!this.getTypeWarning) {
         logger.warn("[getType] Room " + this.roomId + " does not have an m.room.create event");
@@ -3100,9 +3016,8 @@ export class Room extends ReadReceipt {
    * this predecessor comes from a RoomCreate event (rather than a
    * RoomPredecessor, which has the optional via_servers property).
    */
-  findPredecessor() {
-    var msc3946ProcessDynamicPredecessor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    var currentState = this.getLiveTimeline().getState(EventTimeline.FORWARDS);
+  findPredecessor(msc3946ProcessDynamicPredecessor = false) {
+    const currentState = this.getLiveTimeline().getState(EventTimeline.FORWARDS);
     if (!currentState) {
       return null;
     }
@@ -3110,7 +3025,7 @@ export class Room extends ReadReceipt {
   }
   roomNameGenerator(state) {
     if (this.client.roomNameGenerator) {
-      var name = this.client.roomNameGenerator(this.roomId, state);
+      const name = this.client.roomNameGenerator(this.roomId, state);
       if (name !== null) {
         return name;
       }
@@ -3121,13 +3036,13 @@ export class Room extends ReadReceipt {
       case RoomNameType.Generated:
         switch (state.subtype) {
           case "Inviting":
-            return "Inviting ".concat(memberNamesToRoomName(state.names, state.count));
+            return `Inviting ${memberNamesToRoomName(state.names, state.count)}`;
           default:
             return memberNamesToRoomName(state.names, state.count);
         }
       case RoomNameType.EmptyRoom:
         if (state.oldName) {
-          return "Empty room (was ".concat(state.oldName, ")");
+          return `Empty room (was ${state.oldName})`;
         } else {
           return "Empty room";
         }
@@ -3143,11 +3058,9 @@ export class Room extends ReadReceipt {
    * was no m.room.name event.
    * @returns The calculated room name.
    */
-  calculateRoomName(userId) {
-    var ignoreRoomNameEvent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  calculateRoomName(userId, ignoreRoomNameEvent = false) {
     if (!ignoreRoomNameEvent) {
-      var _this$currentState$ge4;
-      var name = (_this$currentState$ge4 = this.currentState.getStateEvents(EventType.RoomName, "")) === null || _this$currentState$ge4 === void 0 ? void 0 : _this$currentState$ge4.getContent().name;
+      const name = this.currentState.getStateEvents(EventType.RoomName, "")?.getContent().name;
       if (name && typeof name === "string") {
         return this.roomNameGenerator({
           type: RoomNameType.Actual,
@@ -3155,23 +3068,23 @@ export class Room extends ReadReceipt {
         });
       }
     }
-    var alias = this.getCanonicalAlias();
+    const alias = this.getCanonicalAlias();
     if (alias) {
       return this.roomNameGenerator({
         type: RoomNameType.Actual,
         name: alias
       });
     }
-    var joinedMemberCount = this.currentState.getJoinedMemberCount();
-    var invitedMemberCount = this.currentState.getInvitedMemberCount();
+    const joinedMemberCount = this.currentState.getJoinedMemberCount();
+    const invitedMemberCount = this.currentState.getInvitedMemberCount();
     // -1 because these numbers include the syncing user
-    var inviteJoinCount = joinedMemberCount + invitedMemberCount - 1;
+    let inviteJoinCount = joinedMemberCount + invitedMemberCount - 1;
 
     // get service members (e.g. helper bots) for exclusion
-    var excludedUserIds = this.getFunctionalMembers();
+    const excludedUserIds = this.getFunctionalMembers();
 
     // get members from heroes that are NOT ourselves
-    var otherNames = [];
+    let otherNames = [];
     if (this.heroes) {
       // if we have heroes, use those as the names
       this.heroes.forEach(hero => {
@@ -3186,16 +3099,17 @@ export class Room extends ReadReceipt {
         if (hero.displayName) {
           otherNames.push(hero.displayName);
         } else {
-          var member = this.getMember(hero.userId);
+          const member = this.getMember(hero.userId);
           otherNames.push(member ? member.name : hero.userId);
         }
       });
     } else {
-      var otherMembers = this.currentState.getMembers().filter(m => {
+      let otherMembers = this.currentState.getMembers().filter(m => {
         return m.userId !== userId && (m.membership === KnownMembership.Invite || m.membership === KnownMembership.Join);
       });
-      otherMembers = otherMembers.filter(_ref20 => {
-        var userId = _ref20.userId;
+      otherMembers = otherMembers.filter(({
+        userId
+      }) => {
         // filter service members
         if (excludedUserIds.includes(userId)) {
           inviteJoinCount--;
@@ -3204,7 +3118,7 @@ export class Room extends ReadReceipt {
         return true;
       });
       // make sure members have stable order
-      var collator = new Intl.Collator();
+      const collator = new Intl.Collator();
       otherMembers.sort((a, b) => collator.compare(a.userId, b.userId));
       // only 5 first members, immitate summaryHeroes
       otherMembers = otherMembers.slice(0, 5);
@@ -3217,13 +3131,13 @@ export class Room extends ReadReceipt {
         count: inviteJoinCount
       });
     }
-    var myMembership = this.getMyMembership();
+    const myMembership = this.getMyMembership();
     // if I have created a room and invited people through
     // 3rd party invites
     if (myMembership == KnownMembership.Join) {
-      var thirdPartyInvites = this.currentState.getStateEvents(EventType.RoomThirdPartyInvite);
-      if (thirdPartyInvites !== null && thirdPartyInvites !== void 0 && thirdPartyInvites.length) {
-        var thirdPartyNames = thirdPartyInvites.map(i => {
+      const thirdPartyInvites = this.currentState.getStateEvents(EventType.RoomThirdPartyInvite);
+      if (thirdPartyInvites?.length) {
+        const thirdPartyNames = thirdPartyInvites.map(i => {
           return i.getContent().display_name;
         });
         return this.roomNameGenerator({
@@ -3236,14 +3150,14 @@ export class Room extends ReadReceipt {
     }
 
     // let's try to figure out who was here before
-    var leftNames = otherNames;
+    let leftNames = otherNames;
     // if we didn't have heroes, try finding them in the room state
     if (!leftNames.length) {
       leftNames = this.currentState.getMembers().filter(m => {
         return m.userId !== userId && m.membership !== KnownMembership.Invite && m.membership !== KnownMembership.Join;
       }).map(m => m.name);
     }
-    var oldName;
+    let oldName;
     if (leftNames.length) {
       oldName = this.roomNameGenerator({
         type: RoomNameType.Generated,
@@ -3266,18 +3180,18 @@ export class Room extends ReadReceipt {
    *   patch it to reflect the visibility change and inform listeners.
    */
   applyNewVisibilityEvent(event) {
-    var visibilityChange = event.asVisibilityChange();
+    const visibilityChange = event.asVisibilityChange();
     if (!visibilityChange) {
       // The event is ill-formed.
       return;
     }
 
     // Ignore visibility change events that are not emitted by moderators.
-    var userId = event.getSender();
+    const userId = event.getSender();
     if (!userId) {
       return;
     }
-    var isPowerSufficient = EVENT_VISIBILITY_CHANGE_TYPE.name && this.currentState.maySendStateEvent(EVENT_VISIBILITY_CHANGE_TYPE.name, userId) || EVENT_VISIBILITY_CHANGE_TYPE.altName && this.currentState.maySendStateEvent(EVENT_VISIBILITY_CHANGE_TYPE.altName, userId);
+    const isPowerSufficient = EVENT_VISIBILITY_CHANGE_TYPE.name && this.currentState.maySendStateEvent(EVENT_VISIBILITY_CHANGE_TYPE.name, userId) || EVENT_VISIBILITY_CHANGE_TYPE.altName && this.currentState.maySendStateEvent(EVENT_VISIBILITY_CHANGE_TYPE.altName, userId);
     if (!isPowerSufficient) {
       // Powerlevel is insufficient.
       return;
@@ -3287,7 +3201,7 @@ export class Room extends ReadReceipt {
     // If the event is not in our timeline and we only receive it later,
     // we may need to apply the visibility change at a later date.
 
-    var visibilityEventsOnOriginalEvent = this.visibilityEvents.get(visibilityChange.eventId);
+    const visibilityEventsOnOriginalEvent = this.visibilityEvents.get(visibilityChange.eventId);
     if (visibilityEventsOnOriginalEvent) {
       // It would be tempting to simply erase the latest visibility change
       // but we need to record all of the changes in case the latest change
@@ -3296,10 +3210,10 @@ export class Room extends ReadReceipt {
       // In practice, linear scans through `visibilityEvents` should be fast.
       // However, to protect against a potential DoS attack, we limit the
       // number of iterations in this loop.
-      var index = visibilityEventsOnOriginalEvent.length - 1;
-      var min = Math.max(0, visibilityEventsOnOriginalEvent.length - MAX_NUMBER_OF_VISIBILITY_EVENTS_TO_SCAN_THROUGH);
+      let index = visibilityEventsOnOriginalEvent.length - 1;
+      const min = Math.max(0, visibilityEventsOnOriginalEvent.length - MAX_NUMBER_OF_VISIBILITY_EVENTS_TO_SCAN_THROUGH);
       for (; index >= min; --index) {
-        var target = visibilityEventsOnOriginalEvent[index];
+        const target = visibilityEventsOnOriginalEvent[index];
         if (target.getTs() < event.getTs()) {
           break;
         }
@@ -3316,7 +3230,7 @@ export class Room extends ReadReceipt {
     // Finally, let's check if the event is already in our timeline.
     // If so, we need to patch it and inform listeners.
 
-    var originalEvent = this.findEventById(visibilityChange.eventId);
+    const originalEvent = this.findEventById(visibilityChange.eventId);
     if (!originalEvent) {
       return;
     }
@@ -3327,16 +3241,16 @@ export class Room extends ReadReceipt {
     if (!event.isVisibilityEvent) {
       throw new Error("expected a visibility change event");
     }
-    var relation = event.getRelation();
-    var originalEventId = relation === null || relation === void 0 ? void 0 : relation.event_id;
-    var visibilityEventsOnOriginalEvent = this.visibilityEvents.get(originalEventId);
+    const relation = event.getRelation();
+    const originalEventId = relation?.event_id;
+    const visibilityEventsOnOriginalEvent = this.visibilityEvents.get(originalEventId);
     if (!visibilityEventsOnOriginalEvent) {
       // No visibility changes on the original event.
       // In particular, this change event was not recorded,
       // most likely because it was ill-formed.
       return;
     }
-    var index = visibilityEventsOnOriginalEvent.findIndex(change => change.getId() === event.getId());
+    const index = visibilityEventsOnOriginalEvent.findIndex(change => change.getId() === event.getId());
     if (index === -1) {
       // This change event was not recorded, most likely because
       // it was ill-formed.
@@ -3347,7 +3261,7 @@ export class Room extends ReadReceipt {
 
     // If we removed the latest visibility change event, propagate changes.
     if (index === visibilityEventsOnOriginalEvent.length) {
-      var originalEvent = this.findEventById(originalEventId);
+      const originalEvent = this.findEventById(originalEventId);
       if (!originalEvent) {
         return;
       }
@@ -3356,8 +3270,8 @@ export class Room extends ReadReceipt {
         this.visibilityEvents.delete(originalEventId);
         originalEvent.applyVisibilityEvent();
       } else {
-        var newEvent = visibilityEventsOnOriginalEvent[visibilityEventsOnOriginalEvent.length - 1];
-        var newVisibility = newEvent.asVisibilityChange();
+        const newEvent = visibilityEventsOnOriginalEvent[visibilityEventsOnOriginalEvent.length - 1];
+        const newVisibility = newEvent.asVisibilityChange();
         if (!newVisibility) {
           // Event is ill-formed.
           // This breaks our invariant.
@@ -3378,13 +3292,13 @@ export class Room extends ReadReceipt {
    * change event.
    */
   applyPendingVisibilityEvents(event) {
-    var visibilityEvents = this.visibilityEvents.get(event.getId());
+    const visibilityEvents = this.visibilityEvents.get(event.getId());
     if (!visibilityEvents || visibilityEvents.length == 0) {
       // No pending visibility change in store.
       return;
     }
-    var visibilityEvent = visibilityEvents[visibilityEvents.length - 1];
-    var visibilityChange = visibilityEvent.asVisibilityChange();
+    const visibilityEvent = visibilityEvents[visibilityEvents.length - 1];
+    const visibilityChange = visibilityEvent.asVisibilityChange();
     if (!visibilityChange) {
       return;
     }
@@ -3448,8 +3362,8 @@ export class Room extends ReadReceipt {
    */
   fixupNotifications(userId) {
     super.fixupNotifications(userId);
-    var unreadThreads = this.getThreads().filter(thread => this.getThreadUnreadNotificationCount(thread.id, NotificationCountType.Total) > 0);
-    for (var thread of unreadThreads) {
+    const unreadThreads = this.getThreads().filter(thread => this.getThreadUnreadNotificationCount(thread.id, NotificationCountType.Total) > 0);
+    for (const thread of unreadThreads) {
       thread.fixupNotifications(userId);
     }
   }
@@ -3484,13 +3398,12 @@ export class Room extends ReadReceipt {
    * will encrypt outgoing events).
    */
   hasEncryptionStateEvent() {
-    var _this$getLiveTimeline;
-    return Boolean((_this$getLiveTimeline = this.getLiveTimeline().getState(EventTimeline.FORWARDS)) === null || _this$getLiveTimeline === void 0 ? void 0 : _this$getLiveTimeline.getStateEvents(EventType.RoomEncryption, ""));
+    return Boolean(this.getLiveTimeline().getState(EventTimeline.FORWARDS)?.getStateEvents(EventType.RoomEncryption, ""));
   }
 }
 
 // a map from current event status to a list of allowed next statuses
-var ALLOWED_TRANSITIONS = {
+const ALLOWED_TRANSITIONS = {
   [EventStatus.ENCRYPTING]: [EventStatus.SENDING, EventStatus.NOT_SENT, EventStatus.CANCELLED],
   [EventStatus.SENDING]: [EventStatus.ENCRYPTING, EventStatus.QUEUED, EventStatus.NOT_SENT, EventStatus.SENT],
   [EventStatus.QUEUED]: [EventStatus.SENDING, EventStatus.NOT_SENT, EventStatus.CANCELLED],
@@ -3498,7 +3411,7 @@ var ALLOWED_TRANSITIONS = {
   [EventStatus.NOT_SENT]: [EventStatus.SENDING, EventStatus.QUEUED, EventStatus.CANCELLED],
   [EventStatus.CANCELLED]: []
 };
-export var RoomNameType = /*#__PURE__*/function (RoomNameType) {
+export let RoomNameType = /*#__PURE__*/function (RoomNameType) {
   RoomNameType[RoomNameType["EmptyRoom"] = 0] = "EmptyRoom";
   RoomNameType[RoomNameType["Generated"] = 1] = "Generated";
   RoomNameType[RoomNameType["Actual"] = 2] = "Actual";
@@ -3506,19 +3419,19 @@ export var RoomNameType = /*#__PURE__*/function (RoomNameType) {
 }({});
 // Can be overriden by IMatrixClientCreateOpts::memberNamesToRoomNameFn
 function memberNamesToRoomName(names, count) {
-  var countWithoutMe = count - 1;
+  const countWithoutMe = count - 1;
   if (!names.length) {
     return "Empty room";
   } else if (names.length === 1 && countWithoutMe <= 1) {
     return names[0];
   } else if (names.length === 2 && countWithoutMe <= 2) {
-    return "".concat(names[0], " and ").concat(names[1]);
+    return `${names[0]} and ${names[1]}`;
   } else {
-    var plural = countWithoutMe > 1;
+    const plural = countWithoutMe > 1;
     if (plural) {
-      return "".concat(names[0], " and ").concat(countWithoutMe, " others");
+      return `${names[0]} and ${countWithoutMe} others`;
     } else {
-      return "".concat(names[0], " and 1 other");
+      return `${names[0]} and 1 other`;
     }
   }
 }