1 files changed, 0 insertions, 343 deletions

diff --git a/includes/external/matrix/node_modules/matrix-js-sdk/lib/models/relations.js b/includes/external/matrix/node_modules/matrix-js-sdk/lib/models/relations.js
deleted file mode 100644
index 238d6c1..0000000
--- a/includes/external/matrix/node_modules/matrix-js-sdk/lib/models/relations.js
+++ /dev/null
@@ -1,343 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.RelationsEvent = exports.Relations = void 0;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _event = require("./event");
-var _logger = require("../logger");
-var _event2 = require("../@types/event");
-var _typedEventEmitter = require("./typed-event-emitter");
-var _room = require("./room");
-/*
-Copyright 2019, 2021, 2023 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.
-*/
-let RelationsEvent;
-exports.RelationsEvent = RelationsEvent;
-(function (RelationsEvent) {
-  RelationsEvent["Add"] = "Relations.add";
-  RelationsEvent["Remove"] = "Relations.remove";
-  RelationsEvent["Redaction"] = "Relations.redaction";
-})(RelationsEvent || (exports.RelationsEvent = RelationsEvent = {}));
-const matchesEventType = (eventType, targetEventType, altTargetEventTypes = []) => [targetEventType, ...altTargetEventTypes].includes(eventType);
-
-/**
- * A container for relation events that supports easy access to common ways of
- * aggregating such events. Each instance holds events that of a single relation
- * type and event type. All of the events also relate to the same original event.
- *
- * The typical way to get one of these containers is via
- * EventTimelineSet#getRelationsForEvent.
- */
-class Relations extends _typedEventEmitter.TypedEventEmitter {
-  /**
-   * @param relationType - The type of relation involved, such as "m.annotation", "m.reference", "m.replace", etc.
-   * @param eventType - The relation event's type, such as "m.reaction", etc.
-   * @param client - The client which created this instance. For backwards compatibility also accepts a Room.
-   * @param altEventTypes - alt event types for relation events, for example to support unstable prefixed event types
-   */
-  constructor(relationType, eventType, client, altEventTypes) {
-    super();
-    this.relationType = relationType;
-    this.eventType = eventType;
-    this.altEventTypes = altEventTypes;
-    (0, _defineProperty2.default)(this, "relationEventIds", new Set());
-    (0, _defineProperty2.default)(this, "relations", new Set());
-    (0, _defineProperty2.default)(this, "annotationsByKey", {});
-    (0, _defineProperty2.default)(this, "annotationsBySender", {});
-    (0, _defineProperty2.default)(this, "sortedAnnotationsByKey", []);
-    (0, _defineProperty2.default)(this, "targetEvent", null);
-    (0, _defineProperty2.default)(this, "creationEmitted", false);
-    (0, _defineProperty2.default)(this, "client", void 0);
-    (0, _defineProperty2.default)(this, "onEventStatus", (event, status) => {
-      if (!event.isSending()) {
-        // Sending is done, so we don't need to listen anymore
-        event.removeListener(_event.MatrixEventEvent.Status, this.onEventStatus);
-        return;
-      }
-      if (status !== _event.EventStatus.CANCELLED) {
-        return;
-      }
-      // Event was cancelled, remove from the collection
-      event.removeListener(_event.MatrixEventEvent.Status, this.onEventStatus);
-      this.removeEvent(event);
-    });
-    (0, _defineProperty2.default)(this, "onBeforeRedaction", async redactedEvent => {
-      if (!this.relations.has(redactedEvent)) {
-        return;
-      }
-      this.relations.delete(redactedEvent);
-      if (this.relationType === _event2.RelationType.Annotation) {
-        // Remove the redacted annotation from aggregation by key
-        this.removeAnnotationFromAggregation(redactedEvent);
-      } else if (this.relationType === _event2.RelationType.Replace && this.targetEvent && !this.targetEvent.isState()) {
-        const lastReplacement = await this.getLastReplacement();
-        this.targetEvent.makeReplaced(lastReplacement);
-      }
-      redactedEvent.removeListener(_event.MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);
-      this.emit(RelationsEvent.Redaction, redactedEvent);
-    });
-    this.client = client instanceof _room.Room ? client.client : client;
-  }
-
-  /**
-   * Add relation events to this collection.
-   *
-   * @param event - The new relation event to be added.
-   */
-  async addEvent(event) {
-    if (this.relationEventIds.has(event.getId())) {
-      return;
-    }
-    const relation = event.getRelation();
-    if (!relation) {
-      _logger.logger.error("Event must have relation info");
-      return;
-    }
-    const relationType = relation.rel_type;
-    const eventType = event.getType();
-    if (this.relationType !== relationType || !matchesEventType(eventType, this.eventType, this.altEventTypes)) {
-      _logger.logger.error("Event relation info doesn't match this container");
-      return;
-    }
-
-    // If the event is in the process of being sent, listen for cancellation
-    // so we can remove the event from the collection.
-    if (event.isSending()) {
-      event.on(_event.MatrixEventEvent.Status, this.onEventStatus);
-    }
-    this.relations.add(event);
-    this.relationEventIds.add(event.getId());
-    if (this.relationType === _event2.RelationType.Annotation) {
-      this.addAnnotationToAggregation(event);
-    } else if (this.relationType === _event2.RelationType.Replace && this.targetEvent && !this.targetEvent.isState()) {
-      const lastReplacement = await this.getLastReplacement();
-      this.targetEvent.makeReplaced(lastReplacement);
-    }
-    event.on(_event.MatrixEventEvent.BeforeRedaction, this.onBeforeRedaction);
-    this.emit(RelationsEvent.Add, event);
-    this.maybeEmitCreated();
-  }
-
-  /**
-   * Remove relation event from this collection.
-   *
-   * @param event - The relation event to remove.
-   */
-  async removeEvent(event) {
-    if (!this.relations.has(event)) {
-      return;
-    }
-    this.relations.delete(event);
-    if (this.relationType === _event2.RelationType.Annotation) {
-      this.removeAnnotationFromAggregation(event);
-    } else if (this.relationType === _event2.RelationType.Replace && this.targetEvent && !this.targetEvent.isState()) {
-      const lastReplacement = await this.getLastReplacement();
-      this.targetEvent.makeReplaced(lastReplacement);
-    }
-    this.emit(RelationsEvent.Remove, event);
-  }
-
-  /**
-   * Listens for event status changes to remove cancelled events.
-   *
-   * @param event - The event whose status has changed
-   * @param status - The new status
-   */
-
-  /**
-   * Get all relation events in this collection.
-   *
-   * These are currently in the order of insertion to this collection, which
-   * won't match timeline order in the case of scrollback.
-   * TODO: Tweak `addEvent` to insert correctly for scrollback.
-   *
-   * Relation events in insertion order.
-   */
-  getRelations() {
-    return [...this.relations];
-  }
-  addAnnotationToAggregation(event) {
-    var _event$getRelation;
-    const {
-      key
-    } = (_event$getRelation = event.getRelation()) !== null && _event$getRelation !== void 0 ? _event$getRelation : {};
-    if (!key) return;
-    let eventsForKey = this.annotationsByKey[key];
-    if (!eventsForKey) {
-      eventsForKey = this.annotationsByKey[key] = new Set();
-      this.sortedAnnotationsByKey.push([key, eventsForKey]);
-    }
-    // Add the new event to the set for this key
-    eventsForKey.add(event);
-    // Re-sort the [key, events] pairs in descending order of event count
-    this.sortedAnnotationsByKey.sort((a, b) => {
-      const aEvents = a[1];
-      const bEvents = b[1];
-      return bEvents.size - aEvents.size;
-    });
-    const sender = event.getSender();
-    let eventsFromSender = this.annotationsBySender[sender];
-    if (!eventsFromSender) {
-      eventsFromSender = this.annotationsBySender[sender] = new Set();
-    }
-    // Add the new event to the set for this sender
-    eventsFromSender.add(event);
-  }
-  removeAnnotationFromAggregation(event) {
-    var _event$getRelation2;
-    const {
-      key
-    } = (_event$getRelation2 = event.getRelation()) !== null && _event$getRelation2 !== void 0 ? _event$getRelation2 : {};
-    if (!key) return;
-    const eventsForKey = this.annotationsByKey[key];
-    if (eventsForKey) {
-      eventsForKey.delete(event);
-
-      // Re-sort the [key, events] pairs in descending order of event count
-      this.sortedAnnotationsByKey.sort((a, b) => {
-        const aEvents = a[1];
-        const bEvents = b[1];
-        return bEvents.size - aEvents.size;
-      });
-    }
-    const sender = event.getSender();
-    const eventsFromSender = this.annotationsBySender[sender];
-    if (eventsFromSender) {
-      eventsFromSender.delete(event);
-    }
-  }
-
-  /**
-   * For relations that have been redacted, we want to remove them from
-   * aggregation data sets and emit an update event.
-   *
-   * To do so, we listen for `Event.beforeRedaction`, which happens:
-   *   - after the server accepted the redaction and remote echoed back to us
-   *   - before the original event has been marked redacted in the client
-   *
-   * @param redactedEvent - The original relation event that is about to be redacted.
-   */
-
-  /**
-   * Get all events in this collection grouped by key and sorted by descending
-   * event count in each group.
-   *
-   * This is currently only supported for the annotation relation type.
-   *
-   * An array of [key, events] pairs sorted by descending event count.
-   * The events are stored in a Set (which preserves insertion order).
-   */
-  getSortedAnnotationsByKey() {
-    if (this.relationType !== _event2.RelationType.Annotation) {
-      // Other relation types are not grouped currently.
-      return null;
-    }
-    return this.sortedAnnotationsByKey;
-  }
-
-  /**
-   * Get all events in this collection grouped by sender.
-   *
-   * This is currently only supported for the annotation relation type.
-   *
-   * An object with each relation sender as a key and the matching Set of
-   * events for that sender as a value.
-   */
-  getAnnotationsBySender() {
-    if (this.relationType !== _event2.RelationType.Annotation) {
-      // Other relation types are not grouped currently.
-      return null;
-    }
-    return this.annotationsBySender;
-  }
-
-  /**
-   * Returns the most recent (and allowed) m.replace relation, if any.
-   *
-   * This is currently only supported for the m.replace relation type,
-   * once the target event is known, see `addEvent`.
-   */
-  async getLastReplacement() {
-    if (this.relationType !== _event2.RelationType.Replace) {
-      // Aggregating on last only makes sense for this relation type
-      return null;
-    }
-    if (!this.targetEvent) {
-      // Don't know which replacements to accept yet.
-      // This method shouldn't be called before the original
-      // event is known anyway.
-      return null;
-    }
-
-    // the all-knowning server tells us that the event at some point had
-    // this timestamp for its replacement, so any following replacement should definitely not be less
-    const replaceRelation = this.targetEvent.getServerAggregatedRelation(_event2.RelationType.Replace);
-    const minTs = replaceRelation === null || replaceRelation === void 0 ? void 0 : replaceRelation.origin_server_ts;
-    const lastReplacement = this.getRelations().reduce((last, event) => {
-      if (event.getSender() !== this.targetEvent.getSender()) {
-        return last;
-      }
-      if (minTs && minTs > event.getTs()) {
-        return last;
-      }
-      if (last && last.getTs() > event.getTs()) {
-        return last;
-      }
-      return event;
-    }, null);
-    if (lastReplacement !== null && lastReplacement !== void 0 && lastReplacement.shouldAttemptDecryption() && this.client.isCryptoEnabled()) {
-      await lastReplacement.attemptDecryption(this.client.crypto);
-    } else if (lastReplacement !== null && lastReplacement !== void 0 && lastReplacement.isBeingDecrypted()) {
-      await lastReplacement.getDecryptionPromise();
-    }
-    return lastReplacement;
-  }
-
-  /*
-   * @param targetEvent - the event the relations are related to.
-   */
-  async setTargetEvent(event) {
-    if (this.targetEvent) {
-      return;
-    }
-    this.targetEvent = event;
-    if (this.relationType === _event2.RelationType.Replace && !this.targetEvent.isState()) {
-      const replacement = await this.getLastReplacement();
-      // this is the initial update, so only call it if we already have something
-      // to not emit Event.replaced needlessly
-      if (replacement) {
-        this.targetEvent.makeReplaced(replacement);
-      }
-    }
-    this.maybeEmitCreated();
-  }
-  maybeEmitCreated() {
-    if (this.creationEmitted) {
-      return;
-    }
-    // Only emit we're "created" once we have a target event instance _and_
-    // at least one related event.
-    if (!this.targetEvent || !this.relations.size) {
-      return;
-    }
-    this.creationEmitted = true;
-    this.targetEvent.emit(_event.MatrixEventEvent.RelationsCreated, this.relationType, this.eventType);
-  }
-}
-exports.Relations = Relations;
-//# sourceMappingURL=relations.js.map
\ No newline at end of file