@unwanted/matrix-sdk-mini 34.12.0-1

package/lib/timeline-window.js

@@ -0,0 +1,494 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+/*
+Copyright 2016 - 2021 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { EventTimeline } from "./models/event-timeline.js";
+import { logger } from "./logger.js";
+import { RoomEvent } from "./models/room.js";
+
+/**
+ * @internal
+ */
+var DEBUG = false;
+
+/**
+ * @internal
+ */
+/* istanbul ignore next */
+var debuglog = DEBUG ? logger.log.bind(logger) : function () {};
+
+/**
+ * the number of times we ask the server for more events before giving up
+ * this is currently higher than it needs to be to workaround lack of a filter
+ * for excluding thread responses from main timeline pagination which can cause
+ * giving up incorrectly - https://github.com/matrix-org/matrix-spec-proposals/pull/3874
+ *
+ * @internal
+ */
+var DEFAULT_PAGINATE_LOOP_LIMIT = 10;
+export class TimelineWindow {
+  /**
+   * Construct a TimelineWindow.
+   *
+   * <p>This abstracts the separate timelines in a Matrix {@link Room} into a single iterable thing.
+   * It keeps track of the start and endpoints of the window, which can be advanced with the help
+   * of pagination requests.
+   *
+   * <p>Before the window is useful, it must be initialised by calling {@link TimelineWindow#load}.
+   *
+   * <p>Note that the window will not automatically extend itself when new events
+   * are received from /sync; you should arrange to call {@link TimelineWindow#paginate}
+   * on {@link RoomEvent.Timeline} events.
+   *
+   * <p>Note that constructing an instance of this class for a room adds a
+   * listener for RoomEvent.Timeline events which is never removed. In theory
+   * this should not cause a leak since the EventEmitter uses weak mappings.
+   *
+   * @param client -   MatrixClient to be used for context/pagination
+   *   requests.
+   *
+   * @param timelineSet -  The timelineSet to track
+   *
+   * @param opts - Configuration options for this window
+   */
+  constructor(client, timelineSet) {
+    var _timelineSet$room;
+    var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    this.client = client;
+    this.timelineSet = timelineSet;
+    _defineProperty(this, "windowLimit", void 0);
+    // these will be TimelineIndex objects; they delineate the 'start' and
+    // 'end' of the window.
+    //
+    // start.index is inclusive; end.index is exclusive.
+    _defineProperty(this, "start", void 0);
+    _defineProperty(this, "end", void 0);
+    _defineProperty(this, "eventCount", 0);
+    this.windowLimit = opts.windowLimit || 1000;
+    (_timelineSet$room = timelineSet.room) === null || _timelineSet$room === void 0 || _timelineSet$room.on(RoomEvent.Timeline, this.onTimelineEvent.bind(this));
+  }
+
+  /**
+   * Initialise the window to point at a given event, or the live timeline
+   *
+   * @param initialEventId -   If given, the window will contain the
+   *    given event
+   * @param initialWindowSize -   Size of the initial window
+   */
+  load(initialEventId) {
+    var initialWindowSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 20;
+    // given an EventTimeline, find the event we were looking for, and initialise our
+    // fields so that the event in question is in the middle of the window.
+    var initFields = timeline => {
+      if (!timeline) {
+        throw new Error("No timeline given to initFields");
+      }
+      var eventIndex;
+      var events = timeline.getEvents();
+      if (!initialEventId) {
+        // we were looking for the live timeline: initialise to the end
+        eventIndex = events.length;
+      } else {
+        eventIndex = events.findIndex(e => e.getId() === initialEventId);
+        if (eventIndex < 0) {
+          throw new Error("getEventTimeline result didn't include requested event");
+        }
+      }
+      var endIndex = Math.min(events.length, eventIndex + Math.ceil(initialWindowSize / 2));
+      var startIndex = Math.max(0, endIndex - initialWindowSize);
+      this.start = new TimelineIndex(timeline, startIndex - timeline.getBaseIndex());
+      this.end = new TimelineIndex(timeline, endIndex - timeline.getBaseIndex());
+      this.eventCount = endIndex - startIndex;
+    };
+
+    // We avoid delaying the resolution of the promise by a reactor tick if we already have the data we need,
+    // which is important to keep room-switching feeling snappy.
+    if (this.timelineSet.getTimelineForEvent(initialEventId)) {
+      initFields(this.timelineSet.getTimelineForEvent(initialEventId));
+      return Promise.resolve();
+    } else if (initialEventId) {
+      return this.client.getEventTimeline(this.timelineSet, initialEventId).then(initFields);
+    } else {
+      initFields(this.timelineSet.getLiveTimeline());
+      return Promise.resolve();
+    }
+  }
+
+  /**
+   * Get the TimelineIndex of the window in the given direction.
+   *
+   * @param direction -   EventTimeline.BACKWARDS to get the TimelineIndex
+   * at the start of the window; EventTimeline.FORWARDS to get the TimelineIndex at
+   * the end.
+   *
+   * @returns The requested timeline index if one exists, null
+   * otherwise.
+   */
+  getTimelineIndex(direction) {
+    if (direction == EventTimeline.BACKWARDS) {
+      var _this$start;
+      return (_this$start = this.start) !== null && _this$start !== void 0 ? _this$start : null;
+    } else if (direction == EventTimeline.FORWARDS) {
+      var _this$end;
+      return (_this$end = this.end) !== null && _this$end !== void 0 ? _this$end : null;
+    } else {
+      throw new Error("Invalid direction '" + direction + "'");
+    }
+  }
+
+  /**
+   * Try to extend the window using events that are already in the underlying
+   * TimelineIndex.
+   *
+   * @param direction -   EventTimeline.BACKWARDS to try extending it
+   *   backwards; EventTimeline.FORWARDS to try extending it forwards.
+   * @param size -   number of events to try to extend by.
+   *
+   * @returns true if the window was extended, false otherwise.
+   */
+  extend(direction, size) {
+    var tl = this.getTimelineIndex(direction);
+    if (!tl) {
+      debuglog("TimelineWindow: no timeline yet");
+      return false;
+    }
+    var count = direction == EventTimeline.BACKWARDS ? tl.retreat(size) : tl.advance(size);
+    if (count) {
+      this.eventCount += count;
+      debuglog("TimelineWindow: increased cap by " + count + " (now " + this.eventCount + ")");
+      // remove some events from the other end, if necessary
+      var excess = this.eventCount - this.windowLimit;
+      if (excess > 0) {
+        this.unpaginate(excess, direction != EventTimeline.BACKWARDS);
+      }
+      return true;
+    }
+    return false;
+  }
+  onTimelineEvent(_event, _room, _atStart, removed) {
+    if (removed) {
+      this.onEventRemoved();
+    }
+  }
+
+  /**
+   * If an event was removed, meaning this window is longer than the timeline,
+   * shorten the window.
+   */
+  onEventRemoved() {
+    var events = this.getEvents();
+    if (events.length > 0 && events[events.length - 1] === undefined && this.end) {
+      this.end.index--;
+    }
+  }
+
+  /**
+   * Check if this window can be extended
+   *
+   * <p>This returns true if we either have more events, or if we have a
+   * pagination token which means we can paginate in that direction. It does not
+   * necessarily mean that there are more events available in that direction at
+   * this time.
+   *
+   * @param direction -   EventTimeline.BACKWARDS to check if we can
+   *   paginate backwards; EventTimeline.FORWARDS to check if we can go forwards
+   *
+   * @returns true if we can paginate in the given direction
+   */
+  canPaginate(direction) {
+    var tl = this.getTimelineIndex(direction);
+    if (!tl) {
+      debuglog("TimelineWindow: no timeline yet");
+      return false;
+    }
+    if (direction == EventTimeline.BACKWARDS) {
+      if (tl.index > tl.minIndex()) {
+        return true;
+      }
+    } else {
+      if (tl.index < tl.maxIndex()) {
+        return true;
+      }
+    }
+    var hasNeighbouringTimeline = tl.timeline.getNeighbouringTimeline(direction);
+    var paginationToken = tl.timeline.getPaginationToken(direction);
+    return Boolean(hasNeighbouringTimeline) || Boolean(paginationToken);
+  }
+
+  /**
+   * Attempt to extend the window
+   *
+   * @param direction -   EventTimeline.BACKWARDS to extend the window
+   *    backwards (towards older events); EventTimeline.FORWARDS to go forwards.
+   *
+   * @param size -   number of events to try to extend by. If fewer than this
+   *    number are immediately available, then we return immediately rather than
+   *    making an API call.
+   *
+   * @param makeRequest - whether we should make API calls to
+   *    fetch further events if we don't have any at all. (This has no effect if
+   *    the room already knows about additional events in the relevant direction,
+   *    even if there are fewer than 'size' of them, as we will just return those
+   *    we already know about.)
+   *
+   * @param requestLimit - limit for the number of API requests we
+   *    should make.
+   *
+   * @returns Promise which resolves to a boolean which is true if more events
+   *    were successfully retrieved.
+   */
+  paginate(direction, size) {
+    var _arguments = arguments,
+      _this = this;
+    return _asyncToGenerator(function* () {
+      var makeRequest = _arguments.length > 2 && _arguments[2] !== undefined ? _arguments[2] : true;
+      var requestLimit = _arguments.length > 3 && _arguments[3] !== undefined ? _arguments[3] : DEFAULT_PAGINATE_LOOP_LIMIT;
+      // Either wind back the message cap (if there are enough events in the
+      // timeline to do so), or fire off a pagination request.
+      var tl = _this.getTimelineIndex(direction);
+      if (!tl) {
+        debuglog("TimelineWindow: no timeline yet");
+        return false;
+      }
+      if (tl.pendingPaginate) {
+        return tl.pendingPaginate;
+      }
+
+      // try moving the cap
+      if (_this.extend(direction, size)) {
+        return true;
+      }
+      if (!makeRequest || requestLimit === 0) {
+        // todo: should we return something different to indicate that there
+        // might be more events out there, but we haven't found them yet?
+        return false;
+      }
+
+      // try making a pagination request
+      var token = tl.timeline.getPaginationToken(direction);
+      if (!token) {
+        debuglog("TimelineWindow: no token");
+        return false;
+      }
+      debuglog("TimelineWindow: starting request");
+      var prom = _this.client.paginateEventTimeline(tl.timeline, {
+        backwards: direction == EventTimeline.BACKWARDS,
+        limit: size
+      }).finally(function () {
+        tl.pendingPaginate = undefined;
+      }).then(r => {
+        debuglog("TimelineWindow: request completed with result " + r);
+        if (!r) {
+          return _this.paginate(direction, size, false, 0);
+        }
+
+        // recurse to advance the index into the results.
+        //
+        // If we don't get any new events, we want to make sure we keep asking
+        // the server for events for as long as we have a valid pagination
+        // token. In particular, we want to know if we've actually hit the
+        // start of the timeline, or if we just happened to know about all of
+        // the events thanks to https://matrix.org/jira/browse/SYN-645.
+        //
+        // On the other hand, we necessarily want to wait forever for the
+        // server to make its mind up about whether there are other events,
+        // because it gives a bad user experience
+        // (https://github.com/vector-im/vector-web/issues/1204).
+        return _this.paginate(direction, size, true, requestLimit - 1);
+      });
+      tl.pendingPaginate = prom;
+      return prom;
+    })();
+  }
+
+  /**
+   * Remove `delta` events from the start or end of the timeline.
+   *
+   * @param delta - number of events to remove from the timeline
+   * @param startOfTimeline - if events should be removed from the start
+   *     of the timeline.
+   */
+  unpaginate(delta, startOfTimeline) {
+    var tl = startOfTimeline ? this.start : this.end;
+    if (!tl) {
+      throw new Error("Attempting to unpaginate startOfTimeline=".concat(startOfTimeline, " but don't have this direction"));
+    }
+
+    // sanity-check the delta
+    if (delta > this.eventCount || delta < 0) {
+      throw new Error("Attemting to unpaginate ".concat(delta, " events, but only have ").concat(this.eventCount, " in the timeline"));
+    }
+    while (delta > 0) {
+      var count = startOfTimeline ? tl.advance(delta) : tl.retreat(delta);
+      if (count <= 0) {
+        // sadness. This shouldn't be possible.
+        throw new Error("Unable to unpaginate any further, but still have " + this.eventCount + " events");
+      }
+      delta -= count;
+      this.eventCount -= count;
+      debuglog("TimelineWindow.unpaginate: dropped " + count + " (now " + this.eventCount + ")");
+    }
+  }
+
+  /**
+   * Get a list of the events currently in the window
+   *
+   * @returns the events in the window
+   */
+  getEvents() {
+    if (!this.start) {
+      // not yet loaded
+      return [];
+    }
+    var result = [];
+
+    // iterate through each timeline between this.start and this.end
+    // (inclusive).
+    var timeline = this.start.timeline;
+    // eslint-disable-next-line no-constant-condition
+    while (timeline) {
+      var _this$end2, _this$end3;
+      var events = timeline.getEvents();
+
+      // For the first timeline in the chain, we want to start at
+      // this.start.index. For the last timeline in the chain, we want to
+      // stop before this.end.index. Otherwise, we want to copy all of the
+      // events in the timeline.
+      //
+      // (Note that both this.start.index and this.end.index are relative
+      // to their respective timelines' BaseIndex).
+      //
+      var startIndex = 0;
+      var endIndex = events.length;
+      if (timeline === this.start.timeline) {
+        startIndex = this.start.index + timeline.getBaseIndex();
+      }
+      if (timeline === ((_this$end2 = this.end) === null || _this$end2 === void 0 ? void 0 : _this$end2.timeline)) {
+        endIndex = this.end.index + timeline.getBaseIndex();
+      }
+      for (var i = startIndex; i < endIndex; i++) {
+        result.push(events[i]);
+      }
+
+      // if we're not done, iterate to the next timeline.
+      if (timeline === ((_this$end3 = this.end) === null || _this$end3 === void 0 ? void 0 : _this$end3.timeline)) {
+        break;
+      } else {
+        timeline = timeline.getNeighbouringTimeline(EventTimeline.FORWARDS);
+      }
+    }
+    return result;
+  }
+}
+
+/**
+ * A thing which contains a timeline reference, and an index into it.
+ * @internal
+ */
+export class TimelineIndex {
+  // index: the indexes are relative to BaseIndex, so could well be negative.
+  constructor(timeline, index) {
+    this.timeline = timeline;
+    this.index = index;
+    _defineProperty(this, "pendingPaginate", void 0);
+  }
+
+  /**
+   * @returns the minimum possible value for the index in the current
+   *    timeline
+   */
+  minIndex() {
+    return this.timeline.getBaseIndex() * -1;
+  }
+
+  /**
+   * @returns the maximum possible value for the index in the current
+   *    timeline (exclusive - ie, it actually returns one more than the index
+   *    of the last element).
+   */
+  maxIndex() {
+    return this.timeline.getEvents().length - this.timeline.getBaseIndex();
+  }
+
+  /**
+   * Try move the index forward, or into the neighbouring timeline
+   *
+   * @param delta -  number of events to advance by
+   * @returns number of events successfully advanced by
+   */
+  advance(delta) {
+    if (!delta) {
+      return 0;
+    }
+
+    // first try moving the index in the current timeline. See if there is room
+    // to do so.
+    var cappedDelta;
+    if (delta < 0) {
+      // we want to wind the index backwards.
+      //
+      // (this.minIndex() - this.index) is a negative number whose magnitude
+      // is the amount of room we have to wind back the index in the current
+      // timeline. We cap delta to this quantity.
+      cappedDelta = Math.max(delta, this.minIndex() - this.index);
+      if (cappedDelta < 0) {
+        this.index += cappedDelta;
+        return cappedDelta;
+      }
+    } else {
+      // we want to wind the index forwards.
+      //
+      // (this.maxIndex() - this.index) is a (positive) number whose magnitude
+      // is the amount of room we have to wind forward the index in the current
+      // timeline. We cap delta to this quantity.
+      cappedDelta = Math.min(delta, this.maxIndex() - this.index);
+      if (cappedDelta > 0) {
+        this.index += cappedDelta;
+        return cappedDelta;
+      }
+    }
+
+    // the index is already at the start/end of the current timeline.
+    //
+    // next see if there is a neighbouring timeline to switch to.
+    var neighbour = this.timeline.getNeighbouringTimeline(delta < 0 ? EventTimeline.BACKWARDS : EventTimeline.FORWARDS);
+    if (neighbour) {
+      this.timeline = neighbour;
+      if (delta < 0) {
+        this.index = this.maxIndex();
+      } else {
+        this.index = this.minIndex();
+      }
+      debuglog("paginate: switched to new neighbour");
+
+      // recurse, using the next timeline
+      return this.advance(delta);
+    }
+    return 0;
+  }
+
+  /**
+   * Try move the index backwards, or into the neighbouring timeline
+   *
+   * @param delta -  number of events to retreat by
+   * @returns number of events successfully retreated by
+   */
+  retreat(delta) {
+    return this.advance(delta * -1) * -1;
+  }
+}
+//# sourceMappingURL=timeline-window.js.map

package/lib/timeline-window.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline-window.js","names":["EventTimeline","logger","RoomEvent","DEBUG","debuglog","log","bind","DEFAULT_PAGINATE_LOOP_LIMIT","TimelineWindow","constructor","client","timelineSet","_timelineSet$room","opts","arguments","length","undefined","_defineProperty","windowLimit","room","on","Timeline","onTimelineEvent","load","initialEventId","initialWindowSize","initFields","timeline","Error","eventIndex","events","getEvents","findIndex","e","getId","endIndex","Math","min","ceil","startIndex","max","start","TimelineIndex","getBaseIndex","end","eventCount","getTimelineForEvent","Promise","resolve","getEventTimeline","then","getLiveTimeline","getTimelineIndex","direction","BACKWARDS","_this$start","FORWARDS","_this$end","extend","size","tl","count","retreat","advance","excess","unpaginate","_event","_room","_atStart","removed","onEventRemoved","index","canPaginate","minIndex","maxIndex","hasNeighbouringTimeline","getNeighbouringTimeline","paginationToken","getPaginationToken","Boolean","paginate","_arguments","_this","_asyncToGenerator","makeRequest","requestLimit","pendingPaginate","token","prom","paginateEventTimeline","backwards","limit","finally","r","delta","startOfTimeline","concat","result","_this$end2","_this$end3","i","push","cappedDelta","neighbour"],"sources":["../src/timeline-window.ts"],"sourcesContent":["/*\nCopyright 2016 - 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { Optional } from \"matrix-events-sdk\";\n\nimport { Direction, EventTimeline } from \"./models/event-timeline.ts\";\nimport { logger } from \"./logger.ts\";\nimport { MatrixClient } from \"./client.ts\";\nimport { EventTimelineSet } from \"./models/event-timeline-set.ts\";\nimport { MatrixEvent } from \"./models/event.ts\";\nimport { Room, RoomEvent } from \"./models/room.ts\";\n\n/**\n * @internal\n */\nconst DEBUG = false;\n\n/**\n * @internal\n */\n/* istanbul ignore next */\nconst debuglog = DEBUG ? logger.log.bind(logger) : function (): void {};\n\n/**\n * the number of times we ask the server for more events before giving up\n * this is currently higher than it needs to be to workaround lack of a filter\n * for excluding thread responses from main timeline pagination which can cause\n * giving up incorrectly - https://github.com/matrix-org/matrix-spec-proposals/pull/3874\n *\n * @internal\n */\nconst DEFAULT_PAGINATE_LOOP_LIMIT = 10;\n\ninterface IOpts {\n    /**\n     * Maximum number of events to keep in the window. If more events are retrieved via pagination requests,\n     * excess events will be dropped from the other end of the window.\n     */\n    windowLimit?: number;\n}\n\nexport class TimelineWindow {\n    private readonly windowLimit: number;\n    // these will be TimelineIndex objects; they delineate the 'start' and\n    // 'end' of the window.\n    //\n    // start.index is inclusive; end.index is exclusive.\n    private start?: TimelineIndex;\n    private end?: TimelineIndex;\n    private eventCount = 0;\n\n    /**\n     * Construct a TimelineWindow.\n     *\n     * <p>This abstracts the separate timelines in a Matrix {@link Room} into a single iterable thing.\n     * It keeps track of the start and endpoints of the window, which can be advanced with the help\n     * of pagination requests.\n     *\n     * <p>Before the window is useful, it must be initialised by calling {@link TimelineWindow#load}.\n     *\n     * <p>Note that the window will not automatically extend itself when new events\n     * are received from /sync; you should arrange to call {@link TimelineWindow#paginate}\n     * on {@link RoomEvent.Timeline} events.\n     *\n     * <p>Note that constructing an instance of this class for a room adds a\n     * listener for RoomEvent.Timeline events which is never removed. In theory\n     * this should not cause a leak since the EventEmitter uses weak mappings.\n     *\n     * @param client -   MatrixClient to be used for context/pagination\n     *   requests.\n     *\n     * @param timelineSet -  The timelineSet to track\n     *\n     * @param opts - Configuration options for this window\n     */\n    public constructor(\n        private readonly client: MatrixClient,\n        private readonly timelineSet: EventTimelineSet,\n        opts: IOpts = {},\n    ) {\n        this.windowLimit = opts.windowLimit || 1000;\n        timelineSet.room?.on(RoomEvent.Timeline, this.onTimelineEvent.bind(this));\n    }\n\n    /**\n     * Initialise the window to point at a given event, or the live timeline\n     *\n     * @param initialEventId -   If given, the window will contain the\n     *    given event\n     * @param initialWindowSize -   Size of the initial window\n     */\n    public load(initialEventId?: string, initialWindowSize = 20): Promise<void> {\n        // given an EventTimeline, find the event we were looking for, and initialise our\n        // fields so that the event in question is in the middle of the window.\n        const initFields = (timeline: Optional<EventTimeline>): void => {\n            if (!timeline) {\n                throw new Error(\"No timeline given to initFields\");\n            }\n\n            let eventIndex: number;\n\n            const events = timeline.getEvents();\n\n            if (!initialEventId) {\n                // we were looking for the live timeline: initialise to the end\n                eventIndex = events.length;\n            } else {\n                eventIndex = events.findIndex((e) => e.getId() === initialEventId);\n\n                if (eventIndex < 0) {\n                    throw new Error(\"getEventTimeline result didn't include requested event\");\n                }\n            }\n\n            const endIndex = Math.min(events.length, eventIndex + Math.ceil(initialWindowSize / 2));\n            const startIndex = Math.max(0, endIndex - initialWindowSize);\n            this.start = new TimelineIndex(timeline, startIndex - timeline.getBaseIndex());\n            this.end = new TimelineIndex(timeline, endIndex - timeline.getBaseIndex());\n            this.eventCount = endIndex - startIndex;\n        };\n\n        // We avoid delaying the resolution of the promise by a reactor tick if we already have the data we need,\n        // which is important to keep room-switching feeling snappy.\n        if (this.timelineSet.getTimelineForEvent(initialEventId)) {\n            initFields(this.timelineSet.getTimelineForEvent(initialEventId));\n            return Promise.resolve();\n        } else if (initialEventId) {\n            return this.client.getEventTimeline(this.timelineSet, initialEventId).then(initFields);\n        } else {\n            initFields(this.timelineSet.getLiveTimeline());\n            return Promise.resolve();\n        }\n    }\n\n    /**\n     * Get the TimelineIndex of the window in the given direction.\n     *\n     * @param direction -   EventTimeline.BACKWARDS to get the TimelineIndex\n     * at the start of the window; EventTimeline.FORWARDS to get the TimelineIndex at\n     * the end.\n     *\n     * @returns The requested timeline index if one exists, null\n     * otherwise.\n     */\n    public getTimelineIndex(direction: Direction): TimelineIndex | null {\n        if (direction == EventTimeline.BACKWARDS) {\n            return this.start ?? null;\n        } else if (direction == EventTimeline.FORWARDS) {\n            return this.end ?? null;\n        } else {\n            throw new Error(\"Invalid direction '\" + direction + \"'\");\n        }\n    }\n\n    /**\n     * Try to extend the window using events that are already in the underlying\n     * TimelineIndex.\n     *\n     * @param direction -   EventTimeline.BACKWARDS to try extending it\n     *   backwards; EventTimeline.FORWARDS to try extending it forwards.\n     * @param size -   number of events to try to extend by.\n     *\n     * @returns true if the window was extended, false otherwise.\n     */\n    public extend(direction: Direction, size: number): boolean {\n        const tl = this.getTimelineIndex(direction);\n\n        if (!tl) {\n            debuglog(\"TimelineWindow: no timeline yet\");\n            return false;\n        }\n\n        const count = direction == EventTimeline.BACKWARDS ? tl.retreat(size) : tl.advance(size);\n\n        if (count) {\n            this.eventCount += count;\n            debuglog(\"TimelineWindow: increased cap by \" + count + \" (now \" + this.eventCount + \")\");\n            // remove some events from the other end, if necessary\n            const excess = this.eventCount - this.windowLimit;\n            if (excess > 0) {\n                this.unpaginate(excess, direction != EventTimeline.BACKWARDS);\n            }\n            return true;\n        }\n\n        return false;\n    }\n\n    private onTimelineEvent(_event?: MatrixEvent, _room?: Room, _atStart?: boolean, removed?: boolean): void {\n        if (removed) {\n            this.onEventRemoved();\n        }\n    }\n\n    /**\n     * If an event was removed, meaning this window is longer than the timeline,\n     * shorten the window.\n     */\n    private onEventRemoved(): void {\n        const events = this.getEvents();\n        if (events.length > 0 && events[events.length - 1] === undefined && this.end) {\n            this.end.index--;\n        }\n    }\n\n    /**\n     * Check if this window can be extended\n     *\n     * <p>This returns true if we either have more events, or if we have a\n     * pagination token which means we can paginate in that direction. It does not\n     * necessarily mean that there are more events available in that direction at\n     * this time.\n     *\n     * @param direction -   EventTimeline.BACKWARDS to check if we can\n     *   paginate backwards; EventTimeline.FORWARDS to check if we can go forwards\n     *\n     * @returns true if we can paginate in the given direction\n     */\n    public canPaginate(direction: Direction): boolean {\n        const tl = this.getTimelineIndex(direction);\n\n        if (!tl) {\n            debuglog(\"TimelineWindow: no timeline yet\");\n            return false;\n        }\n\n        if (direction == EventTimeline.BACKWARDS) {\n            if (tl.index > tl.minIndex()) {\n                return true;\n            }\n        } else {\n            if (tl.index < tl.maxIndex()) {\n                return true;\n            }\n        }\n\n        const hasNeighbouringTimeline = tl.timeline.getNeighbouringTimeline(direction);\n        const paginationToken = tl.timeline.getPaginationToken(direction);\n        return Boolean(hasNeighbouringTimeline) || Boolean(paginationToken);\n    }\n\n    /**\n     * Attempt to extend the window\n     *\n     * @param direction -   EventTimeline.BACKWARDS to extend the window\n     *    backwards (towards older events); EventTimeline.FORWARDS to go forwards.\n     *\n     * @param size -   number of events to try to extend by. If fewer than this\n     *    number are immediately available, then we return immediately rather than\n     *    making an API call.\n     *\n     * @param makeRequest - whether we should make API calls to\n     *    fetch further events if we don't have any at all. (This has no effect if\n     *    the room already knows about additional events in the relevant direction,\n     *    even if there are fewer than 'size' of them, as we will just return those\n     *    we already know about.)\n     *\n     * @param requestLimit - limit for the number of API requests we\n     *    should make.\n     *\n     * @returns Promise which resolves to a boolean which is true if more events\n     *    were successfully retrieved.\n     */\n    public async paginate(\n        direction: Direction,\n        size: number,\n        makeRequest = true,\n        requestLimit = DEFAULT_PAGINATE_LOOP_LIMIT,\n    ): Promise<boolean> {\n        // Either wind back the message cap (if there are enough events in the\n        // timeline to do so), or fire off a pagination request.\n        const tl = this.getTimelineIndex(direction);\n\n        if (!tl) {\n            debuglog(\"TimelineWindow: no timeline yet\");\n            return false;\n        }\n\n        if (tl.pendingPaginate) {\n            return tl.pendingPaginate;\n        }\n\n        // try moving the cap\n        if (this.extend(direction, size)) {\n            return true;\n        }\n\n        if (!makeRequest || requestLimit === 0) {\n            // todo: should we return something different to indicate that there\n            // might be more events out there, but we haven't found them yet?\n            return false;\n        }\n\n        // try making a pagination request\n        const token = tl.timeline.getPaginationToken(direction);\n        if (!token) {\n            debuglog(\"TimelineWindow: no token\");\n            return false;\n        }\n\n        debuglog(\"TimelineWindow: starting request\");\n\n        const prom = this.client\n            .paginateEventTimeline(tl.timeline, {\n                backwards: direction == EventTimeline.BACKWARDS,\n                limit: size,\n            })\n            .finally(function () {\n                tl.pendingPaginate = undefined;\n            })\n            .then((r) => {\n                debuglog(\"TimelineWindow: request completed with result \" + r);\n                if (!r) {\n                    return this.paginate(direction, size, false, 0);\n                }\n\n                // recurse to advance the index into the results.\n                //\n                // If we don't get any new events, we want to make sure we keep asking\n                // the server for events for as long as we have a valid pagination\n                // token. In particular, we want to know if we've actually hit the\n                // start of the timeline, or if we just happened to know about all of\n                // the events thanks to https://matrix.org/jira/browse/SYN-645.\n                //\n                // On the other hand, we necessarily want to wait forever for the\n                // server to make its mind up about whether there are other events,\n                // because it gives a bad user experience\n                // (https://github.com/vector-im/vector-web/issues/1204).\n                return this.paginate(direction, size, true, requestLimit - 1);\n            });\n        tl.pendingPaginate = prom;\n        return prom;\n    }\n\n    /**\n     * Remove `delta` events from the start or end of the timeline.\n     *\n     * @param delta - number of events to remove from the timeline\n     * @param startOfTimeline - if events should be removed from the start\n     *     of the timeline.\n     */\n    public unpaginate(delta: number, startOfTimeline: boolean): void {\n        const tl = startOfTimeline ? this.start : this.end;\n        if (!tl) {\n            throw new Error(\n                `Attempting to unpaginate startOfTimeline=${startOfTimeline} but don't have this direction`,\n            );\n        }\n\n        // sanity-check the delta\n        if (delta > this.eventCount || delta < 0) {\n            throw new Error(\n                `Attemting to unpaginate ${delta} events, but only have ${this.eventCount} in the timeline`,\n            );\n        }\n\n        while (delta > 0) {\n            const count = startOfTimeline ? tl.advance(delta) : tl.retreat(delta);\n            if (count <= 0) {\n                // sadness. This shouldn't be possible.\n                throw new Error(\"Unable to unpaginate any further, but still have \" + this.eventCount + \" events\");\n            }\n\n            delta -= count;\n            this.eventCount -= count;\n            debuglog(\"TimelineWindow.unpaginate: dropped \" + count + \" (now \" + this.eventCount + \")\");\n        }\n    }\n\n    /**\n     * Get a list of the events currently in the window\n     *\n     * @returns the events in the window\n     */\n    public getEvents(): MatrixEvent[] {\n        if (!this.start) {\n            // not yet loaded\n            return [];\n        }\n\n        const result: MatrixEvent[] = [];\n\n        // iterate through each timeline between this.start and this.end\n        // (inclusive).\n        let timeline: EventTimeline | null = this.start.timeline;\n        // eslint-disable-next-line no-constant-condition\n        while (timeline) {\n            const events = timeline.getEvents();\n\n            // For the first timeline in the chain, we want to start at\n            // this.start.index. For the last timeline in the chain, we want to\n            // stop before this.end.index. Otherwise, we want to copy all of the\n            // events in the timeline.\n            //\n            // (Note that both this.start.index and this.end.index are relative\n            // to their respective timelines' BaseIndex).\n            //\n            let startIndex = 0;\n            let endIndex = events.length;\n            if (timeline === this.start.timeline) {\n                startIndex = this.start.index + timeline.getBaseIndex();\n            }\n            if (timeline === this.end?.timeline) {\n                endIndex = this.end.index + timeline.getBaseIndex();\n            }\n\n            for (let i = startIndex; i < endIndex; i++) {\n                result.push(events[i]);\n            }\n\n            // if we're not done, iterate to the next timeline.\n            if (timeline === this.end?.timeline) {\n                break;\n            } else {\n                timeline = timeline.getNeighbouringTimeline(EventTimeline.FORWARDS);\n            }\n        }\n\n        return result;\n    }\n}\n\n/**\n * A thing which contains a timeline reference, and an index into it.\n * @internal\n */\nexport class TimelineIndex {\n    public pendingPaginate?: Promise<boolean>;\n\n    // index: the indexes are relative to BaseIndex, so could well be negative.\n    public constructor(\n        public timeline: EventTimeline,\n        public index: number,\n    ) {}\n\n    /**\n     * @returns the minimum possible value for the index in the current\n     *    timeline\n     */\n    public minIndex(): number {\n        return this.timeline.getBaseIndex() * -1;\n    }\n\n    /**\n     * @returns the maximum possible value for the index in the current\n     *    timeline (exclusive - ie, it actually returns one more than the index\n     *    of the last element).\n     */\n    public maxIndex(): number {\n        return this.timeline.getEvents().length - this.timeline.getBaseIndex();\n    }\n\n    /**\n     * Try move the index forward, or into the neighbouring timeline\n     *\n     * @param delta -  number of events to advance by\n     * @returns number of events successfully advanced by\n     */\n    public advance(delta: number): number {\n        if (!delta) {\n            return 0;\n        }\n\n        // first try moving the index in the current timeline. See if there is room\n        // to do so.\n        let cappedDelta;\n        if (delta < 0) {\n            // we want to wind the index backwards.\n            //\n            // (this.minIndex() - this.index) is a negative number whose magnitude\n            // is the amount of room we have to wind back the index in the current\n            // timeline. We cap delta to this quantity.\n            cappedDelta = Math.max(delta, this.minIndex() - this.index);\n            if (cappedDelta < 0) {\n                this.index += cappedDelta;\n                return cappedDelta;\n            }\n        } else {\n            // we want to wind the index forwards.\n            //\n            // (this.maxIndex() - this.index) is a (positive) number whose magnitude\n            // is the amount of room we have to wind forward the index in the current\n            // timeline. We cap delta to this quantity.\n            cappedDelta = Math.min(delta, this.maxIndex() - this.index);\n            if (cappedDelta > 0) {\n                this.index += cappedDelta;\n                return cappedDelta;\n            }\n        }\n\n        // the index is already at the start/end of the current timeline.\n        //\n        // next see if there is a neighbouring timeline to switch to.\n        const neighbour = this.timeline.getNeighbouringTimeline(\n            delta < 0 ? EventTimeline.BACKWARDS : EventTimeline.FORWARDS,\n        );\n        if (neighbour) {\n            this.timeline = neighbour;\n            if (delta < 0) {\n                this.index = this.maxIndex();\n            } else {\n                this.index = this.minIndex();\n            }\n\n            debuglog(\"paginate: switched to new neighbour\");\n\n            // recurse, using the next timeline\n            return this.advance(delta);\n        }\n\n        return 0;\n    }\n\n    /**\n     * Try move the index backwards, or into the neighbouring timeline\n     *\n     * @param delta -  number of events to retreat by\n     * @returns number of events successfully retreated by\n     */\n    public retreat(delta: number): number {\n        return this.advance(delta * -1) * -1;\n    }\n}\n"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAIA,SAAoBA,aAAa,QAAQ,4BAA4B;AACrE,SAASC,MAAM,QAAQ,aAAa;AAIpC,SAAeC,SAAS,QAAQ,kBAAkB;;AAElD;AACA;AACA;AACA,IAAMC,KAAK,GAAG,KAAK;;AAEnB;AACA;AACA;AACA;AACA,IAAMC,QAAQ,GAAGD,KAAK,GAAGF,MAAM,CAACI,GAAG,CAACC,IAAI,CAACL,MAAM,CAAC,GAAG,YAAkB,CAAC,CAAC;;AAEvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAMM,2BAA2B,GAAG,EAAE;AAUtC,OAAO,MAAMC,cAAc,CAAC;EAUxB;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACWC,WAAWA,CACGC,MAAoB,EACpBC,WAA6B,EAEhD;IAAA,IAAAC,iBAAA;IAAA,IADEC,IAAW,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;IAAA,KAFCJ,MAAoB,GAApBA,MAAoB;IAAA,KACpBC,WAA6B,GAA7BA,WAA6B;IAAAM,eAAA;IAlClD;IACA;IACA;IACA;IAAAA,eAAA;IAAAA,eAAA;IAAAA,eAAA,qBAGqB,CAAC;IA+BlB,IAAI,CAACC,WAAW,GAAGL,IAAI,CAACK,WAAW,IAAI,IAAI;IAC3C,CAAAN,iBAAA,GAAAD,WAAW,CAACQ,IAAI,cAAAP,iBAAA,eAAhBA,iBAAA,CAAkBQ,EAAE,CAAClB,SAAS,CAACmB,QAAQ,EAAE,IAAI,CAACC,eAAe,CAAChB,IAAI,CAAC,IAAI,CAAC,CAAC;EAC7E;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;EACWiB,IAAIA,CAACC,cAAuB,EAAyC;IAAA,IAAvCC,iBAAiB,GAAAX,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,EAAE;IACvD;IACA;IACA,IAAMY,UAAU,GAAIC,QAAiC,IAAW;MAC5D,IAAI,CAACA,QAAQ,EAAE;QACX,MAAM,IAAIC,KAAK,CAAC,iCAAiC,CAAC;MACtD;MAEA,IAAIC,UAAkB;MAEtB,IAAMC,MAAM,GAAGH,QAAQ,CAACI,SAAS,CAAC,CAAC;MAEnC,IAAI,CAACP,cAAc,EAAE;QACjB;QACAK,UAAU,GAAGC,MAAM,CAACf,MAAM;MAC9B,CAAC,MAAM;QACHc,UAAU,GAAGC,MAAM,CAACE,SAAS,CAAEC,CAAC,IAAKA,CAAC,CAACC,KAAK,CAAC,CAAC,KAAKV,cAAc,CAAC;QAElE,IAAIK,UAAU,GAAG,CAAC,EAAE;UAChB,MAAM,IAAID,KAAK,CAAC,wDAAwD,CAAC;QAC7E;MACJ;MAEA,IAAMO,QAAQ,GAAGC,IAAI,CAACC,GAAG,CAACP,MAAM,CAACf,MAAM,EAAEc,UAAU,GAAGO,IAAI,CAACE,IAAI,CAACb,iBAAiB,GAAG,CAAC,CAAC,CAAC;MACvF,IAAMc,UAAU,GAAGH,IAAI,CAACI,GAAG,CAAC,CAAC,EAAEL,QAAQ,GAAGV,iBAAiB,CAAC;MAC5D,IAAI,CAACgB,KAAK,GAAG,IAAIC,aAAa,CAACf,QAAQ,EAAEY,UAAU,GAAGZ,QAAQ,CAACgB,YAAY,CAAC,CAAC,CAAC;MAC9E,IAAI,CAACC,GAAG,GAAG,IAAIF,aAAa,CAACf,QAAQ,EAAEQ,QAAQ,GAAGR,QAAQ,CAACgB,YAAY,CAAC,CAAC,CAAC;MAC1E,IAAI,CAACE,UAAU,GAAGV,QAAQ,GAAGI,UAAU;IAC3C,CAAC;;IAED;IACA;IACA,IAAI,IAAI,CAAC5B,WAAW,CAACmC,mBAAmB,CAACtB,cAAc,CAAC,EAAE;MACtDE,UAAU,CAAC,IAAI,CAACf,WAAW,CAACmC,mBAAmB,CAACtB,cAAc,CAAC,CAAC;MAChE,OAAOuB,OAAO,CAACC,OAAO,CAAC,CAAC;IAC5B,CAAC,MAAM,IAAIxB,cAAc,EAAE;MACvB,OAAO,IAAI,CAACd,MAAM,CAACuC,gBAAgB,CAAC,IAAI,CAACtC,WAAW,EAAEa,cAAc,CAAC,CAAC0B,IAAI,CAACxB,UAAU,CAAC;IAC1F,CAAC,MAAM;MACHA,UAAU,CAAC,IAAI,CAACf,WAAW,CAACwC,eAAe,CAAC,CAAC,CAAC;MAC9C,OAAOJ,OAAO,CAACC,OAAO,CAAC,CAAC;IAC5B;EACJ;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACWI,gBAAgBA,CAACC,SAAoB,EAAwB;IAChE,IAAIA,SAAS,IAAIrD,aAAa,CAACsD,SAAS,EAAE;MAAA,IAAAC,WAAA;MACtC,QAAAA,WAAA,GAAO,IAAI,CAACd,KAAK,cAAAc,WAAA,cAAAA,WAAA,GAAI,IAAI;IAC7B,CAAC,MAAM,IAAIF,SAAS,IAAIrD,aAAa,CAACwD,QAAQ,EAAE;MAAA,IAAAC,SAAA;MAC5C,QAAAA,SAAA,GAAO,IAAI,CAACb,GAAG,cAAAa,SAAA,cAAAA,SAAA,GAAI,IAAI;IAC3B,CAAC,MAAM;MACH,MAAM,IAAI7B,KAAK,CAAC,qBAAqB,GAAGyB,SAAS,GAAG,GAAG,CAAC;IAC5D;EACJ;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACWK,MAAMA,CAACL,SAAoB,EAAEM,IAAY,EAAW;IACvD,IAAMC,EAAE,GAAG,IAAI,CAACR,gBAAgB,CAACC,SAAS,CAAC;IAE3C,IAAI,CAACO,EAAE,EAAE;MACLxD,QAAQ,CAAC,iCAAiC,CAAC;MAC3C,OAAO,KAAK;IAChB;IAEA,IAAMyD,KAAK,GAAGR,SAAS,IAAIrD,aAAa,CAACsD,SAAS,GAAGM,EAAE,CAACE,OAAO,CAACH,IAAI,CAAC,GAAGC,EAAE,CAACG,OAAO,CAACJ,IAAI,CAAC;IAExF,IAAIE,KAAK,EAAE;MACP,IAAI,CAAChB,UAAU,IAAIgB,KAAK;MACxBzD,QAAQ,CAAC,mCAAmC,GAAGyD,KAAK,GAAG,QAAQ,GAAG,IAAI,CAAChB,UAAU,GAAG,GAAG,CAAC;MACxF;MACA,IAAMmB,MAAM,GAAG,IAAI,CAACnB,UAAU,GAAG,IAAI,CAAC3B,WAAW;MACjD,IAAI8C,MAAM,GAAG,CAAC,EAAE;QACZ,IAAI,CAACC,UAAU,CAACD,MAAM,EAAEX,SAAS,IAAIrD,aAAa,CAACsD,SAAS,CAAC;MACjE;MACA,OAAO,IAAI;IACf;IAEA,OAAO,KAAK;EAChB;EAEQhC,eAAeA,CAAC4C,MAAoB,EAAEC,KAAY,EAAEC,QAAkB,EAAEC,OAAiB,EAAQ;IACrG,IAAIA,OAAO,EAAE;MACT,IAAI,CAACC,cAAc,CAAC,CAAC;IACzB;EACJ;;EAEA;AACJ;AACA;AACA;EACYA,cAAcA,CAAA,EAAS;IAC3B,IAAMxC,MAAM,GAAG,IAAI,CAACC,SAAS,CAAC,CAAC;IAC/B,IAAID,MAAM,CAACf,MAAM,GAAG,CAAC,IAAIe,MAAM,CAACA,MAAM,CAACf,MAAM,GAAG,CAAC,CAAC,KAAKC,SAAS,IAAI,IAAI,CAAC4B,GAAG,EAAE;MAC1E,IAAI,CAACA,GAAG,CAAC2B,KAAK,EAAE;IACpB;EACJ;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACWC,WAAWA,CAACnB,SAAoB,EAAW;IAC9C,IAAMO,EAAE,GAAG,IAAI,CAACR,gBAAgB,CAACC,SAAS,CAAC;IAE3C,IAAI,CAACO,EAAE,EAAE;MACLxD,QAAQ,CAAC,iCAAiC,CAAC;MAC3C,OAAO,KAAK;IAChB;IAEA,IAAIiD,SAAS,IAAIrD,aAAa,CAACsD,SAAS,EAAE;MACtC,IAAIM,EAAE,CAACW,KAAK,GAAGX,EAAE,CAACa,QAAQ,CAAC,CAAC,EAAE;QAC1B,OAAO,IAAI;MACf;IACJ,CAAC,MAAM;MACH,IAAIb,EAAE,CAACW,KAAK,GAAGX,EAAE,CAACc,QAAQ,CAAC,CAAC,EAAE;QAC1B,OAAO,IAAI;MACf;IACJ;IAEA,IAAMC,uBAAuB,GAAGf,EAAE,CAACjC,QAAQ,CAACiD,uBAAuB,CAACvB,SAAS,CAAC;IAC9E,IAAMwB,eAAe,GAAGjB,EAAE,CAACjC,QAAQ,CAACmD,kBAAkB,CAACzB,SAAS,CAAC;IACjE,OAAO0B,OAAO,CAACJ,uBAAuB,CAAC,IAAII,OAAO,CAACF,eAAe,CAAC;EACvE;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACiBG,QAAQA,CACjB3B,SAAoB,EACpBM,IAAY,EAGI;IAAA,IAAAsB,UAAA,GAAAnE,SAAA;MAAAoE,KAAA;IAAA,OAAAC,iBAAA;MAAA,IAFhBC,WAAW,GAAAH,UAAA,CAAAlE,MAAA,QAAAkE,UAAA,QAAAjE,SAAA,GAAAiE,UAAA,MAAG,IAAI;MAAA,IAClBI,YAAY,GAAAJ,UAAA,CAAAlE,MAAA,QAAAkE,UAAA,QAAAjE,SAAA,GAAAiE,UAAA,MAAG1E,2BAA2B;MAE1C;MACA;MACA,IAAMqD,EAAE,GAAGsB,KAAI,CAAC9B,gBAAgB,CAACC,SAAS,CAAC;MAE3C,IAAI,CAACO,EAAE,EAAE;QACLxD,QAAQ,CAAC,iCAAiC,CAAC;QAC3C,OAAO,KAAK;MAChB;MAEA,IAAIwD,EAAE,CAAC0B,eAAe,EAAE;QACpB,OAAO1B,EAAE,CAAC0B,eAAe;MAC7B;;MAEA;MACA,IAAIJ,KAAI,CAACxB,MAAM,CAACL,SAAS,EAAEM,IAAI,CAAC,EAAE;QAC9B,OAAO,IAAI;MACf;MAEA,IAAI,CAACyB,WAAW,IAAIC,YAAY,KAAK,CAAC,EAAE;QACpC;QACA;QACA,OAAO,KAAK;MAChB;;MAEA;MACA,IAAME,KAAK,GAAG3B,EAAE,CAACjC,QAAQ,CAACmD,kBAAkB,CAACzB,SAAS,CAAC;MACvD,IAAI,CAACkC,KAAK,EAAE;QACRnF,QAAQ,CAAC,0BAA0B,CAAC;QACpC,OAAO,KAAK;MAChB;MAEAA,QAAQ,CAAC,kCAAkC,CAAC;MAE5C,IAAMoF,IAAI,GAAGN,KAAI,CAACxE,MAAM,CACnB+E,qBAAqB,CAAC7B,EAAE,CAACjC,QAAQ,EAAE;QAChC+D,SAAS,EAAErC,SAAS,IAAIrD,aAAa,CAACsD,SAAS;QAC/CqC,KAAK,EAAEhC;MACX,CAAC,CAAC,CACDiC,OAAO,CAAC,YAAY;QACjBhC,EAAE,CAAC0B,eAAe,GAAGtE,SAAS;MAClC,CAAC,CAAC,CACDkC,IAAI,CAAE2C,CAAC,IAAK;QACTzF,QAAQ,CAAC,gDAAgD,GAAGyF,CAAC,CAAC;QAC9D,IAAI,CAACA,CAAC,EAAE;UACJ,OAAOX,KAAI,CAACF,QAAQ,CAAC3B,SAAS,EAAEM,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACnD;;QAEA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,OAAOuB,KAAI,CAACF,QAAQ,CAAC3B,SAAS,EAAEM,IAAI,EAAE,IAAI,EAAE0B,YAAY,GAAG,CAAC,CAAC;MACjE,CAAC,CAAC;MACNzB,EAAE,CAAC0B,eAAe,GAAGE,IAAI;MACzB,OAAOA,IAAI;IAAC;EAChB;;EAEA;AACJ;AACA;AACA;AACA;AACA;AACA;EACWvB,UAAUA,CAAC6B,KAAa,EAAEC,eAAwB,EAAQ;IAC7D,IAAMnC,EAAE,GAAGmC,eAAe,GAAG,IAAI,CAACtD,KAAK,GAAG,IAAI,CAACG,GAAG;IAClD,IAAI,CAACgB,EAAE,EAAE;MACL,MAAM,IAAIhC,KAAK,6CAAAoE,MAAA,CACiCD,eAAe,mCAC/D,CAAC;IACL;;IAEA;IACA,IAAID,KAAK,GAAG,IAAI,CAACjD,UAAU,IAAIiD,KAAK,GAAG,CAAC,EAAE;MACtC,MAAM,IAAIlE,KAAK,4BAAAoE,MAAA,CACgBF,KAAK,6BAAAE,MAAA,CAA0B,IAAI,CAACnD,UAAU,qBAC7E,CAAC;IACL;IAEA,OAAOiD,KAAK,GAAG,CAAC,EAAE;MACd,IAAMjC,KAAK,GAAGkC,eAAe,GAAGnC,EAAE,CAACG,OAAO,CAAC+B,KAAK,CAAC,GAAGlC,EAAE,CAACE,OAAO,CAACgC,KAAK,CAAC;MACrE,IAAIjC,KAAK,IAAI,CAAC,EAAE;QACZ;QACA,MAAM,IAAIjC,KAAK,CAAC,mDAAmD,GAAG,IAAI,CAACiB,UAAU,GAAG,SAAS,CAAC;MACtG;MAEAiD,KAAK,IAAIjC,KAAK;MACd,IAAI,CAAChB,UAAU,IAAIgB,KAAK;MACxBzD,QAAQ,CAAC,qCAAqC,GAAGyD,KAAK,GAAG,QAAQ,GAAG,IAAI,CAAChB,UAAU,GAAG,GAAG,CAAC;IAC9F;EACJ;;EAEA;AACJ;AACA;AACA;AACA;EACWd,SAASA,CAAA,EAAkB;IAC9B,IAAI,CAAC,IAAI,CAACU,KAAK,EAAE;MACb;MACA,OAAO,EAAE;IACb;IAEA,IAAMwD,MAAqB,GAAG,EAAE;;IAEhC;IACA;IACA,IAAItE,QAA8B,GAAG,IAAI,CAACc,KAAK,CAACd,QAAQ;IACxD;IACA,OAAOA,QAAQ,EAAE;MAAA,IAAAuE,UAAA,EAAAC,UAAA;MACb,IAAMrE,MAAM,GAAGH,QAAQ,CAACI,SAAS,CAAC,CAAC;;MAEnC;MACA;MACA;MACA;MACA;MACA;MACA;MACA;MACA,IAAIQ,UAAU,GAAG,CAAC;MAClB,IAAIJ,QAAQ,GAAGL,MAAM,CAACf,MAAM;MAC5B,IAAIY,QAAQ,KAAK,IAAI,CAACc,KAAK,CAACd,QAAQ,EAAE;QAClCY,UAAU,GAAG,IAAI,CAACE,KAAK,CAAC8B,KAAK,GAAG5C,QAAQ,CAACgB,YAAY,CAAC,CAAC;MAC3D;MACA,IAAIhB,QAAQ,OAAAuE,UAAA,GAAK,IAAI,CAACtD,GAAG,cAAAsD,UAAA,uBAARA,UAAA,CAAUvE,QAAQ,GAAE;QACjCQ,QAAQ,GAAG,IAAI,CAACS,GAAG,CAAC2B,KAAK,GAAG5C,QAAQ,CAACgB,YAAY,CAAC,CAAC;MACvD;MAEA,KAAK,IAAIyD,CAAC,GAAG7D,UAAU,EAAE6D,CAAC,GAAGjE,QAAQ,EAAEiE,CAAC,EAAE,EAAE;QACxCH,MAAM,CAACI,IAAI,CAACvE,MAAM,CAACsE,CAAC,CAAC,CAAC;MAC1B;;MAEA;MACA,IAAIzE,QAAQ,OAAAwE,UAAA,GAAK,IAAI,CAACvD,GAAG,cAAAuD,UAAA,uBAARA,UAAA,CAAUxE,QAAQ,GAAE;QACjC;MACJ,CAAC,MAAM;QACHA,QAAQ,GAAGA,QAAQ,CAACiD,uBAAuB,CAAC5E,aAAa,CAACwD,QAAQ,CAAC;MACvE;IACJ;IAEA,OAAOyC,MAAM;EACjB;AACJ;;AAEA;AACA;AACA;AACA;AACA,OAAO,MAAMvD,aAAa,CAAC;EAGvB;EACOjC,WAAWA,CACPkB,QAAuB,EACvB4C,KAAa,EACtB;IAAA,KAFS5C,QAAuB,GAAvBA,QAAuB;IAAA,KACvB4C,KAAa,GAAbA,KAAa;IAAAtD,eAAA;EACrB;;EAEH;AACJ;AACA;AACA;EACWwD,QAAQA,CAAA,EAAW;IACtB,OAAO,IAAI,CAAC9C,QAAQ,CAACgB,YAAY,CAAC,CAAC,GAAG,CAAC,CAAC;EAC5C;;EAEA;AACJ;AACA;AACA;AACA;EACW+B,QAAQA,CAAA,EAAW;IACtB,OAAO,IAAI,CAAC/C,QAAQ,CAACI,SAAS,CAAC,CAAC,CAAChB,MAAM,GAAG,IAAI,CAACY,QAAQ,CAACgB,YAAY,CAAC,CAAC;EAC1E;;EAEA;AACJ;AACA;AACA;AACA;AACA;EACWoB,OAAOA,CAAC+B,KAAa,EAAU;IAClC,IAAI,CAACA,KAAK,EAAE;MACR,OAAO,CAAC;IACZ;;IAEA;IACA;IACA,IAAIQ,WAAW;IACf,IAAIR,KAAK,GAAG,CAAC,EAAE;MACX;MACA;MACA;MACA;MACA;MACAQ,WAAW,GAAGlE,IAAI,CAACI,GAAG,CAACsD,KAAK,EAAE,IAAI,CAACrB,QAAQ,CAAC,CAAC,GAAG,IAAI,CAACF,KAAK,CAAC;MAC3D,IAAI+B,WAAW,GAAG,CAAC,EAAE;QACjB,IAAI,CAAC/B,KAAK,IAAI+B,WAAW;QACzB,OAAOA,WAAW;MACtB;IACJ,CAAC,MAAM;MACH;MACA;MACA;MACA;MACA;MACAA,WAAW,GAAGlE,IAAI,CAACC,GAAG,CAACyD,KAAK,EAAE,IAAI,CAACpB,QAAQ,CAAC,CAAC,GAAG,IAAI,CAACH,KAAK,CAAC;MAC3D,IAAI+B,WAAW,GAAG,CAAC,EAAE;QACjB,IAAI,CAAC/B,KAAK,IAAI+B,WAAW;QACzB,OAAOA,WAAW;MACtB;IACJ;;IAEA;IACA;IACA;IACA,IAAMC,SAAS,GAAG,IAAI,CAAC5E,QAAQ,CAACiD,uBAAuB,CACnDkB,KAAK,GAAG,CAAC,GAAG9F,aAAa,CAACsD,SAAS,GAAGtD,aAAa,CAACwD,QACxD,CAAC;IACD,IAAI+C,SAAS,EAAE;MACX,IAAI,CAAC5E,QAAQ,GAAG4E,SAAS;MACzB,IAAIT,KAAK,GAAG,CAAC,EAAE;QACX,IAAI,CAACvB,KAAK,GAAG,IAAI,CAACG,QAAQ,CAAC,CAAC;MAChC,CAAC,MAAM;QACH,IAAI,CAACH,KAAK,GAAG,IAAI,CAACE,QAAQ,CAAC,CAAC;MAChC;MAEArE,QAAQ,CAAC,qCAAqC,CAAC;;MAE/C;MACA,OAAO,IAAI,CAAC2D,OAAO,CAAC+B,KAAK,CAAC;IAC9B;IAEA,OAAO,CAAC;EACZ;;EAEA;AACJ;AACA;AACA;AACA;AACA;EACWhC,OAAOA,CAACgC,KAAa,EAAU;IAClC,OAAO,IAAI,CAAC/B,OAAO,CAAC+B,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;EACxC;AACJ","ignoreList":[]}

package/lib/types.d.ts

@@ -0,0 +1,33 @@
+export type * from "./@types/media.ts";
+export * from "./@types/membership.ts";
+export type * from "./@types/event.ts";
+export type * from "./@types/events.ts";
+export type * from "./@types/state_events.ts";
+export type * from "./@types/AESEncryptedSecretStoragePayload.ts";
+/** The different methods for device and user verification */
+export declare enum VerificationMethod {
+    /** Short authentication string (emoji or decimals).
+     *
+     * @see https://spec.matrix.org/v1.9/client-server-api/#short-authentication-string-sas-verification
+     */
+    Sas = "m.sas.v1",
+    /**
+     * Verification by showing a QR code which is scanned by the other device.
+     *
+     * @see https://spec.matrix.org/v1.9/client-server-api/#qr-codes
+     */
+    ShowQrCode = "m.qr_code.show.v1",
+    /**
+     * Verification by scanning a QR code that is shown by the other device.
+     *
+     * @see https://spec.matrix.org/v1.9/client-server-api/#qr-codes
+     */
+    ScanQrCode = "m.qr_code.scan.v1",
+    /**
+     * Verification by confirming that we have scanned a QR code.
+     *
+     * @see https://spec.matrix.org/v1.9/client-server-api/#qr-codes
+     */
+    Reciprocate = "m.reciprocate.v1"
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAuBA,mBAAmB,mBAAmB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,mBAAmB,mBAAmB,CAAC;AACvC,mBAAmB,oBAAoB,CAAC;AACxC,mBAAmB,0BAA0B,CAAC;AAC9C,mBAAmB,8CAA8C,CAAC;AAElE,6DAA6D;AAC7D,oBAAY,kBAAkB;IAC1B;;;OAGG;IACH,GAAG,aAAa;IAEhB;;;;OAIG;IACH,UAAU,sBAAsB;IAEhC;;;;OAIG;IACH,UAAU,sBAAsB;IAEhC;;;;OAIG;IACH,WAAW,qBAAqB;CACnC"}

package/lib/types.js

@@ -0,0 +1,33 @@
+/*
+Copyright 2024 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+ * This file is a secondary entrypoint for the js-sdk library, for use by Typescript projects.
+ * It exposes low-level types and interfaces reflecting structures defined in the Matrix specification.
+ *
+ * Remember to only export *public* types from this file.
+ */
+
+export * from "./@types/membership.js";
+/** The different methods for device and user verification */
+export var VerificationMethod = /*#__PURE__*/function (VerificationMethod) {
+  VerificationMethod["Sas"] = "m.sas.v1";
+  VerificationMethod["ShowQrCode"] = "m.qr_code.show.v1";
+  VerificationMethod["ScanQrCode"] = "m.qr_code.scan.v1";
+  VerificationMethod["Reciprocate"] = "m.reciprocate.v1";
+  return VerificationMethod;
+}({});
+//# sourceMappingURL=types.js.map

package/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":["VerificationMethod"],"sources":["../src/types.ts"],"sourcesContent":["/*\nCopyright 2024 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/*\n * This file is a secondary entrypoint for the js-sdk library, for use by Typescript projects.\n * It exposes low-level types and interfaces reflecting structures defined in the Matrix specification.\n *\n * Remember to only export *public* types from this file.\n */\n\nexport type * from \"./@types/media.ts\";\nexport * from \"./@types/membership.ts\";\nexport type * from \"./@types/event.ts\";\nexport type * from \"./@types/events.ts\";\nexport type * from \"./@types/state_events.ts\";\nexport type * from \"./@types/AESEncryptedSecretStoragePayload.ts\";\n\n/** The different methods for device and user verification */\nexport enum VerificationMethod {\n    /** Short authentication string (emoji or decimals).\n     *\n     * @see https://spec.matrix.org/v1.9/client-server-api/#short-authentication-string-sas-verification\n     */\n    Sas = \"m.sas.v1\",\n\n    /**\n     * Verification by showing a QR code which is scanned by the other device.\n     *\n     * @see https://spec.matrix.org/v1.9/client-server-api/#qr-codes\n     */\n    ShowQrCode = \"m.qr_code.show.v1\",\n\n    /**\n     * Verification by scanning a QR code that is shown by the other device.\n     *\n     * @see https://spec.matrix.org/v1.9/client-server-api/#qr-codes\n     */\n    ScanQrCode = \"m.qr_code.scan.v1\",\n\n    /**\n     * Verification by confirming that we have scanned a QR code.\n     *\n     * @see https://spec.matrix.org/v1.9/client-server-api/#qr-codes\n     */\n    Reciprocate = \"m.reciprocate.v1\",\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAGA,cAAc,wBAAwB;AAMtC;AACA,WAAYA,kBAAkB,0BAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAlBA,kBAAkB;EAAA,OAAlBA,kBAAkB;AAAA","ignoreList":[]}

package/lib/utils/decryptAESSecretStorageItem.d.ts

@@ -0,0 +1,12 @@
+import { AESEncryptedSecretStoragePayload } from "../@types/AESEncryptedSecretStoragePayload.ts";
+/**
+ * Decrypt an AES-encrypted Secret Storage item.
+ *
+ * @param data - the encrypted data, returned by {@link utils/encryptAESSecretStorageItem.default | encryptAESSecretStorageItem}.
+ * @param key - the encryption key to use as an input to the HKDF function which is used to derive the AES key. Must
+ *    be the same as provided to {@link utils/encryptAESSecretStorageItem.default | encryptAESSecretStorageItem}.
+ * @param name - the name of the secret. Also used as an input to the HKDF operation which is used to derive the AES
+ *    key, so again must be the same as provided to {@link utils/encryptAESSecretStorageItem.default | encryptAESSecretStorageItem}.
+ */
+export default function decryptAESSecretStorageItem(data: AESEncryptedSecretStoragePayload, key: Uint8Array, name: string): Promise<string>;
+//# sourceMappingURL=decryptAESSecretStorageItem.d.ts.map

package/lib/utils/decryptAESSecretStorageItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decryptAESSecretStorageItem.d.ts","sourceRoot":"","sources":["../../src/utils/decryptAESSecretStorageItem.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AAEjG;;;;;;;;GAQG;AACH,wBAA8B,2BAA2B,CACrD,IAAI,EAAE,gCAAgC,EACtC,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,CAoBjB"}