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

package/lib/models/room.js

@@ -327,7 +327,6 @@ export class Room extends ReadReceipt {
         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());
           });
@@ -368,46 +367,6 @@ export class Room extends ReadReceipt {
     })();
   }
 
-  /**
-   * Bulk decrypt critical events in a room
-   *
-   * Critical events represents the minimal set of events to decrypt
-   * for a typical UI to function properly
-   *
-   * - Last event of every room (to generate likely message preview)
-   * - All events up to the read receipt (to calculate an accurate notification count)
-   *
-   * @returns Signals when all events have been decrypted
-   */
-  decryptCriticalEvents() {
-    var _this3 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this3.client.isCryptoEnabled()) 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);
-    })();
-  }
-
-  /**
-   * Bulk decrypt events in a room
-   *
-   * @returns Signals when all events have been decrypted
-   */
-  decryptAllEvents() {
-    var _this4 = this;
-    return _asyncToGenerator(function* () {
-      if (!_this4.client.isCryptoEnabled()) return;
-      var decryptionPromises = _this4.getUnfilteredTimelineSet().getLiveTimeline().getEvents().slice(0) // copy before reversing
-      .reverse().map(event => _this4.client.decryptEventIfNeeded(event));
-      yield Promise.allSettled(decryptionPromises);
-    })();
-  }
-
   /**
    * Gets the creator of the room
    * @returns The creator of the room, or null if it could not be determined
@@ -447,11 +406,11 @@ export class Room extends ReadReceipt {
    * Resolves to the version the room should be upgraded to.
    */
   getRecommendedVersion() {
-    var _this5 = this;
+    var _this3 = this;
     return _asyncToGenerator(function* () {
       var capabilities = {};
       try {
-        capabilities = yield _this5.client.getCapabilities();
+        capabilities = yield _this3.client.getCapabilities();
       } catch (_unused2) {}
       var versionCap = capabilities["m.room_versions"];
       if (!versionCap) {
@@ -463,7 +422,7 @@ export class Room extends ReadReceipt {
           versionCap.available[safeVer] = RoomVersionStability.Stable;
         }
       }
-      var result = _this5.checkVersionAgainstCapability(versionCap);
+      var result = _this3.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
@@ -473,7 +432,7 @@ export class Room extends ReadReceipt {
         // 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();
+          capabilities = yield _this3.client.fetchCapabilities();
         } catch (e) {
           logger.warn("Failed to refresh room version capabilities", e);
         }
@@ -482,7 +441,7 @@ export class Room extends ReadReceipt {
           logger.warn("No room version capability - assuming upgrade required.");
           return result;
         } else {
-          result = _this5.checkVersionAgainstCapability(versionCap);
+          result = _this3.checkVersionAgainstCapability(versionCap);
         }
       }
       return result;
@@ -799,30 +758,30 @@ export class Room extends ReadReceipt {
     }
   }
   loadMembersFromServer() {
-    var _this6 = this;
+    var _this4 = 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);
+      var lastSyncToken = _this4.client.store.getSyncToken();
+      var response = yield _this4.client.members(_this4.roomId, undefined, KnownMembership.Leave, lastSyncToken !== null && lastSyncToken !== void 0 ? lastSyncToken : undefined);
       return response.chunk;
     })();
   }
   loadMembers() {
-    var _this7 = this;
+    var _this5 = this;
     return _asyncToGenerator(function* () {
       // were the members loaded from the server?
       var fromServer = false;
-      var rawMembersEvents = yield _this7.client.store.getOutOfBandMembers(_this7.roomId);
+      var rawMembersEvents = yield _this5.client.store.getOutOfBandMembers(_this5.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()) {
+      if (rawMembersEvents === null || _this5.hasEncryptionStateEvent()) {
         fromServer = true;
-        rawMembersEvents = yield _this7.loadMembersFromServer();
-        logger.log("LL: got ".concat(rawMembersEvents.length, " ") + "members from server for room ".concat(_this7.roomId));
+        rawMembersEvents = yield _this5.loadMembersFromServer();
+        logger.log("LL: got ".concat(rawMembersEvents.length, " ") + "members from server for room ".concat(_this5.roomId));
       }
-      var memberEvents = rawMembersEvents.filter(noUnsafeEventProps).map(_this7.client.getEventMapper());
+      var memberEvents = rawMembersEvents.filter(noUnsafeEventProps).map(_this5.client.getEventMapper());
       return {
         memberEvents,
         fromServer
@@ -898,13 +857,13 @@ export class Room extends ReadReceipt {
    * Removes the lazily loaded members from storage if needed
    */
   clearLoadedMembersIfNeeded() {
-    var _this8 = this;
+    var _this6 = 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;
+      if (_this6.opts.lazyLoadMembers && _this6.membersPromise) {
+        yield _this6.loadMembersIfNeeded();
+        yield _this6.client.store.clearOutOfBandMembers(_this6.roomId);
+        _this6.currentState.clearOutOfBandMembers();
+        _this6.membersPromise = undefined;
       }
     })();
   }
@@ -934,17 +893,17 @@ export class Room extends ReadReceipt {
    * `room.getTimelineNeedsRefresh()`.
    */
   refreshLiveTimeline() {
-    var _this9 = this;
+    var _this7 = this;
     return _asyncToGenerator(function* () {
-      var liveTimelineBefore = _this9.getLiveTimeline();
+      var liveTimelineBefore = _this7.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));
+      logger.log("[refreshLiveTimeline for ".concat(_this7.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 timelineSet = _this7.getUnfilteredTimelineSet();
       var newTimeline;
       // If there isn't any event in the timeline, let's go fetch the latest
       // event and construct a timeline from it.
@@ -953,7 +912,7 @@ export class Room extends ReadReceipt {
       // with refreshing the timeline before which left them in a blank
       // timeline from `resetLiveTimeline`.
       if (!mostRecentEventInTimeline) {
-        newTimeline = yield _this9.client.getLatestTimeline(timelineSet);
+        newTimeline = yield _this7.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
@@ -962,21 +921,21 @@ export class Room extends ReadReceipt {
         // `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);
+        _this7.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);
+        _this7.emit(RoomEvent.TimelineRefresh, _this7, 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());
+        newTimeline = yield _this7.client.getEventTimeline(timelineSet, mostRecentEventInTimeline.getId());
       }
 
       // If a racing `/sync` beat us to creating a new timeline, use that
@@ -984,7 +943,7 @@ export class Room extends ReadReceipt {
       // 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"));
+        logger.log("[refreshLiveTimeline for ".concat(_this7.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
@@ -996,17 +955,17 @@ export class Room extends ReadReceipt {
         timelineSet.setLiveTimeline(newTimeline);
         // Fixup `this.oldstate` so that `scrollback` has the pagination tokens
         // available
-        _this9.fixUpLegacyTimelineFields();
+        _this7.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.");
+        logger.log("[refreshLiveTimeline for ".concat(_this7.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);
+      _this7.setTimelineNeedsRefresh(false);
 
       // Emit an event which clients can react to and re-load the timeline
       // from the SDK
-      _this9.emit(RoomEvent.TimelineRefresh, _this9, timelineSet);
+      _this7.emit(RoomEvent.TimelineRefresh, _this7, timelineSet);
     })();
   }
 
@@ -1569,12 +1528,12 @@ export class Room extends ReadReceipt {
    * we should encrypt messages for in this room.
    */
   getEncryptionTargetMembers() {
-    var _this10 = this;
+    var _this8 = this;
     return _asyncToGenerator(function* () {
-      yield _this10.loadMembersIfNeeded();
-      var members = _this10.getMembersWithMembership(KnownMembership.Join);
-      if (_this10.shouldEncryptForInvitedMembers()) {
-        members = members.concat(_this10.getMembersWithMembership(KnownMembership.Invite));
+      yield _this8.loadMembersIfNeeded();
+      var members = _this8.getMembersWithMembership(KnownMembership.Join);
+      if (_this8.shouldEncryptForInvitedMembers()) {
+        members = members.concat(_this8.getMembersWithMembership(KnownMembership.Invite));
       }
       return members;
     })();
@@ -1679,10 +1638,10 @@ export class Room extends ReadReceipt {
   }
   getThreadListFilter() {
     var _arguments = arguments,
-      _this11 = this;
+      _this9 = this;
     return _asyncToGenerator(function* () {
       var filterType = _arguments.length > 0 && _arguments[0] !== undefined ? _arguments[0] : ThreadFilterType.All;
-      var myUserId = _this11.client.getUserId();
+      var myUserId = _this9.client.getUserId();
       var filter = new Filter(myUserId);
       var definition = {
         room: {
@@ -1695,36 +1654,36 @@ export class Room extends ReadReceipt {
         definition.room.timeline[FILTER_RELATED_BY_SENDERS.name] = [myUserId];
       }
       filter.setDefinition(definition);
-      var filterId = yield _this11.client.getOrCreateFilter("THREAD_PANEL_".concat(_this11.roomId, "_").concat(filterType), filter);
+      var filterId = yield _this9.client.getOrCreateFilter("THREAD_PANEL_".concat(_this9.roomId, "_").concat(filterType), filter);
       filter.filterId = filterId;
       return filter;
     })();
   }
   createThreadTimelineSet(filterType) {
-    var _this12 = this;
+    var _this10 = this;
     return _asyncToGenerator(function* () {
       var timelineSet;
       if (Thread.hasServerSideListSupport) {
-        timelineSet = new EventTimelineSet(_this12, _objectSpread(_objectSpread({}, _this12.opts), {}, {
+        timelineSet = new EventTimelineSet(_this10, _objectSpread(_objectSpread({}, _this10.opts), {}, {
           pendingEvents: false
         }), undefined, undefined, filterType !== null && filterType !== void 0 ? filterType : ThreadFilterType.All);
-        _this12.reEmitter.reEmit(timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
+        _this10.reEmitter.reEmit(timelineSet, [RoomEvent.Timeline, RoomEvent.TimelineReset]);
       } else if (Thread.hasServerSideSupport) {
-        var filter = yield _this12.getThreadListFilter(filterType);
-        timelineSet = _this12.getOrCreateFilteredTimelineSet(filter, {
+        var filter = yield _this10.getThreadListFilter(filterType);
+        timelineSet = _this10.getOrCreateFilteredTimelineSet(filter, {
           prepopulateTimeline: false,
           useSyncEvents: false,
           pendingEvents: false
         });
       } else {
-        timelineSet = new EventTimelineSet(_this12, {
+        timelineSet = new EventTimelineSet(_this10, {
           pendingEvents: false
         });
-        Array.from(_this12.threads).forEach(_ref3 => {
+        Array.from(_this10.threads).forEach(_ref3 => {
           var [, thread] = _ref3;
           if (thread.length === 0) return;
           var currentUserParticipated = thread.timeline.some(event => {
-            return event.getSender() === _this12.client.getUserId();
+            return event.getSender() === _this10.client.getUserId();
           });
           if (filterType !== ThreadFilterType.My || currentUserParticipated) {
             timelineSet.getLiveTimeline().addEvent(thread.rootEvent, {
@@ -1755,22 +1714,22 @@ export class Room extends ReadReceipt {
    * Without server support that means fetching as much at once as the server allows us to.
    */
   fetchRoomThreads() {
-    var _this13 = this;
+    var _this11 = this;
     return _asyncToGenerator(function* () {
-      if (_this13.threadsReady || !_this13.client.supportsThreads()) {
+      if (_this11.threadsReady || !_this11.client.supportsThreads()) {
         return;
       }
       if (Thread.hasServerSideListSupport) {
-        yield Promise.all([_this13.fetchRoomThreadList(ThreadFilterType.All), _this13.fetchRoomThreadList(ThreadFilterType.My)]);
+        yield Promise.all([_this11.fetchRoomThreadList(ThreadFilterType.All), _this11.fetchRoomThreadList(ThreadFilterType.My)]);
       } else {
-        var allThreadsFilter = yield _this13.getThreadListFilter();
+        var allThreadsFilter = yield _this11.getThreadListFilter();
         var {
           chunk: events
-        } = yield _this13.client.createMessagesRequest(_this13.roomId, "", Number.MAX_SAFE_INTEGER, Direction.Backward, allThreadsFilter);
+        } = yield _this11.client.createMessagesRequest(_this11.roomId, "", Number.MAX_SAFE_INTEGER, Direction.Backward, allThreadsFilter);
         if (!events.length) return;
 
         // Sorted by last_reply origin_server_ts
-        var threadRoots = events.map(_this13.client.getEventMapper()).sort((eventA, eventB) => {
+        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
@@ -1781,33 +1740,27 @@ export class Room extends ReadReceipt {
           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 = _this13.getLiveTimeline().getState(EventTimeline.FORWARDS);
+        var roomState = _this11.getLiveTimeline().getState(EventTimeline.FORWARDS);
         for (var rootEvent of threadRoots) {
-          var _this13$threadsTimeli;
+          var _this11$threadsTimeli;
           var _opts = {
             duplicateStrategy: DuplicateStrategy.Ignore,
             fromCache: false,
             roomState
           };
-          (_this13$threadsTimeli = _this13.threadsTimelineSets[0]) === null || _this13$threadsTimeli === void 0 || _this13$threadsTimeli.addLiveEvent(rootEvent, _opts);
+          (_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 _this13$threadsTimeli2;
-            (_this13$threadsTimeli2 = _this13.threadsTimelineSets[1]) === null || _this13$threadsTimeli2 === void 0 || _this13$threadsTimeli2.addLiveEvent(rootEvent, _opts);
-            latestMyThreadsRootEvent = rootEvent;
+            var _this11$threadsTimeli2;
+            (_this11$threadsTimeli2 = _this11.threadsTimelineSets[1]) === null || _this11$threadsTimeli2 === void 0 || _this11$threadsTimeli2.addLiveEvent(rootEvent, _opts);
           }
         }
-        _this13.processThreadRoots(threadRoots, true);
-        _this13.client.decryptEventIfNeeded(threadRoots[threadRoots.length - 1]);
-        if (latestMyThreadsRootEvent) {
-          _this13.client.decryptEventIfNeeded(latestMyThreadsRootEvent);
-        }
+        _this11.processThreadRoots(threadRoots, true);
       }
-      _this13.on(ThreadEvent.NewReply, _this13.onThreadReply);
-      _this13.on(ThreadEvent.Update, _this13.onThreadUpdate);
-      _this13.on(ThreadEvent.Delete, _this13.onThreadDelete);
-      _this13.threadsReady = true;
+      _this11.on(ThreadEvent.NewReply, _this11.onThreadReply);
+      _this11.on(ThreadEvent.Update, _this11.onThreadUpdate);
+      _this11.on(ThreadEvent.Delete, _this11.onThreadDelete);
+      _this11.threadsReady = true;
     })();
   }
 
@@ -1817,7 +1770,7 @@ export class Room extends ReadReceipt {
    * @param events - List of events
    */
   processPollEvents(events) {
-    var _this14 = this;
+    var _this12 = this;
     return _asyncToGenerator(function* () {
       for (var event of events) {
         try {
@@ -1828,8 +1781,7 @@ export class Room extends ReadReceipt {
            * Try to decrypt the event. Promise resolution does not guarantee a successful decryption.
            * Retry is handled in {@link processPollEvent}.
            */
-          yield _this14.client.decryptEventIfNeeded(event);
-          _this14.processPollEvent(event);
+          _this12.processPollEvent(event);
         } catch (err) {
           logger.warn("Error processing poll event", event.getId(), err);
         }
@@ -1848,31 +1800,25 @@ export class Room extends ReadReceipt {
    * @param event - Event that could be a poll event
    */
   processPollEvent(event) {
-    var _this15 = this;
+    var _this13 = this;
     return _asyncToGenerator(function* () {
-      if (event.isDecryptionFailure()) {
-        event.once(MatrixEventEvent.Decrypted, maybeDecryptedEvent => {
-          _this15.processPollEvent(maybeDecryptedEvent);
-        });
-        return;
-      }
       if (M_POLL_START.matches(event.getType())) {
         try {
-          var poll = new Poll(event, _this15.client, _this15);
-          _this15.polls.set(event.getId(), poll);
-          _this15.emit(PollEvent.New, poll);
+          var poll = new Poll(event, _this13.client, _this13);
+          _this13.polls.set(event.getId(), poll);
+          _this13.emit(PollEvent.New, poll);
 
           // remove the poll when redacted
           event.once(MatrixEventEvent.BeforeRedaction, redactedEvent => {
-            _this15.polls.delete(redactedEvent.getId());
+            _this13.polls.delete(redactedEvent.getId());
           });
         } catch (_unused3) {}
         // poll creation can fail for malformed poll start events
         return;
       }
       var relationEventId = event.relationEventId;
-      if (relationEventId && _this15.polls.has(relationEventId)) {
-        var _poll = _this15.polls.get(relationEventId);
+      if (relationEventId && _this13.polls.has(relationEventId)) {
+        var _poll = _this13.polls.get(relationEventId);
         _poll === null || _poll === void 0 || _poll.onNewRelation(event);
       }
     })();
@@ -1883,20 +1829,20 @@ export class Room extends ReadReceipt {
    * @internal
    */
   fetchRoomThreadList(filter) {
-    var _this16 = this;
+    var _this14 = this;
     return _asyncToGenerator(function* () {
-      if (!_this16.client.supportsThreads()) return;
-      if (_this16.threadsTimelineSets.length === 0) return;
-      var timelineSet = filter === ThreadFilterType.My ? _this16.threadsTimelineSets[1] : _this16.threadsTimelineSets[0];
+      if (!_this14.client.supportsThreads()) return;
+      if (_this14.threadsTimelineSets.length === 0) return;
+      var timelineSet = filter === ThreadFilterType.My ? _this14.threadsTimelineSets[1] : _this14.threadsTimelineSets[0];
       var {
         chunk: events,
         end
-      } = yield _this16.client.createThreadListMessagesRequest(_this16.roomId, null, undefined, Direction.Backward, timelineSet.threadListType, timelineSet.getFilter());
+      } = yield _this14.client.createThreadListMessagesRequest(_this14.roomId, null, undefined, Direction.Backward, timelineSet.threadListType, timelineSet.getFilter());
       timelineSet.getLiveTimeline().setPaginationToken(end !== null && end !== void 0 ? end : null, Direction.Backward);
       if (!events.length) return;
-      var matrixEvents = events.map(_this16.client.getEventMapper());
-      _this16.processThreadRoots(matrixEvents, true);
-      var roomState = _this16.getLiveTimeline().getState(EventTimeline.FORWARDS);
+      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,
@@ -2479,7 +2425,7 @@ export class Room extends ReadReceipt {
    * @throws If `duplicateStrategy` is not falsey, 'replace' or 'ignore'.
    */
   addLiveEvents(events, addLiveEventOptions) {
-    var _this17 = this;
+    var _this15 = this;
     return _asyncToGenerator(function* () {
       var {
         duplicateStrategy,
@@ -2491,8 +2437,8 @@ export class Room extends ReadReceipt {
       }
 
       // sanity check that the live timeline is still live
-      _this17.assertTimelineSetsAreLive();
-      var threadRoots = _this17.findThreadRoots(events);
+      _this15.assertTimelineSetsAreLive();
+      var threadRoots = _this15.findThreadRoots(events);
       var eventsByThread = {};
       var options = {
         duplicateStrategy,
@@ -2505,12 +2451,12 @@ export class Room extends ReadReceipt {
       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".
-        _this17.processLiveEvent(event);
+        _this15.processLiveEvent(event);
         if (event.getUnsigned().transaction_id) {
-          var existingEvent = _this17.txnToEvent.get(event.getUnsigned().transaction_id);
+          var existingEvent = _this15.txnToEvent.get(event.getUnsigned().transaction_id);
           if (existingEvent) {
             // remote echo of an event we sent earlier
-            _this17.handleRemoteEcho(event, existingEvent);
+            _this15.handleRemoteEcho(event, existingEvent);
             continue; // we can skip adding the event to the timeline sets, it is already there
           }
         }
@@ -2518,10 +2464,10 @@ export class Room extends ReadReceipt {
           shouldLiveInRoom,
           shouldLiveInThread,
           threadId = ""
-        } = _this17.eventShouldLiveIn(event, neighbouringEvents, threadRoots);
+        } = _this15.eventShouldLiveIn(event, neighbouringEvents, threadRoots);
         if (!shouldLiveInThread && !shouldLiveInRoom && event.isRelation()) {
           try {
-            var parentEvent = new MatrixEvent(yield _this17.client.fetchRoomEvent(_this17.roomId, event.relationEventId));
+            var parentEvent = new MatrixEvent(yield _this15.client.fetchRoomEvent(_this15.roomId, event.relationEventId));
             neighbouringEvents.push(parentEvent);
             if (parentEvent.threadRootId) {
               threadRoots.add(parentEvent.threadRootId);
@@ -2533,7 +2479,7 @@ export class Room extends ReadReceipt {
               shouldLiveInRoom,
               shouldLiveInThread,
               threadId = ""
-            } = _this17.eventShouldLiveIn(event, neighbouringEvents, threadRoots));
+            } = _this15.eventShouldLiveIn(event, neighbouringEvents, threadRoots));
           } catch (e) {
             logger.error("Failed to load parent event of unhandled relation", e);
           }
@@ -2543,14 +2489,14 @@ export class Room extends ReadReceipt {
         }
         (_eventsByThread$threa = eventsByThread[threadId]) === null || _eventsByThread$threa === void 0 || _eventsByThread$threa.push(event);
         if (shouldLiveInRoom) {
-          _this17.addLiveEvent(event, options);
+          _this15.addLiveEvent(event, options);
         } else if (!shouldLiveInThread && event.isRelation()) {
-          _this17.relations.aggregateChildEvent(event);
+          _this15.relations.aggregateChildEvent(event);
         }
       }
       Object.entries(eventsByThread).forEach(_ref5 => {
         var [threadId, threadEvents] = _ref5;
-        _this17.addThreadedEvents(threadId, threadEvents, false);
+        _this15.addThreadedEvents(threadId, threadEvents, false);
       });
     })();
   }