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

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

@@ -1,5 +1,3 @@
-import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 /*
 Copyright 2015 - 2023 The Matrix.org Foundation C.I.C.
@@ -56,11 +54,11 @@ export { EventStatus } from "./event-status.js";
  */
 
 // A singleton implementing `IMessageVisibilityVisible`.
-var MESSAGE_VISIBLE = Object.freeze({
+const MESSAGE_VISIBLE = Object.freeze({
   visible: true
 });
-export var MAX_STICKY_DURATION_MS = 3600000;
-export var MatrixEventEvent = /*#__PURE__*/function (MatrixEventEvent) {
+export const MAX_STICKY_DURATION_MS = 3600000;
+export let MatrixEventEvent = /*#__PURE__*/function (MatrixEventEvent) {
   /**
    * An event has been decrypted, or we have failed to decrypt it.
    *
@@ -89,23 +87,22 @@ export class MatrixEvent extends TypedEventEmitter {
    * @internal
    */
   setMetadata(stateContext, toStartOfTimeline) {
-    var _this$sender, _this$target;
     // If an event is an m.room.member state event then we should set the sentinels again in case setEventMetadata
     // was already called before the state was applied and thus the sentinel points at the member from before this event.
-    var affectsSelf = this.isState() && this.getType() === EventType.RoomMember && this.getSender() === this.getStateKey();
-    var changed = false;
+    const affectsSelf = this.isState() && this.getType() === EventType.RoomMember && this.getSender() === this.getStateKey();
+    let changed = false;
     // When we try to generate a sentinel member before we have that member
     // in the members object, we still generate a sentinel but it doesn't
     // have a membership event, so test to see if events.member is set. We
     // check this to avoid overriding non-sentinel members by sentinel ones
     // when adding the event to a filtered timeline
-    if (affectsSelf || !((_this$sender = this.sender) !== null && _this$sender !== void 0 && (_this$sender = _this$sender.events) !== null && _this$sender !== void 0 && _this$sender.member)) {
-      var newSender = stateContext.getSentinelMember(this.getSender());
+    if (affectsSelf || !this.sender?.events?.member) {
+      const newSender = stateContext.getSentinelMember(this.getSender());
       if (newSender !== this.sender) changed = true;
       this.sender = newSender;
     }
-    if (affectsSelf || !((_this$target = this.target) !== null && _this$target !== void 0 && (_this$target = _this$target.events) !== null && _this$target !== void 0 && _this$target.member) && this.getType() === EventType.RoomMember) {
-      var newTarget = stateContext.getSentinelMember(this.getStateKey());
+    if (affectsSelf || !this.target?.events?.member && this.getType() === EventType.RoomMember) {
+      const newTarget = stateContext.getSentinelMember(this.getStateKey());
       if (newTarget !== this.target) changed = true;
       this.target = newTarget;
     }
@@ -129,16 +126,6 @@ export class MatrixEvent extends TypedEventEmitter {
    * Should be read-only
    */
 
-  /**
-   * The timestamp for when this event should expire, in milliseconds.
-   * Prefers using the server-provided value, but will fall back to local calculation.
-   *
-   * This value is **safe** to use, as malicious start time and duration are appropriately capped.
-   *
-   * If the event is not a sticky event (or not supported by the server),
-   * then this returns `undefined`.
-   */
-
   /**
    * Construct a Matrix Event object
    *
@@ -147,9 +134,7 @@ export class MatrixEvent extends TypedEventEmitter {
    * methods defined on this class. Using the getter methods shields your app
    * from changes to event JSON between Matrix versions.
    */
-  constructor() {
-    var _this$getTs;
-    var event = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  constructor(event = {}) {
     super();
 
     // intern the values of matrix events to force share strings and reduce the
@@ -163,6 +148,7 @@ export class MatrixEvent extends TypedEventEmitter {
     _defineProperty(this, "_replacingEvent", null);
     _defineProperty(this, "_localRedactionEvent", null);
     _defineProperty(this, "_isCancelled", false);
+    _defineProperty(this, "clearEvent", void 0);
     /* Message hiding, as specified by https://github.com/matrix-org/matrix-doc/pull/3531.
      Note: We're returning this object, so any value stored here MUST be frozen.
     */
@@ -182,6 +168,12 @@ export class MatrixEvent extends TypedEventEmitter {
      * the megolm session (for megolm) claims to own. See getClaimedEd25519Key()
      */
     _defineProperty(this, "claimedEd25519Key", null);
+    /**
+     * If another user forwarded the key to this message
+     * (eg via [MSC4268](https://github.com/matrix-org/matrix-spec-proposals/pull/4268)),
+     * the ID of that user.
+     */
+    _defineProperty(this, "keyForwardedBy", void 0);
     /* if we have a process decrypting this event, a Promise which resolves
      * when it is finished. Normally null.
      */
@@ -191,6 +183,22 @@ export class MatrixEvent extends TypedEventEmitter {
      * attempt may succeed)
      */
     _defineProperty(this, "retryDecryption", false);
+    /* The txnId with which this event was sent if it was during this session,
+     * allows for a unique ID which does not change when the event comes back down sync.
+     */
+    _defineProperty(this, "txnId", void 0);
+    /**
+     * A reference to the thread this event belongs to
+     */
+    _defineProperty(this, "thread", void 0);
+    _defineProperty(this, "threadId", void 0);
+    /* Set an approximate timestamp for the event relative the local clock.
+     * This will inherently be approximate because it doesn't take into account
+     * the time between the server putting the 'age' field on the event as it sent
+     * it to us and the time we're now constructing this event, but that's better
+     * than assuming the local clock is in sync with the origin HS's clock.
+     */
+    _defineProperty(this, "localTimestamp", void 0);
     /**
      * The room member who sent this event, or null e.g.
      * this is a presence event. This is only guaranteed to be set for events that
@@ -223,19 +231,28 @@ export class MatrixEvent extends TypedEventEmitter {
      * Should be read-only
      */
     _defineProperty(this, "forwardLooking", true);
+    _defineProperty(this, "reEmitter", void 0);
+    /**
+     * The timestamp for when this event should expire, in milliseconds.
+     * Prefers using the server-provided value, but will fall back to local calculation.
+     *
+     * This value is **safe** to use, as malicious start time and duration are appropriately capped.
+     *
+     * If the event is not a sticky event (or not supported by the server),
+     * then this returns `undefined`.
+     */
+    _defineProperty(this, "unstableStickyExpiresAt", void 0);
     this.event = event;
     ["state_key", "type", "sender", "room_id", "membership"].forEach(prop => {
       if (typeof event[prop] !== "string") return;
       event[prop] = internaliseString(event[prop]);
     });
     ["membership", "avatar_url", "displayname"].forEach(prop => {
-      var _event$content;
-      if (typeof ((_event$content = event.content) === null || _event$content === void 0 ? void 0 : _event$content[prop]) !== "string") return;
+      if (typeof event.content?.[prop] !== "string") return;
       event.content[prop] = internaliseString(event.content[prop]);
     });
     ["rel_type"].forEach(prop => {
-      var _event$content2;
-      if (typeof ((_event$content2 = event.content) === null || _event$content2 === void 0 || (_event$content2 = _event$content2["m.relates_to"]) === null || _event$content2 === void 0 ? void 0 : _event$content2[prop]) !== "string") return;
+      if (typeof event.content?.["m.relates_to"]?.[prop] !== "string") return;
       event.content["m.relates_to"][prop] = internaliseString(event.content["m.relates_to"][prop]);
     });
     this.txnId = event.txn_id;
@@ -244,9 +261,9 @@ export class MatrixEvent extends TypedEventEmitter {
     // or due to server-side bugs such as https://github.com/matrix-org/synapse/issues/8429.
     // The fallback in these cases will be to use the origin_server_ts.
     // For EDUs, the origin_server_ts also is not defined so we use Date.now().
-    var age = this.getAge();
-    var now = Date.now();
-    this.localTimestamp = age !== undefined ? now - age : (_this$getTs = this.getTs()) !== null && _this$getTs !== void 0 ? _this$getTs : now;
+    const age = this.getAge();
+    const now = Date.now();
+    this.localTimestamp = age !== undefined ? now - age : this.getTs() ?? now;
     this.reEmitter = new TypedReEmitter(this);
     if (this.unstableStickyInfo) {
       if (this.unstableStickyInfo.duration_ttl_ms) {
@@ -267,8 +284,7 @@ export class MatrixEvent extends TypedEventEmitter {
    */
   get unstableExtensibleEvent() {
     if (!this._hasCachedExtEv) {
-      var _ExtensibleEvents$par;
-      this._cachedExtEv = (_ExtensibleEvents$par = ExtensibleEvents.parse(this.getEffectiveEvent())) !== null && _ExtensibleEvents$par !== void 0 ? _ExtensibleEvents$par : undefined;
+      this._cachedExtEv = ExtensibleEvents.parse(this.getEffectiveEvent()) ?? undefined;
     }
     return this._cachedExtEv;
   }
@@ -286,7 +302,7 @@ export class MatrixEvent extends TypedEventEmitter {
    * @returns A shallow copy of the event, in wire format, as it would have been had it not been encrypted.
    */
   getEffectiveEvent() {
-    var content = Object.assign({}, this.getContent()); // clone for mutation
+    const content = Object.assign({}, this.getContent()); // clone for mutation
 
     if (this.getWireType() === EventType.RoomMessageEncrypted) {
       // Encrypted events sometimes aren't symmetrical on the `content` so we'll copy
@@ -294,16 +310,13 @@ export class MatrixEvent extends TypedEventEmitter {
       // between the plain and decrypted copies of `content` because we assume that the
       // app is relying on the decrypted version, so we want to expose that as a source
       // of truth here too.
-      for (var _ref3 of Object.entries(this.getWireContent())) {
-        var _ref2 = _slicedToArray(_ref3, 2);
-        var _key = _ref2[0];
-        var value = _ref2[1];
+      for (const [key, value] of Object.entries(this.getWireContent())) {
         // Skip fields from the encrypted event schema though - we don't want to leak
         // these.
-        if (["algorithm", "ciphertext", "device_id", "sender_key", "session_id"].includes(_key)) {
+        if (["algorithm", "ciphertext", "device_id", "sender_key", "session_id"].includes(key)) {
           continue;
         }
-        if (content[_key] === undefined) content[_key] = value;
+        if (content[key] === undefined) content[key] = value;
       }
     }
 
@@ -391,15 +404,14 @@ export class MatrixEvent extends TypedEventEmitter {
    * ```
    */
   getDetails() {
-    var room = this.getRoomId();
+    const room = this.getRoomId();
     if (room) {
-      var _this$getDate;
       // in-room event
-      return "id=".concat(this.getId(), " type=").concat(this.getWireType(), " sender=").concat(this.getSender(), " room=").concat(room, " ts=").concat((_this$getDate = this.getDate()) === null || _this$getDate === void 0 ? void 0 : _this$getDate.toISOString());
+      return `id=${this.getId()} type=${this.getWireType()} sender=${this.getSender()} room=${room} ts=${this.getDate()?.toISOString()}`;
     } else {
       // to-device event
-      var msgid = this.getContent()[ToDeviceMessageId];
-      return "msgid=".concat(msgid, " type=").concat(this.getWireType(), " sender=").concat(this.getSender());
+      const msgid = this.getContent()[ToDeviceMessageId];
+      return `msgid=${msgid} type=${this.getWireType()} sender=${this.getSender()}`;
     }
   }
 
@@ -410,15 +422,13 @@ export class MatrixEvent extends TypedEventEmitter {
    * @returns The event content JSON, or an empty object.
    */
   getOriginalContent() {
-    var _this$event$content;
     if (this._localRedactionEvent) {
       return {};
     }
     if (this.clearEvent) {
-      var _this$clearEvent$cont;
-      return (_this$clearEvent$cont = this.clearEvent.content) !== null && _this$clearEvent$cont !== void 0 ? _this$clearEvent$cont : {};
+      return this.clearEvent.content ?? {};
     }
-    return (_this$event$content = this.event.content) !== null && _this$event$content !== void 0 ? _this$event$content : {};
+    return this.event.content ?? {};
   }
 
   /**
@@ -432,8 +442,7 @@ export class MatrixEvent extends TypedEventEmitter {
     if (this._localRedactionEvent) {
       return {};
     } else if (this._replacingEvent) {
-      var _this$_replacingEvent;
-      return (_this$_replacingEvent = this._replacingEvent.getContent()["m.new_content"]) !== null && _this$_replacingEvent !== void 0 ? _this$_replacingEvent : {};
+      return this._replacingEvent.getContent()["m.new_content"] ?? {};
     } else {
       return this.getOriginalContent();
     }
@@ -453,13 +462,12 @@ export class MatrixEvent extends TypedEventEmitter {
    * Get the event ID of the thread head
    */
   get threadRootId() {
-    var _this$getWireContent;
     // don't allow state events to be threaded as per the spec
     if (this.isState()) {
       return undefined;
     }
-    var relatesTo = (_this$getWireContent = this.getWireContent()) === null || _this$getWireContent === void 0 ? void 0 : _this$getWireContent["m.relates_to"];
-    if ((relatesTo === null || relatesTo === void 0 ? void 0 : relatesTo.rel_type) === THREAD_RELATION_TYPE.name) {
+    const relatesTo = this.getWireContent()?.["m.relates_to"];
+    if (relatesTo?.rel_type === THREAD_RELATION_TYPE.name) {
       return relatesTo.event_id;
     }
     if (this.thread) {
@@ -468,7 +476,7 @@ export class MatrixEvent extends TypedEventEmitter {
     if (this.threadId !== undefined) {
       return this.threadId;
     }
-    var unsigned = this.getUnsigned();
+    const unsigned = this.getUnsigned();
     if (typeof unsigned[UNSIGNED_THREAD_ID_FIELD.name] === "string") {
       return unsigned[UNSIGNED_THREAD_ID_FIELD.name];
     }
@@ -483,7 +491,7 @@ export class MatrixEvent extends TypedEventEmitter {
     if (this.isState()) {
       return false;
     }
-    var threadDetails = this.getServerAggregatedRelation(THREAD_RELATION_TYPE.name);
+    const threadDetails = this.getServerAggregatedRelation(THREAD_RELATION_TYPE.name);
 
     // Bundled relationships only returned when the sync response is limited
     // hence us having to check both bundled relation and inspect the thread
@@ -491,12 +499,10 @@ export class MatrixEvent extends TypedEventEmitter {
     return !!threadDetails || this.threadRootId === this.getId();
   }
   get replyEventId() {
-    var _this$getWireContent$;
-    return (_this$getWireContent$ = this.getWireContent()["m.relates_to"]) === null || _this$getWireContent$ === void 0 || (_this$getWireContent$ = _this$getWireContent$["m.in_reply_to"]) === null || _this$getWireContent$ === void 0 ? void 0 : _this$getWireContent$.event_id;
+    return this.getWireContent()["m.relates_to"]?.["m.in_reply_to"]?.event_id;
   }
   get relationEventId() {
-    var _this$getWireContent2;
-    return (_this$getWireContent2 = this.getWireContent()) === null || _this$getWireContent2 === void 0 || (_this$getWireContent2 = _this$getWireContent2["m.relates_to"]) === null || _this$getWireContent2 === void 0 ? void 0 : _this$getWireContent2.event_id;
+    return this.getWireContent()?.["m.relates_to"]?.event_id;
   }
 
   /**
@@ -582,7 +588,7 @@ export class MatrixEvent extends TypedEventEmitter {
    *   not report it.
    */
   getMembershipAtEvent() {
-    var unsigned = this.getUnsigned();
+    const unsigned = this.getUnsigned();
     return UNSIGNED_MEMBERSHIP_FIELD.findIn(unsigned);
   }
 
@@ -619,7 +625,7 @@ export class MatrixEvent extends TypedEventEmitter {
 
     // if this is a state event, pack cleartext type and statekey
     if (this.isState()) {
-      this.event.state_key = "".concat(this.clearEvent.type, ":").concat(this.clearEvent.state_key);
+      this.event.state_key = `${this.clearEvent.type}:${this.clearEvent.state_key}`;
     }
   }
 
@@ -671,35 +677,30 @@ export class MatrixEvent extends TypedEventEmitter {
    * @returns promise which resolves (to undefined) when the decryption
    * attempt is completed.
    */
-  attemptDecryption(crypto) {
-    var _arguments = arguments,
-      _this = this;
-    return _asyncToGenerator(function* () {
-      var options = _arguments.length > 1 && _arguments[1] !== undefined ? _arguments[1] : {};
-      // start with a couple of sanity checks.
-      if (!_this.isEncrypted()) {
-        throw new Error("Attempt to decrypt event which isn't encrypted");
-      }
-      var alreadyDecrypted = _this.clearEvent && !_this.isDecryptionFailure();
-      if (alreadyDecrypted) {
-        // we may want to just ignore this? let's start with rejecting it.
-        throw new Error("Attempt to decrypt event which has already been decrypted");
-      }
+  async attemptDecryption(crypto, options = {}) {
+    // start with a couple of sanity checks.
+    if (!this.isEncrypted()) {
+      throw new Error("Attempt to decrypt event which isn't encrypted");
+    }
+    const alreadyDecrypted = this.clearEvent && !this.isDecryptionFailure();
+    if (alreadyDecrypted) {
+      // we may want to just ignore this? let's start with rejecting it.
+      throw new Error("Attempt to decrypt event which has already been decrypted");
+    }
 
-      // if we already have a decryption attempt in progress, then it may
-      // fail because it was using outdated info. We now have reason to
-      // succeed where it failed before, but we don't want to have multiple
-      // attempts going at the same time, so just set a flag that says we have
-      // new info.
-      //
-      if (_this.decryptionPromise) {
-        logger.log("Event ".concat(_this.getId(), " already being decrypted; queueing a retry"));
-        _this.retryDecryption = true;
-        return _this.decryptionPromise;
-      }
-      _this.decryptionPromise = _this.decryptionLoop(crypto, options);
-      return _this.decryptionPromise;
-    })();
+    // if we already have a decryption attempt in progress, then it may
+    // fail because it was using outdated info. We now have reason to
+    // succeed where it failed before, but we don't want to have multiple
+    // attempts going at the same time, so just set a flag that says we have
+    // new info.
+    //
+    if (this.decryptionPromise) {
+      logger.log(`Event ${this.getId()} already being decrypted; queueing a retry`);
+      this.retryDecryption = true;
+      return this.decryptionPromise;
+    }
+    this.decryptionPromise = this.decryptionLoop(crypto, options);
+    return this.decryptionPromise;
   }
 
   /**
@@ -711,90 +712,85 @@ export class MatrixEvent extends TypedEventEmitter {
    */
   getKeyRequestRecipients(userId) {
     // send the request to all of our own devices
-    var recipients = [{
+    const recipients = [{
       userId,
       deviceId: "*"
     }];
     return recipients;
   }
-  decryptionLoop(crypto) {
-    var _arguments2 = arguments,
-      _this2 = this;
-    return _asyncToGenerator(function* () {
-      var options = _arguments2.length > 1 && _arguments2[1] !== undefined ? _arguments2[1] : {};
-      // make sure that this method never runs completely synchronously.
-      // (doing so would mean that we would clear decryptionPromise *before*
-      // it is set in attemptDecryption - and hence end up with a stuck
-      // `decryptionPromise`).
-      yield Promise.resolve();
-
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
-        _this2.retryDecryption = false;
-        var err = undefined;
-        try {
-          var res = yield crypto.decryptEvent(_this2);
-          if (options.isRetry === true) {
-            logger.info("Decrypted event on retry (".concat(_this2.getDetails(), ")"));
-          }
-          _this2.setClearData(res);
-          _this2._decryptionFailureReason = null;
-        } catch (e) {
-          var detailedError = e instanceof DecryptionError ? e.detailedString : String(e);
-          err = e;
-
-          // see if we have a retry queued.
-          //
-          // NB: make sure to keep this check in the same tick of the
-          //   event loop as `decryptionPromise = null` below - otherwise we
-          //   risk a race:
-          //
-          //   * A: we check retryDecryption here and see that it is
-          //        false
-          //   * B: we get a second call to attemptDecryption, which sees
-          //        that decryptionPromise is set so sets
-          //        retryDecryption
-          //   * A: we continue below, clear decryptionPromise, and
-          //        never do the retry.
-          //
-          if (_this2.retryDecryption) {
-            // decryption error, but we have a retry queued.
-            logger.log("Error decrypting event (".concat(_this2.getDetails(), "), but retrying: ").concat(detailedError));
-            continue;
-          }
-
-          // decryption error, no retries queued. Warn about the error and
-          // set it to m.bad.encrypted.
-          //
-          // the detailedString already includes the name and message of the error, and the stack isn't much use,
-          // so we don't bother to log `e` separately.
-          logger.warn("Error decrypting event (".concat(_this2.getDetails(), "): ").concat(detailedError));
-          _this2.setClearDataForDecryptionFailure(String(e));
-          _this2._decryptionFailureReason = e instanceof DecryptionError ? e.code : DecryptionFailureCode.UNKNOWN_ERROR;
+  async decryptionLoop(crypto, options = {}) {
+    // make sure that this method never runs completely synchronously.
+    // (doing so would mean that we would clear decryptionPromise *before*
+    // it is set in attemptDecryption - and hence end up with a stuck
+    // `decryptionPromise`).
+    await Promise.resolve();
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      this.retryDecryption = false;
+      let err = undefined;
+      try {
+        const res = await crypto.decryptEvent(this);
+        if (options.isRetry === true) {
+          logger.info(`Decrypted event on retry (${this.getDetails()})`);
         }
+        this.setClearData(res);
+        this._decryptionFailureReason = null;
+      } catch (e) {
+        const detailedError = e instanceof DecryptionError ? e.detailedString : String(e);
+        err = e;
 
-        // Make sure we clear 'decryptionPromise' before sending the 'Event.decrypted' event,
-        // otherwise the app will be confused to see `isBeingDecrypted` still set when
-        // there isn't an `Event.decrypted` on the way.
+        // see if we have a retry queued.
         //
-        // see also notes on retryDecryption above.
+        // NB: make sure to keep this check in the same tick of the
+        //   event loop as `decryptionPromise = null` below - otherwise we
+        //   risk a race:
         //
-        _this2.decryptionPromise = null;
-        _this2.retryDecryption = false;
-
-        // Before we emit the event, clear the push actions so that they can be recalculated
-        // by relevant code. We do this because the clear event has now changed, making it
-        // so that existing rules can be re-run over the applicable properties. Stuff like
-        // highlighting when the user's name is mentioned rely on this happening. We also want
-        // to set the push actions before emitting so that any notification listeners don't
-        // pick up the wrong contents.
-        _this2.setPushDetails();
-        if (options.emit !== false) {
-          _this2.emit(MatrixEventEvent.Decrypted, _this2, err);
+        //   * A: we check retryDecryption here and see that it is
+        //        false
+        //   * B: we get a second call to attemptDecryption, which sees
+        //        that decryptionPromise is set so sets
+        //        retryDecryption
+        //   * A: we continue below, clear decryptionPromise, and
+        //        never do the retry.
+        //
+        if (this.retryDecryption) {
+          // decryption error, but we have a retry queued.
+          logger.log(`Error decrypting event (${this.getDetails()}), but retrying: ${detailedError}`);
+          continue;
         }
-        return;
+
+        // decryption error, no retries queued. Warn about the error and
+        // set it to m.bad.encrypted.
+        //
+        // the detailedString already includes the name and message of the error, and the stack isn't much use,
+        // so we don't bother to log `e` separately.
+        logger.warn(`Error decrypting event (${this.getDetails()}): ${detailedError}`);
+        this.setClearDataForDecryptionFailure(String(e));
+        this._decryptionFailureReason = e instanceof DecryptionError ? e.code : DecryptionFailureCode.UNKNOWN_ERROR;
+      }
+
+      // Make sure we clear 'decryptionPromise' before sending the 'Event.decrypted' event,
+      // otherwise the app will be confused to see `isBeingDecrypted` still set when
+      // there isn't an `Event.decrypted` on the way.
+      //
+      // see also notes on retryDecryption above.
+      //
+      this.decryptionPromise = null;
+      this.retryDecryption = false;
+
+      // Before we emit the event, clear the push actions so that they can be recalculated
+      // by relevant code. We do this because the clear event has now changed, making it
+      // so that existing rules can be re-run over the applicable properties. Stuff like
+      // highlighting when the user's name is mentioned rely on this happening. We also want
+      // to set the push actions before emitting so that any notification listeners don't
+      // pick up the wrong contents.
+      this.setPushDetails();
+      if (options.emit !== false) {
+        this.emit(MatrixEventEvent.Decrypted, this, err);
       }
-    })();
+      return;
+    }
   }
 
   /**
@@ -807,10 +803,9 @@ export class MatrixEvent extends TypedEventEmitter {
    * @param decryptionResult - the decryption result, including the plaintext and some key info
    */
   setClearData(decryptionResult) {
-    var _decryptionResult$sen, _decryptionResult$cla;
     this.clearEvent = decryptionResult.clearEvent;
-    this.senderCurve25519Key = (_decryptionResult$sen = decryptionResult.senderCurve25519Key) !== null && _decryptionResult$sen !== void 0 ? _decryptionResult$sen : null;
-    this.claimedEd25519Key = (_decryptionResult$cla = decryptionResult.claimedEd25519Key) !== null && _decryptionResult$cla !== void 0 ? _decryptionResult$cla : null;
+    this.senderCurve25519Key = decryptionResult.senderCurve25519Key ?? null;
+    this.claimedEd25519Key = decryptionResult.claimedEd25519Key ?? null;
     this.keyForwardedBy = decryptionResult.keyForwardedBy;
     this.invalidateExtensibleEvent();
   }
@@ -825,7 +820,7 @@ export class MatrixEvent extends TypedEventEmitter {
       type: EventType.RoomMessage,
       content: {
         msgtype: "m.bad.encrypted",
-        body: "** Unable to decrypt: ".concat(reason, " **")
+        body: `** Unable to decrypt: ${reason} **`
       }
     };
     this.senderCurve25519Key = null;
@@ -934,7 +929,7 @@ export class MatrixEvent extends TypedEventEmitter {
     this.event.unsigned = unsigned;
   }
   unmarkLocallyRedacted() {
-    var value = this._localRedactionEvent;
+    const value = this._localRedactionEvent;
     this._localRedactionEvent = null;
     if (this.event.unsigned) {
       this.event.unsigned.redacted_because = undefined;
@@ -965,10 +960,9 @@ export class MatrixEvent extends TypedEventEmitter {
    *   changing the reason (if it was hidden).
    */
   applyVisibilityEvent(visibilityChange) {
-    var _visibilityChange$vis, _visibilityChange$rea;
-    var visible = (_visibilityChange$vis = visibilityChange === null || visibilityChange === void 0 ? void 0 : visibilityChange.visible) !== null && _visibilityChange$vis !== void 0 ? _visibilityChange$vis : true;
-    var reason = (_visibilityChange$rea = visibilityChange === null || visibilityChange === void 0 ? void 0 : visibilityChange.reason) !== null && _visibilityChange$rea !== void 0 ? _visibilityChange$rea : null;
-    var change = false;
+    const visible = visibilityChange?.visible ?? true;
+    const reason = visibilityChange?.reason ?? null;
+    let change = false;
     if (this.visibility.visible !== visible) {
       change = true;
     } else if (!this.visibility.visible && this.visibility["reason"] !== reason) {
@@ -1024,9 +1018,9 @@ export class MatrixEvent extends TypedEventEmitter {
       this.event.unsigned = {};
     }
     this.event.unsigned.redacted_because = redactionEvent.event;
-    for (var _key2 in this.event) {
-      if (this.event.hasOwnProperty(_key2) && !REDACT_KEEP_KEYS.has(_key2)) {
-        delete this.event[_key2];
+    for (const key in this.event) {
+      if (this.event.hasOwnProperty(key) && !REDACT_KEEP_KEYS.has(key)) {
+        delete this.event[key];
       }
     }
 
@@ -1034,11 +1028,11 @@ export class MatrixEvent extends TypedEventEmitter {
     if (this.isEncrypted()) {
       this.clearEvent = undefined;
     }
-    var keeps = this.getType() in REDACT_KEEP_CONTENT_MAP ? REDACT_KEEP_CONTENT_MAP[this.getType()] : {};
-    var content = this.getContent();
-    for (var _key3 in content) {
-      if (content.hasOwnProperty(_key3) && !keeps[_key3]) {
-        delete content[_key3];
+    const keeps = this.getType() in REDACT_KEEP_CONTENT_MAP ? REDACT_KEEP_CONTENT_MAP[this.getType()] : {};
+    const content = this.getContent();
+    for (const key in content) {
+      if (content.hasOwnProperty(key) && !keeps[key]) {
+        delete content[key];
       }
     }
 
@@ -1051,28 +1045,26 @@ export class MatrixEvent extends TypedEventEmitter {
     this.invalidateExtensibleEvent();
   }
   moveAllRelatedToMainTimeline(room) {
-    var thread = this.thread;
+    const thread = this.thread;
     this.moveToMainTimeline(room);
 
     // If we dont have access to the thread, we can only move this
     // event, not things related to it.
     if (thread) {
-      for (var _event of thread.events) {
-        var _event$getRelation;
-        if (((_event$getRelation = _event.getRelation()) === null || _event$getRelation === void 0 ? void 0 : _event$getRelation.event_id) === this.getId()) {
-          _event.moveAllRelatedToMainTimeline(room);
+      for (const event of thread.events) {
+        if (event.getRelation()?.event_id === this.getId()) {
+          event.moveAllRelatedToMainTimeline(room);
         }
       }
     }
   }
   moveToMainTimeline(room) {
-    var _this$thread;
     // Remove it from its thread
-    (_this$thread = this.thread) === null || _this$thread === void 0 || _this$thread.timelineSet.removeEvent(this.getId());
+    this.thread?.timelineSet.removeEvent(this.getId());
     this.setThread(undefined);
 
     // And insert it into the main timeline
-    var timeline = room.getLiveTimeline();
+    const timeline = room.getLiveTimeline();
     // We use insertEventIntoTimeline to insert it in timestamp order,
     // because we don't know where it should go (until we have MSC4033).
     timeline.getTimelineSet().insertEventIntoTimeline(this, timeline, timeline.getState(EventTimeline.FORWARDS), false);
@@ -1108,19 +1100,19 @@ export class MatrixEvent extends TypedEventEmitter {
       // Not a visibility change event.
       return null;
     }
-    var relation = this.getRelation();
+    const relation = this.getRelation();
     if (!relation || relation.rel_type != "m.reference") {
       // Ill-formed, ignore this event.
       return null;
     }
-    var eventId = relation.event_id;
+    const eventId = relation.event_id;
     if (!eventId) {
       // Ill-formed, ignore this event.
       return null;
     }
-    var content = this.getWireContent();
-    var visible = !!content.visible;
-    var reason = content.reason;
+    const content = this.getWireContent();
+    const visible = !!content.visible;
+    const reason = content.reason;
     if (reason && typeof reason != "string") {
       // Ill-formed, ignore this event.
       return null;
@@ -1151,12 +1143,10 @@ export class MatrixEvent extends TypedEventEmitter {
    * @returns The redaction event JSON, or an empty object
    */
   getRedactionEvent() {
-    var _this$clearEvent, _this$event$unsigned;
     if (!this.isRedacted()) return null;
-    if ((_this$clearEvent = this.clearEvent) !== null && _this$clearEvent !== void 0 && _this$clearEvent.unsigned) {
-      var _this$clearEvent$unsi, _this$clearEvent2;
-      return (_this$clearEvent$unsi = (_this$clearEvent2 = this.clearEvent) === null || _this$clearEvent2 === void 0 ? void 0 : _this$clearEvent2.unsigned.redacted_because) !== null && _this$clearEvent$unsi !== void 0 ? _this$clearEvent$unsi : null;
-    } else if ((_this$event$unsigned = this.event.unsigned) !== null && _this$event$unsigned !== void 0 && _this$event$unsigned.redacted_because) {
+    if (this.clearEvent?.unsigned) {
+      return this.clearEvent?.unsigned.redacted_because ?? null;
+    } else if (this.event.unsigned?.redacted_because) {
       return this.event.unsigned.redacted_because;
     } else {
       return {};
@@ -1199,9 +1189,8 @@ export class MatrixEvent extends TypedEventEmitter {
    * @param event - the object to assign to the `event` property
    */
   handleRemoteEcho(event) {
-    var _this$getAge;
-    var oldUnsigned = this.getUnsigned();
-    var oldId = this.getId();
+    const oldUnsigned = this.getUnsigned();
+    const oldId = this.getId();
     this.event = event;
     // if this event was redacted before it was sent, it's locally marked as redacted.
     // At this point, we've received the remote echo for the event, but not yet for
@@ -1220,7 +1209,7 @@ export class MatrixEvent extends TypedEventEmitter {
       // emit the event if it changed
       this.emit(MatrixEventEvent.LocalEventIdReplaced, this);
     }
-    this.localTimestamp = Date.now() - ((_this$getAge = this.getAge()) !== null && _this$getAge !== void 0 ? _this$getAge : 0);
+    this.localTimestamp = Date.now() - (this.getAge() ?? 0);
   }
 
   /**
@@ -1253,26 +1242,24 @@ export class MatrixEvent extends TypedEventEmitter {
    * given type
    */
   isRelation(relType) {
-    var _this$getWireContent3;
     // Relation info is lifted out of the encrypted content when sent to
     // encrypted rooms, so we have to check `getWireContent` for this.
-    var relation = (_this$getWireContent3 = this.getWireContent()) === null || _this$getWireContent3 === void 0 ? void 0 : _this$getWireContent3["m.relates_to"];
-    if (this.isState() && !!(relation !== null && relation !== void 0 && relation.rel_type) && [RelationType.Replace, RelationType.Thread].includes(relation.rel_type)) {
+    const relation = this.getWireContent()?.["m.relates_to"];
+    if (this.isState() && !!relation?.rel_type && [RelationType.Replace, RelationType.Thread].includes(relation.rel_type)) {
       // State events cannot be m.replace or m.thread relations
       return false;
     }
-    return !!(relation !== null && relation !== void 0 && relation.rel_type && relation.event_id && (relType ? relation.rel_type === relType : true));
+    return !!(relation?.rel_type && relation.event_id && (relType ? relation.rel_type === relType : true));
   }
 
   /**
    * Get relation info for the event, if any.
    */
   getRelation() {
-    var _this$getWireContent$2;
     if (!this.isRelation()) {
       return null;
     }
-    return (_this$getWireContent$2 = this.getWireContent()["m.relates_to"]) !== null && _this$getWireContent$2 !== void 0 ? _this$getWireContent$2 : null;
+    return this.getWireContent()["m.relates_to"] ?? null;
   }
 
   /**
@@ -1296,7 +1283,7 @@ export class MatrixEvent extends TypedEventEmitter {
       return;
     }
     if (this._replacingEvent !== newEvent) {
-      this._replacingEvent = newEvent !== null && newEvent !== void 0 ? newEvent : null;
+      this._replacingEvent = newEvent ?? null;
       this.emit(MatrixEventEvent.Replaced, this);
       this.invalidateExtensibleEvent();
     }
@@ -1316,15 +1303,14 @@ export class MatrixEvent extends TypedEventEmitter {
     return this.status;
   }
   getServerAggregatedRelation(relType) {
-    var _this$getUnsigned$mR;
-    return (_this$getUnsigned$mR = this.getUnsigned()["m.relations"]) === null || _this$getUnsigned$mR === void 0 ? void 0 : _this$getUnsigned$mR[relType];
+    return this.getUnsigned()["m.relations"]?.[relType];
   }
 
   /**
    * Returns the event ID of the event replacing the content of this event, if any.
    */
   replacingEventId() {
-    var replaceRelation = this.getServerAggregatedRelation(RelationType.Replace);
+    const replaceRelation = this.getServerAggregatedRelation(RelationType.Replace);
     if (replaceRelation) {
       return replaceRelation.event_id;
     } else if (this._replacingEvent) {
@@ -1345,15 +1331,14 @@ export class MatrixEvent extends TypedEventEmitter {
    * Returns the origin_server_ts of the event replacing the content of this event, if any.
    */
   replacingEventDate() {
-    var replaceRelation = this.getServerAggregatedRelation(RelationType.Replace);
+    const replaceRelation = this.getServerAggregatedRelation(RelationType.Replace);
     if (replaceRelation) {
-      var ts = replaceRelation.origin_server_ts;
+      const ts = replaceRelation.origin_server_ts;
       if (Number.isFinite(ts)) {
         return new Date(ts);
       }
     } else if (this._replacingEvent) {
-      var _this$_replacingEvent2;
-      return (_this$_replacingEvent2 = this._replacingEvent.getDate()) !== null && _this$_replacingEvent2 !== void 0 ? _this$_replacingEvent2 : undefined;
+      return this._replacingEvent.getDate() ?? undefined;
     }
   }
 
@@ -1369,7 +1354,7 @@ export class MatrixEvent extends TypedEventEmitter {
    * For relations and redactions, returns the event_id this event is referring to.
    */
   getAssociatedId() {
-    var relation = this.getRelation();
+    const relation = this.getRelation();
     if (this.replyEventId) {
       return this.replyEventId;
     } else if (relation) {
@@ -1395,7 +1380,7 @@ export class MatrixEvent extends TypedEventEmitter {
    * @param eventId - the new event id
    */
   updateAssociatedId(eventId) {
-    var relation = this.getRelation();
+    const relation = this.getRelation();
     if (relation) {
       relation.event_id = eventId;
     } else if (this.isRedaction()) {
@@ -1409,8 +1394,7 @@ export class MatrixEvent extends TypedEventEmitter {
    * listeners that a cancellation event is coming down the same pipe shortly.
    * @param cancelled - Whether the event is to be cancelled or not.
    */
-  flagCancelled() {
-    var cancelled = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  flagCancelled(cancelled = true) {
     this._isCancelled = cancelled;
   }
 
@@ -1438,11 +1422,8 @@ export class MatrixEvent extends TypedEventEmitter {
    * @returns A snapshot of this event.
    */
   toSnapshot() {
-    var ev = new MatrixEvent(JSON.parse(JSON.stringify(this.event)));
-    for (var _ref6 of Object.entries(this)) {
-      var _ref5 = _slicedToArray(_ref6, 2);
-      var p = _ref5[0];
-      var v = _ref5[1];
+    const ev = new MatrixEvent(JSON.parse(JSON.stringify(this.event)));
+    for (const [p, v] of Object.entries(this)) {
       if (p !== "event") {
         // exclude the thing we just cloned
         // @ts-ignore - XXX: this is just nasty
@@ -1462,8 +1443,8 @@ export class MatrixEvent extends TypedEventEmitter {
   isEquivalentTo(otherEvent) {
     if (!otherEvent) return false;
     if (otherEvent === this) return true;
-    var myProps = deepSortedObjectEntries(this.event);
-    var theirProps = deepSortedObjectEntries(otherEvent.event);
+    const myProps = deepSortedObjectEntries(this.event);
+    const theirProps = deepSortedObjectEntries(otherEvent.event);
     return JSON.stringify(myProps) === JSON.stringify(theirProps);
   }
 
@@ -1485,7 +1466,7 @@ export class MatrixEvent extends TypedEventEmitter {
    * In any case, the value it returns is not a faithful serialization of the object.
    */
   toJSON() {
-    var event = this.getEffectiveEvent();
+    const event = this.getEffectiveEvent();
     if (!this.isEncrypted()) {
       return event;
     }
@@ -1514,7 +1495,7 @@ export class MatrixEvent extends TypedEventEmitter {
       this.reEmitter.stopReEmitting(this.thread, [ThreadEvent.Update]);
     }
     this.thread = thread;
-    this.setThreadId(thread === null || thread === void 0 ? void 0 : thread.id);
+    this.setThreadId(thread?.id);
     if (thread) {
       this.reEmitter.reEmit(thread, [ThreadEvent.Update]);
     }
@@ -1538,14 +1519,13 @@ export class MatrixEvent extends TypedEventEmitter {
    * `duration_ms` is safely bounded to a hour.
    */
   get unstableStickyInfo() {
-    var _this$event$msc4354_s, _this$event$unsigned2;
-    if (!((_this$event$msc4354_s = this.event.msc4354_sticky) !== null && _this$event$msc4354_s !== void 0 && _this$event$msc4354_s.duration_ms)) {
+    if (!this.event.msc4354_sticky?.duration_ms) {
       return undefined;
     }
     return {
       duration_ms: Math.min(MAX_STICKY_DURATION_MS, this.event.msc4354_sticky.duration_ms),
       // This is assumed to be bounded server-side.
-      duration_ttl_ms: (_this$event$unsigned2 = this.event.unsigned) === null || _this$event$unsigned2 === void 0 ? void 0 : _this$event$unsigned2.msc4354_sticky_duration_ttl_ms
+      duration_ttl_ms: this.event.unsigned?.msc4354_sticky_duration_ttl_ms
     };
   }
 }
@@ -1559,10 +1539,10 @@ export class MatrixEvent extends TypedEventEmitter {
  *  - We keep 'unsigned' since that is created by the local server
  *  - We keep user_id for backwards-compat with v1
  */
-var REDACT_KEEP_KEYS = new Set(["event_id", "type", "room_id", "user_id", "sender", "state_key", "prev_state", "content", "unsigned", "origin_server_ts"]);
+const REDACT_KEEP_KEYS = new Set(["event_id", "type", "room_id", "user_id", "sender", "state_key", "prev_state", "content", "unsigned", "origin_server_ts"]);
 
 // a map from state event type to the .content keys we keep when an event is redacted
-var REDACT_KEEP_CONTENT_MAP = {
+const REDACT_KEEP_CONTENT_MAP = {
   [EventType.RoomMember]: {
     membership: 1
   },