@sudoplatform/sudo-secure-communications 0.0.1 → 5.0.1

package/vendor/matrix-js-sdk/lib/@types/polls.js

@@ -0,0 +1,2824 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/matrix-events-sdk/lib/NamespacedMap.js
+var require_NamespacedMap = __commonJS({
+  "node_modules/matrix-events-sdk/lib/NamespacedMap.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.NamespacedMap = void 0;
+    function _createForOfIteratorHelper(o, allowArrayLike) {
+      var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+      if (!it) {
+        if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+          if (it) o = it;
+          var i = 0;
+          var F = /* @__PURE__ */ __name(function F2() {
+          }, "F");
+          return { s: F, n: /* @__PURE__ */ __name(function n() {
+            if (i >= o.length) return { done: true };
+            return { done: false, value: o[i++] };
+          }, "n"), e: /* @__PURE__ */ __name(function e(_e) {
+            throw _e;
+          }, "e"), f: F };
+        }
+        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+      }
+      var normalCompletion = true, didErr = false, err;
+      return { s: /* @__PURE__ */ __name(function s() {
+        it = it.call(o);
+      }, "s"), n: /* @__PURE__ */ __name(function n() {
+        var step = it.next();
+        normalCompletion = step.done;
+        return step;
+      }, "n"), e: /* @__PURE__ */ __name(function e(_e2) {
+        didErr = true;
+        err = _e2;
+      }, "e"), f: /* @__PURE__ */ __name(function f() {
+        try {
+          if (!normalCompletion && it["return"] != null) it["return"]();
+        } finally {
+          if (didErr) throw err;
+        }
+      }, "f") };
+    }
+    __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
+    function _unsupportedIterableToArray(o, minLen) {
+      if (!o) return;
+      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+      var n = Object.prototype.toString.call(o).slice(8, -1);
+      if (n === "Object" && o.constructor) n = o.constructor.name;
+      if (n === "Map" || n === "Set") return Array.from(o);
+      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+    }
+    __name(_unsupportedIterableToArray, "_unsupportedIterableToArray");
+    function _arrayLikeToArray(arr, len) {
+      if (len == null || len > arr.length) len = arr.length;
+      for (var i = 0, arr2 = new Array(len); i < len; i++) {
+        arr2[i] = arr[i];
+      }
+      return arr2;
+    }
+    __name(_arrayLikeToArray, "_arrayLikeToArray");
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    __name(_defineProperties, "_defineProperties");
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    __name(_createClass, "_createClass");
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(_defineProperty, "_defineProperty");
+    var NamespacedMap = /* @__PURE__ */ (function() {
+      function NamespacedMap2(initial) {
+        _classCallCheck(this, NamespacedMap2);
+        _defineProperty(this, "internalMap", /* @__PURE__ */ new Map());
+        if (initial) {
+          var _iterator = _createForOfIteratorHelper(initial), _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+              var val = _step.value;
+              this.set(val[0], val[1]);
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        }
+      }
+      __name(NamespacedMap2, "NamespacedMap");
+      _createClass(NamespacedMap2, [{
+        key: "get",
+        value: /* @__PURE__ */ __name(function get(key) {
+          if (key.name && this.internalMap.has(key.name)) {
+            return this.internalMap.get(key.name);
+          }
+          if (key.altName && this.internalMap.has(key.altName)) {
+            return this.internalMap.get(key.altName);
+          }
+          return null;
+        }, "get")
+        /**
+         * Sets a value in the map.
+         * @param {NS} key The key.
+         * @param {V} val The value.
+         */
+      }, {
+        key: "set",
+        value: /* @__PURE__ */ __name(function set(key, val) {
+          if (key.name) {
+            this.internalMap.set(key.name, val);
+          }
+          if (key.altName) {
+            this.internalMap.set(key.altName, val);
+          }
+        }, "set")
+        /**
+         * Determines if any of the valid namespaced values are present
+         * in the map.
+         * @param {NS} key The key.
+         * @returns {boolean} True if present.
+         */
+      }, {
+        key: "has",
+        value: /* @__PURE__ */ __name(function has(key) {
+          return !!this.get(key);
+        }, "has")
+        /**
+         * Removes all the namespaced values from the map.
+         * @param {NS} key The key.
+         */
+      }, {
+        key: "delete",
+        value: /* @__PURE__ */ __name(function _delete(key) {
+          if (key.name) {
+            this.internalMap["delete"](key.name);
+          }
+          if (key.altName) {
+            this.internalMap["delete"](key.altName);
+          }
+        }, "_delete")
+        /**
+         * Determines if the map contains a specific namespaced value
+         * instead of the parent NS type.
+         * @param {string} key The key.
+         * @returns {boolean} True if present.
+         */
+      }, {
+        key: "hasNamespaced",
+        value: /* @__PURE__ */ __name(function hasNamespaced(key) {
+          return this.internalMap.has(key);
+        }, "hasNamespaced")
+        /**
+         * Gets a specific namespaced value from the map instead of the
+         * parent NS type. Returns falsy if not found.
+         * @param {string} key The key.
+         * @returns {Optional<V>} The value, or falsy.
+         */
+      }, {
+        key: "getNamespaced",
+        value: /* @__PURE__ */ __name(function getNamespaced(key) {
+          return this.internalMap.get(key);
+        }, "getNamespaced")
+      }]);
+      return NamespacedMap2;
+    })();
+    exports.NamespacedMap = NamespacedMap;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/InvalidEventError.js
+var require_InvalidEventError = __commonJS({
+  "node_modules/matrix-events-sdk/lib/InvalidEventError.js"(exports) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    __name(_typeof, "_typeof");
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.InvalidEventError = void 0;
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    __name(_defineProperties, "_defineProperties");
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    __name(_createClass, "_createClass");
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      Object.defineProperty(subClass, "prototype", { writable: false });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    __name(_inherits, "_inherits");
+    function _createSuper(Derived) {
+      var hasNativeReflectConstruct = _isNativeReflectConstruct();
+      return /* @__PURE__ */ __name(function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+          var NewTarget = _getPrototypeOf(this).constructor;
+          result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+          result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+      }, "_createSuperInternal");
+    }
+    __name(_createSuper, "_createSuper");
+    function _possibleConstructorReturn(self, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      } else if (call !== void 0) {
+        throw new TypeError("Derived constructors may only return object or undefined");
+      }
+      return _assertThisInitialized(self);
+    }
+    __name(_possibleConstructorReturn, "_possibleConstructorReturn");
+    function _assertThisInitialized(self) {
+      if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self;
+    }
+    __name(_assertThisInitialized, "_assertThisInitialized");
+    function _wrapNativeSuper(Class) {
+      var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+      _wrapNativeSuper = /* @__PURE__ */ __name(function _wrapNativeSuper2(Class2) {
+        if (Class2 === null || !_isNativeFunction(Class2)) return Class2;
+        if (typeof Class2 !== "function") {
+          throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+          if (_cache.has(Class2)) return _cache.get(Class2);
+          _cache.set(Class2, Wrapper);
+        }
+        function Wrapper() {
+          return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+        }
+        __name(Wrapper, "Wrapper");
+        Wrapper.prototype = Object.create(Class2.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } });
+        return _setPrototypeOf(Wrapper, Class2);
+      }, "_wrapNativeSuper");
+      return _wrapNativeSuper(Class);
+    }
+    __name(_wrapNativeSuper, "_wrapNativeSuper");
+    function _construct(Parent, args, Class) {
+      if (_isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+      } else {
+        _construct = /* @__PURE__ */ __name(function _construct2(Parent2, args2, Class2) {
+          var a = [null];
+          a.push.apply(a, args2);
+          var Constructor = Function.bind.apply(Parent2, a);
+          var instance = new Constructor();
+          if (Class2) _setPrototypeOf(instance, Class2.prototype);
+          return instance;
+        }, "_construct");
+      }
+      return _construct.apply(null, arguments);
+    }
+    __name(_construct, "_construct");
+    function _isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+      if (Reflect.construct.sham) return false;
+      if (typeof Proxy === "function") return true;
+      try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    __name(_isNativeReflectConstruct, "_isNativeReflectConstruct");
+    function _isNativeFunction(fn) {
+      return Function.toString.call(fn).indexOf("[native code]") !== -1;
+    }
+    __name(_isNativeFunction, "_isNativeFunction");
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      }, "_setPrototypeOf");
+      return _setPrototypeOf(o, p);
+    }
+    __name(_setPrototypeOf, "_setPrototypeOf");
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      }, "_getPrototypeOf");
+      return _getPrototypeOf(o);
+    }
+    __name(_getPrototypeOf, "_getPrototypeOf");
+    var InvalidEventError = /* @__PURE__ */ (function(_Error) {
+      _inherits(InvalidEventError2, _Error);
+      var _super = _createSuper(InvalidEventError2);
+      function InvalidEventError2(message) {
+        _classCallCheck(this, InvalidEventError2);
+        return _super.call(this, message);
+      }
+      __name(InvalidEventError2, "InvalidEventError");
+      return _createClass(InvalidEventError2);
+    })(/* @__PURE__ */ _wrapNativeSuper(Error));
+    exports.InvalidEventError = InvalidEventError;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/events/ExtensibleEvent.js
+var require_ExtensibleEvent = __commonJS({
+  "node_modules/matrix-events-sdk/lib/events/ExtensibleEvent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.ExtensibleEvent = void 0;
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    __name(_defineProperties, "_defineProperties");
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    __name(_createClass, "_createClass");
+    var ExtensibleEvent = /* @__PURE__ */ (function() {
+      function ExtensibleEvent2(wireFormat) {
+        _classCallCheck(this, ExtensibleEvent2);
+        this.wireFormat = wireFormat;
+      }
+      __name(ExtensibleEvent2, "ExtensibleEvent");
+      _createClass(ExtensibleEvent2, [{
+        key: "wireContent",
+        get: /* @__PURE__ */ __name(function get() {
+          return this.wireFormat.content;
+        }, "get")
+        /**
+         * Serializes the event into a format which can be used to send the
+         * event to the room.
+         * @returns {IPartialEvent<object>} The serialized event.
+         */
+      }]);
+      return ExtensibleEvent2;
+    })();
+    exports.ExtensibleEvent = ExtensibleEvent;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/types.js
+var require_types = __commonJS({
+  "node_modules/matrix-events-sdk/lib/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.isOptionalAString = isOptionalAString;
+    exports.isProvided = isProvided;
+    function isOptionalAString(s) {
+      return isProvided(s) && typeof s === "string";
+    }
+    __name(isOptionalAString, "isOptionalAString");
+    function isProvided(s) {
+      return s !== null && s !== void 0;
+    }
+    __name(isProvided, "isProvided");
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/NamespacedValue.js
+var require_NamespacedValue = __commonJS({
+  "node_modules/matrix-events-sdk/lib/NamespacedValue.js"(exports) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    __name(_typeof, "_typeof");
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.UnstableValue = exports.NamespacedValue = void 0;
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      Object.defineProperty(subClass, "prototype", { writable: false });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    __name(_inherits, "_inherits");
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      }, "_setPrototypeOf");
+      return _setPrototypeOf(o, p);
+    }
+    __name(_setPrototypeOf, "_setPrototypeOf");
+    function _createSuper(Derived) {
+      var hasNativeReflectConstruct = _isNativeReflectConstruct();
+      return /* @__PURE__ */ __name(function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+          var NewTarget = _getPrototypeOf(this).constructor;
+          result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+          result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+      }, "_createSuperInternal");
+    }
+    __name(_createSuper, "_createSuper");
+    function _possibleConstructorReturn(self, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      } else if (call !== void 0) {
+        throw new TypeError("Derived constructors may only return object or undefined");
+      }
+      return _assertThisInitialized(self);
+    }
+    __name(_possibleConstructorReturn, "_possibleConstructorReturn");
+    function _assertThisInitialized(self) {
+      if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self;
+    }
+    __name(_assertThisInitialized, "_assertThisInitialized");
+    function _isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+      if (Reflect.construct.sham) return false;
+      if (typeof Proxy === "function") return true;
+      try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    __name(_isNativeReflectConstruct, "_isNativeReflectConstruct");
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      }, "_getPrototypeOf");
+      return _getPrototypeOf(o);
+    }
+    __name(_getPrototypeOf, "_getPrototypeOf");
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    __name(_defineProperties, "_defineProperties");
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    __name(_createClass, "_createClass");
+    var NamespacedValue = /* @__PURE__ */ (function() {
+      function NamespacedValue2(stable, unstable) {
+        _classCallCheck(this, NamespacedValue2);
+        this.stable = stable;
+        this.unstable = unstable;
+        if (!this.unstable && !this.stable) {
+          throw new Error("One of stable or unstable values must be supplied");
+        }
+      }
+      __name(NamespacedValue2, "NamespacedValue");
+      _createClass(NamespacedValue2, [{
+        key: "name",
+        get: /* @__PURE__ */ __name(function get() {
+          if (this.stable) {
+            return this.stable;
+          }
+          return this.unstable;
+        }, "get")
+      }, {
+        key: "altName",
+        get: /* @__PURE__ */ __name(function get() {
+          if (!this.stable) {
+            return null;
+          }
+          return this.unstable;
+        }, "get")
+      }, {
+        key: "matches",
+        value: /* @__PURE__ */ __name(function matches(val) {
+          return !!this.name && this.name === val || !!this.altName && this.altName === val;
+        }, "matches")
+        // this desperately wants https://github.com/microsoft/TypeScript/pull/26349 at the top level of the class
+        // so we can instantiate `NamespacedValue<string, _, _>` as a default type for that namespace.
+      }, {
+        key: "findIn",
+        value: /* @__PURE__ */ __name(function findIn(obj) {
+          var val;
+          if (this.name) {
+            val = obj === null || obj === void 0 ? void 0 : obj[this.name];
+          }
+          if (!val && this.altName) {
+            val = obj === null || obj === void 0 ? void 0 : obj[this.altName];
+          }
+          return val;
+        }, "findIn")
+      }, {
+        key: "includedIn",
+        value: /* @__PURE__ */ __name(function includedIn(arr) {
+          var included = false;
+          if (this.name) {
+            included = arr.includes(this.name);
+          }
+          if (!included && this.altName) {
+            included = arr.includes(this.altName);
+          }
+          return included;
+        }, "includedIn")
+      }]);
+      return NamespacedValue2;
+    })();
+    exports.NamespacedValue = NamespacedValue;
+    var UnstableValue2 = /* @__PURE__ */ (function(_NamespacedValue) {
+      _inherits(UnstableValue3, _NamespacedValue);
+      var _super = _createSuper(UnstableValue3);
+      function UnstableValue3(stable, unstable) {
+        var _this;
+        _classCallCheck(this, UnstableValue3);
+        _this = _super.call(this, stable, unstable);
+        if (!_this.unstable) {
+          throw new Error("Unstable value must be supplied");
+        }
+        return _this;
+      }
+      __name(UnstableValue3, "UnstableValue");
+      _createClass(UnstableValue3, [{
+        key: "name",
+        get: /* @__PURE__ */ __name(function get() {
+          return this.unstable;
+        }, "get")
+      }, {
+        key: "altName",
+        get: /* @__PURE__ */ __name(function get() {
+          return this.stable;
+        }, "get")
+      }]);
+      return UnstableValue3;
+    })(NamespacedValue);
+    exports.UnstableValue = UnstableValue2;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/events/message_types.js
+var require_message_types = __commonJS({
+  "node_modules/matrix-events-sdk/lib/events/message_types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.M_TEXT = exports.M_NOTICE = exports.M_MESSAGE = exports.M_HTML = exports.M_EMOTE = void 0;
+    var _NamespacedValue = require_NamespacedValue();
+    var M_MESSAGE = new _NamespacedValue.UnstableValue("m.message", "org.matrix.msc1767.message");
+    exports.M_MESSAGE = M_MESSAGE;
+    var M_TEXT = new _NamespacedValue.UnstableValue("m.text", "org.matrix.msc1767.text");
+    exports.M_TEXT = M_TEXT;
+    var M_HTML = new _NamespacedValue.UnstableValue("m.html", "org.matrix.msc1767.html");
+    exports.M_HTML = M_HTML;
+    var M_EMOTE = new _NamespacedValue.UnstableValue("m.emote", "org.matrix.msc1767.emote");
+    exports.M_EMOTE = M_EMOTE;
+    var M_NOTICE = new _NamespacedValue.UnstableValue("m.notice", "org.matrix.msc1767.notice");
+    exports.M_NOTICE = M_NOTICE;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/utility/events.js
+var require_events = __commonJS({
+  "node_modules/matrix-events-sdk/lib/utility/events.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.isEventTypeSame = isEventTypeSame;
+    function isEventTypeSame(given, expected) {
+      if (typeof given === "string") {
+        if (typeof expected === "string") {
+          return expected === given;
+        } else {
+          return expected.matches(given);
+        }
+      } else {
+        if (typeof expected === "string") {
+          return given.matches(expected);
+        } else {
+          var expectedNs = expected;
+          var givenNs = given;
+          return expectedNs.matches(givenNs.name) || expectedNs.matches(givenNs.altName);
+        }
+      }
+    }
+    __name(isEventTypeSame, "isEventTypeSame");
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/events/MessageEvent.js
+var require_MessageEvent = __commonJS({
+  "node_modules/matrix-events-sdk/lib/events/MessageEvent.js"(exports) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    __name(_typeof, "_typeof");
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.MessageEvent = void 0;
+    var _ExtensibleEvent2 = require_ExtensibleEvent();
+    var _types = require_types();
+    var _InvalidEventError = require_InvalidEventError();
+    var _message_types = require_message_types();
+    var _events = require_events();
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        enumerableOnly && (symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        })), keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    __name(ownKeys, "ownKeys");
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = null != arguments[i] ? arguments[i] : {};
+        i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+      return target;
+    }
+    __name(_objectSpread, "_objectSpread");
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    __name(_defineProperties, "_defineProperties");
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    __name(_createClass, "_createClass");
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      Object.defineProperty(subClass, "prototype", { writable: false });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    __name(_inherits, "_inherits");
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      }, "_setPrototypeOf");
+      return _setPrototypeOf(o, p);
+    }
+    __name(_setPrototypeOf, "_setPrototypeOf");
+    function _createSuper(Derived) {
+      var hasNativeReflectConstruct = _isNativeReflectConstruct();
+      return /* @__PURE__ */ __name(function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+          var NewTarget = _getPrototypeOf(this).constructor;
+          result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+          result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+      }, "_createSuperInternal");
+    }
+    __name(_createSuper, "_createSuper");
+    function _possibleConstructorReturn(self, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      } else if (call !== void 0) {
+        throw new TypeError("Derived constructors may only return object or undefined");
+      }
+      return _assertThisInitialized(self);
+    }
+    __name(_possibleConstructorReturn, "_possibleConstructorReturn");
+    function _assertThisInitialized(self) {
+      if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self;
+    }
+    __name(_assertThisInitialized, "_assertThisInitialized");
+    function _isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+      if (Reflect.construct.sham) return false;
+      if (typeof Proxy === "function") return true;
+      try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    __name(_isNativeReflectConstruct, "_isNativeReflectConstruct");
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      }, "_getPrototypeOf");
+      return _getPrototypeOf(o);
+    }
+    __name(_getPrototypeOf, "_getPrototypeOf");
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(_defineProperty, "_defineProperty");
+    var MessageEvent = /* @__PURE__ */ (function(_ExtensibleEvent) {
+      _inherits(MessageEvent2, _ExtensibleEvent);
+      var _super = _createSuper(MessageEvent2);
+      function MessageEvent2(wireFormat) {
+        var _this;
+        _classCallCheck(this, MessageEvent2);
+        _this = _super.call(this, wireFormat);
+        _defineProperty(_assertThisInitialized(_this), "text", void 0);
+        _defineProperty(_assertThisInitialized(_this), "html", void 0);
+        _defineProperty(_assertThisInitialized(_this), "renderings", void 0);
+        var mmessage = _message_types.M_MESSAGE.findIn(_this.wireContent);
+        var mtext = _message_types.M_TEXT.findIn(_this.wireContent);
+        var mhtml = _message_types.M_HTML.findIn(_this.wireContent);
+        if ((0, _types.isProvided)(mmessage)) {
+          if (!Array.isArray(mmessage)) {
+            throw new _InvalidEventError.InvalidEventError("m.message contents must be an array");
+          }
+          var text = mmessage.find(function(r) {
+            return !(0, _types.isProvided)(r.mimetype) || r.mimetype === "text/plain";
+          });
+          var html = mmessage.find(function(r) {
+            return r.mimetype === "text/html";
+          });
+          if (!text) throw new _InvalidEventError.InvalidEventError("m.message is missing a plain text representation");
+          _this.text = text.body;
+          _this.html = html === null || html === void 0 ? void 0 : html.body;
+          _this.renderings = mmessage;
+        } else if ((0, _types.isOptionalAString)(mtext)) {
+          _this.text = mtext;
+          _this.html = mhtml;
+          _this.renderings = [{
+            body: mtext,
+            mimetype: "text/plain"
+          }];
+          if (_this.html) {
+            _this.renderings.push({
+              body: _this.html,
+              mimetype: "text/html"
+            });
+          }
+        } else {
+          throw new _InvalidEventError.InvalidEventError("Missing textual representation for event");
+        }
+        return _this;
+      }
+      __name(MessageEvent2, "MessageEvent");
+      _createClass(MessageEvent2, [{
+        key: "isEmote",
+        get: /* @__PURE__ */ __name(function get() {
+          return _message_types.M_EMOTE.matches(this.wireFormat.type) || (0, _types.isProvided)(_message_types.M_EMOTE.findIn(this.wireFormat.content));
+        }, "get")
+        /**
+         * Gets whether this message is considered a "notice". Note that a message
+         * might be an emote and notice at the same time: while technically possible,
+         * the event should be interpreted as one or the other.
+         */
+      }, {
+        key: "isNotice",
+        get: /* @__PURE__ */ __name(function get() {
+          return _message_types.M_NOTICE.matches(this.wireFormat.type) || (0, _types.isProvided)(_message_types.M_NOTICE.findIn(this.wireFormat.content));
+        }, "get")
+      }, {
+        key: "isEquivalentTo",
+        value: /* @__PURE__ */ __name(function isEquivalentTo(primaryEventType) {
+          return (0, _events.isEventTypeSame)(primaryEventType, _message_types.M_MESSAGE);
+        }, "isEquivalentTo")
+      }, {
+        key: "serializeMMessageOnly",
+        value: /* @__PURE__ */ __name(function serializeMMessageOnly() {
+          var messageRendering = _defineProperty({}, _message_types.M_MESSAGE.name, this.renderings);
+          if (this.renderings.length === 1) {
+            var mime = this.renderings[0].mimetype;
+            if (mime === void 0 || mime === "text/plain") {
+              messageRendering = _defineProperty({}, _message_types.M_TEXT.name, this.renderings[0].body);
+            }
+          }
+          return messageRendering;
+        }, "serializeMMessageOnly")
+      }, {
+        key: "serialize",
+        value: /* @__PURE__ */ __name(function serialize() {
+          var _this$html;
+          return {
+            type: "m.room.message",
+            content: _objectSpread(_objectSpread({}, this.serializeMMessageOnly()), {}, {
+              body: this.text,
+              msgtype: "m.text",
+              format: this.html ? "org.matrix.custom.html" : void 0,
+              formatted_body: (_this$html = this.html) !== null && _this$html !== void 0 ? _this$html : void 0
+            })
+          };
+        }, "serialize")
+        /**
+         * Creates a new MessageEvent from text and HTML.
+         * @param {string} text The text.
+         * @param {string} html Optional HTML.
+         * @returns {MessageEvent} The representative message event.
+         */
+      }], [{
+        key: "from",
+        value: /* @__PURE__ */ __name(function from(text, html) {
+          var _content;
+          return new MessageEvent2({
+            type: _message_types.M_MESSAGE.name,
+            content: (_content = {}, _defineProperty(_content, _message_types.M_TEXT.name, text), _defineProperty(_content, _message_types.M_HTML.name, html), _content)
+          });
+        }, "from")
+      }]);
+      return MessageEvent2;
+    })(_ExtensibleEvent2.ExtensibleEvent);
+    exports.MessageEvent = MessageEvent;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/events/NoticeEvent.js
+var require_NoticeEvent = __commonJS({
+  "node_modules/matrix-events-sdk/lib/events/NoticeEvent.js"(exports) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    __name(_typeof, "_typeof");
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.NoticeEvent = void 0;
+    var _MessageEvent2 = require_MessageEvent();
+    var _message_types = require_message_types();
+    var _events = require_events();
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(_defineProperty, "_defineProperty");
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    __name(_defineProperties, "_defineProperties");
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    __name(_createClass, "_createClass");
+    function _get() {
+      if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+      } else {
+        _get = /* @__PURE__ */ __name(function _get2(target, property, receiver) {
+          var base = _superPropBase(target, property);
+          if (!base) return;
+          var desc = Object.getOwnPropertyDescriptor(base, property);
+          if (desc.get) {
+            return desc.get.call(arguments.length < 3 ? target : receiver);
+          }
+          return desc.value;
+        }, "_get");
+      }
+      return _get.apply(this, arguments);
+    }
+    __name(_get, "_get");
+    function _superPropBase(object, property) {
+      while (!Object.prototype.hasOwnProperty.call(object, property)) {
+        object = _getPrototypeOf(object);
+        if (object === null) break;
+      }
+      return object;
+    }
+    __name(_superPropBase, "_superPropBase");
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      Object.defineProperty(subClass, "prototype", { writable: false });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    __name(_inherits, "_inherits");
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      }, "_setPrototypeOf");
+      return _setPrototypeOf(o, p);
+    }
+    __name(_setPrototypeOf, "_setPrototypeOf");
+    function _createSuper(Derived) {
+      var hasNativeReflectConstruct = _isNativeReflectConstruct();
+      return /* @__PURE__ */ __name(function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+          var NewTarget = _getPrototypeOf(this).constructor;
+          result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+          result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+      }, "_createSuperInternal");
+    }
+    __name(_createSuper, "_createSuper");
+    function _possibleConstructorReturn(self, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      } else if (call !== void 0) {
+        throw new TypeError("Derived constructors may only return object or undefined");
+      }
+      return _assertThisInitialized(self);
+    }
+    __name(_possibleConstructorReturn, "_possibleConstructorReturn");
+    function _assertThisInitialized(self) {
+      if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self;
+    }
+    __name(_assertThisInitialized, "_assertThisInitialized");
+    function _isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+      if (Reflect.construct.sham) return false;
+      if (typeof Proxy === "function") return true;
+      try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    __name(_isNativeReflectConstruct, "_isNativeReflectConstruct");
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      }, "_getPrototypeOf");
+      return _getPrototypeOf(o);
+    }
+    __name(_getPrototypeOf, "_getPrototypeOf");
+    var NoticeEvent = /* @__PURE__ */ (function(_MessageEvent) {
+      _inherits(NoticeEvent2, _MessageEvent);
+      var _super = _createSuper(NoticeEvent2);
+      function NoticeEvent2(wireFormat) {
+        _classCallCheck(this, NoticeEvent2);
+        return _super.call(this, wireFormat);
+      }
+      __name(NoticeEvent2, "NoticeEvent");
+      _createClass(NoticeEvent2, [{
+        key: "isNotice",
+        get: /* @__PURE__ */ __name(function get() {
+          return true;
+        }, "get")
+      }, {
+        key: "isEquivalentTo",
+        value: /* @__PURE__ */ __name(function isEquivalentTo(primaryEventType) {
+          return (0, _events.isEventTypeSame)(primaryEventType, _message_types.M_NOTICE) || _get(_getPrototypeOf(NoticeEvent2.prototype), "isEquivalentTo", this).call(this, primaryEventType);
+        }, "isEquivalentTo")
+      }, {
+        key: "serialize",
+        value: /* @__PURE__ */ __name(function serialize() {
+          var message = _get(_getPrototypeOf(NoticeEvent2.prototype), "serialize", this).call(this);
+          message.content["msgtype"] = "m.notice";
+          return message;
+        }, "serialize")
+        /**
+         * Creates a new NoticeEvent from text and HTML.
+         * @param {string} text The text.
+         * @param {string} html Optional HTML.
+         * @returns {MessageEvent} The representative message event.
+         */
+      }], [{
+        key: "from",
+        value: /* @__PURE__ */ __name(function from(text, html) {
+          var _content;
+          return new NoticeEvent2({
+            type: _message_types.M_NOTICE.name,
+            content: (_content = {}, _defineProperty(_content, _message_types.M_TEXT.name, text), _defineProperty(_content, _message_types.M_HTML.name, html), _content)
+          });
+        }, "from")
+      }]);
+      return NoticeEvent2;
+    })(_MessageEvent2.MessageEvent);
+    exports.NoticeEvent = NoticeEvent;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/events/EmoteEvent.js
+var require_EmoteEvent = __commonJS({
+  "node_modules/matrix-events-sdk/lib/events/EmoteEvent.js"(exports) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    __name(_typeof, "_typeof");
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.EmoteEvent = void 0;
+    var _MessageEvent2 = require_MessageEvent();
+    var _message_types = require_message_types();
+    var _events = require_events();
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(_defineProperty, "_defineProperty");
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    __name(_defineProperties, "_defineProperties");
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    __name(_createClass, "_createClass");
+    function _get() {
+      if (typeof Reflect !== "undefined" && Reflect.get) {
+        _get = Reflect.get;
+      } else {
+        _get = /* @__PURE__ */ __name(function _get2(target, property, receiver) {
+          var base = _superPropBase(target, property);
+          if (!base) return;
+          var desc = Object.getOwnPropertyDescriptor(base, property);
+          if (desc.get) {
+            return desc.get.call(arguments.length < 3 ? target : receiver);
+          }
+          return desc.value;
+        }, "_get");
+      }
+      return _get.apply(this, arguments);
+    }
+    __name(_get, "_get");
+    function _superPropBase(object, property) {
+      while (!Object.prototype.hasOwnProperty.call(object, property)) {
+        object = _getPrototypeOf(object);
+        if (object === null) break;
+      }
+      return object;
+    }
+    __name(_superPropBase, "_superPropBase");
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      Object.defineProperty(subClass, "prototype", { writable: false });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    __name(_inherits, "_inherits");
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      }, "_setPrototypeOf");
+      return _setPrototypeOf(o, p);
+    }
+    __name(_setPrototypeOf, "_setPrototypeOf");
+    function _createSuper(Derived) {
+      var hasNativeReflectConstruct = _isNativeReflectConstruct();
+      return /* @__PURE__ */ __name(function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+          var NewTarget = _getPrototypeOf(this).constructor;
+          result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+          result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+      }, "_createSuperInternal");
+    }
+    __name(_createSuper, "_createSuper");
+    function _possibleConstructorReturn(self, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      } else if (call !== void 0) {
+        throw new TypeError("Derived constructors may only return object or undefined");
+      }
+      return _assertThisInitialized(self);
+    }
+    __name(_possibleConstructorReturn, "_possibleConstructorReturn");
+    function _assertThisInitialized(self) {
+      if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self;
+    }
+    __name(_assertThisInitialized, "_assertThisInitialized");
+    function _isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+      if (Reflect.construct.sham) return false;
+      if (typeof Proxy === "function") return true;
+      try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    __name(_isNativeReflectConstruct, "_isNativeReflectConstruct");
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      }, "_getPrototypeOf");
+      return _getPrototypeOf(o);
+    }
+    __name(_getPrototypeOf, "_getPrototypeOf");
+    var EmoteEvent = /* @__PURE__ */ (function(_MessageEvent) {
+      _inherits(EmoteEvent2, _MessageEvent);
+      var _super = _createSuper(EmoteEvent2);
+      function EmoteEvent2(wireFormat) {
+        _classCallCheck(this, EmoteEvent2);
+        return _super.call(this, wireFormat);
+      }
+      __name(EmoteEvent2, "EmoteEvent");
+      _createClass(EmoteEvent2, [{
+        key: "isEmote",
+        get: /* @__PURE__ */ __name(function get() {
+          return true;
+        }, "get")
+      }, {
+        key: "isEquivalentTo",
+        value: /* @__PURE__ */ __name(function isEquivalentTo(primaryEventType) {
+          return (0, _events.isEventTypeSame)(primaryEventType, _message_types.M_EMOTE) || _get(_getPrototypeOf(EmoteEvent2.prototype), "isEquivalentTo", this).call(this, primaryEventType);
+        }, "isEquivalentTo")
+      }, {
+        key: "serialize",
+        value: /* @__PURE__ */ __name(function serialize() {
+          var message = _get(_getPrototypeOf(EmoteEvent2.prototype), "serialize", this).call(this);
+          message.content["msgtype"] = "m.emote";
+          return message;
+        }, "serialize")
+        /**
+         * Creates a new EmoteEvent from text and HTML.
+         * @param {string} text The text.
+         * @param {string} html Optional HTML.
+         * @returns {MessageEvent} The representative message event.
+         */
+      }], [{
+        key: "from",
+        value: /* @__PURE__ */ __name(function from(text, html) {
+          var _content;
+          return new EmoteEvent2({
+            type: _message_types.M_EMOTE.name,
+            content: (_content = {}, _defineProperty(_content, _message_types.M_TEXT.name, text), _defineProperty(_content, _message_types.M_HTML.name, html), _content)
+          });
+        }, "from")
+      }]);
+      return EmoteEvent2;
+    })(_MessageEvent2.MessageEvent);
+    exports.EmoteEvent = EmoteEvent;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/interpreters/legacy/MRoomMessage.js
+var require_MRoomMessage = __commonJS({
+  "node_modules/matrix-events-sdk/lib/interpreters/legacy/MRoomMessage.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.LEGACY_M_ROOM_MESSAGE = void 0;
+    exports.parseMRoomMessage = parseMRoomMessage;
+    var _MessageEvent = require_MessageEvent();
+    var _NoticeEvent = require_NoticeEvent();
+    var _EmoteEvent = require_EmoteEvent();
+    var _NamespacedValue = require_NamespacedValue();
+    var _message_types = require_message_types();
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        enumerableOnly && (symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        })), keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    __name(ownKeys, "ownKeys");
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = null != arguments[i] ? arguments[i] : {};
+        i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+      return target;
+    }
+    __name(_objectSpread, "_objectSpread");
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(_defineProperty, "_defineProperty");
+    var LEGACY_M_ROOM_MESSAGE = new _NamespacedValue.NamespacedValue("m.room.message");
+    exports.LEGACY_M_ROOM_MESSAGE = LEGACY_M_ROOM_MESSAGE;
+    function parseMRoomMessage(wireEvent) {
+      var _wireEvent$content, _wireEvent$content2, _wireEvent$content3;
+      if (_message_types.M_MESSAGE.findIn(wireEvent.content) || _message_types.M_TEXT.findIn(wireEvent.content)) {
+        return new _MessageEvent.MessageEvent(wireEvent);
+      }
+      var msgtype = (_wireEvent$content = wireEvent.content) === null || _wireEvent$content === void 0 ? void 0 : _wireEvent$content.msgtype;
+      var text = (_wireEvent$content2 = wireEvent.content) === null || _wireEvent$content2 === void 0 ? void 0 : _wireEvent$content2.body;
+      var html = ((_wireEvent$content3 = wireEvent.content) === null || _wireEvent$content3 === void 0 ? void 0 : _wireEvent$content3.format) === "org.matrix.custom.html" ? wireEvent.content.formatted_body : null;
+      if (msgtype === "m.text") {
+        var _objectSpread2;
+        return new _MessageEvent.MessageEvent(_objectSpread(_objectSpread({}, wireEvent), {}, {
+          content: _objectSpread(_objectSpread({}, wireEvent.content), {}, (_objectSpread2 = {}, _defineProperty(_objectSpread2, _message_types.M_TEXT.name, text), _defineProperty(_objectSpread2, _message_types.M_HTML.name, html), _objectSpread2))
+        }));
+      } else if (msgtype === "m.notice") {
+        var _objectSpread3;
+        return new _NoticeEvent.NoticeEvent(_objectSpread(_objectSpread({}, wireEvent), {}, {
+          content: _objectSpread(_objectSpread({}, wireEvent.content), {}, (_objectSpread3 = {}, _defineProperty(_objectSpread3, _message_types.M_TEXT.name, text), _defineProperty(_objectSpread3, _message_types.M_HTML.name, html), _objectSpread3))
+        }));
+      } else if (msgtype === "m.emote") {
+        var _objectSpread4;
+        return new _EmoteEvent.EmoteEvent(_objectSpread(_objectSpread({}, wireEvent), {}, {
+          content: _objectSpread(_objectSpread({}, wireEvent.content), {}, (_objectSpread4 = {}, _defineProperty(_objectSpread4, _message_types.M_TEXT.name, text), _defineProperty(_objectSpread4, _message_types.M_HTML.name, html), _objectSpread4))
+        }));
+      } else {
+        return null;
+      }
+    }
+    __name(parseMRoomMessage, "parseMRoomMessage");
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/interpreters/modern/MMessage.js
+var require_MMessage = __commonJS({
+  "node_modules/matrix-events-sdk/lib/interpreters/modern/MMessage.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.parseMMessage = parseMMessage;
+    var _MessageEvent = require_MessageEvent();
+    var _message_types = require_message_types();
+    var _EmoteEvent = require_EmoteEvent();
+    var _NoticeEvent = require_NoticeEvent();
+    function parseMMessage(wireEvent) {
+      if (_message_types.M_EMOTE.matches(wireEvent.type)) {
+        return new _EmoteEvent.EmoteEvent(wireEvent);
+      } else if (_message_types.M_NOTICE.matches(wireEvent.type)) {
+        return new _NoticeEvent.NoticeEvent(wireEvent);
+      }
+      return new _MessageEvent.MessageEvent(wireEvent);
+    }
+    __name(parseMMessage, "parseMMessage");
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/events/poll_types.js
+var require_poll_types = __commonJS({
+  "node_modules/matrix-events-sdk/lib/events/poll_types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.M_POLL_START = exports.M_POLL_RESPONSE = exports.M_POLL_KIND_UNDISCLOSED = exports.M_POLL_KIND_DISCLOSED = exports.M_POLL_END = void 0;
+    var _NamespacedValue = require_NamespacedValue();
+    var M_POLL_KIND_DISCLOSED2 = new _NamespacedValue.UnstableValue("m.poll.disclosed", "org.matrix.msc3381.poll.disclosed");
+    exports.M_POLL_KIND_DISCLOSED = M_POLL_KIND_DISCLOSED2;
+    var M_POLL_KIND_UNDISCLOSED2 = new _NamespacedValue.UnstableValue("m.poll.undisclosed", "org.matrix.msc3381.poll.undisclosed");
+    exports.M_POLL_KIND_UNDISCLOSED = M_POLL_KIND_UNDISCLOSED2;
+    var M_POLL_START2 = new _NamespacedValue.UnstableValue("m.poll.start", "org.matrix.msc3381.poll.start");
+    exports.M_POLL_START = M_POLL_START2;
+    var M_POLL_RESPONSE2 = new _NamespacedValue.UnstableValue("m.poll.response", "org.matrix.msc3381.poll.response");
+    exports.M_POLL_RESPONSE = M_POLL_RESPONSE2;
+    var M_POLL_END2 = new _NamespacedValue.UnstableValue("m.poll.end", "org.matrix.msc3381.poll.end");
+    exports.M_POLL_END = M_POLL_END2;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/events/PollStartEvent.js
+var require_PollStartEvent = __commonJS({
+  "node_modules/matrix-events-sdk/lib/events/PollStartEvent.js"(exports) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    __name(_typeof, "_typeof");
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.PollStartEvent = exports.PollAnswerSubevent = void 0;
+    var _poll_types = require_poll_types();
+    var _MessageEvent2 = require_MessageEvent();
+    var _message_types = require_message_types();
+    var _InvalidEventError = require_InvalidEventError();
+    var _NamespacedValue = require_NamespacedValue();
+    var _events = require_events();
+    var _ExtensibleEvent2 = require_ExtensibleEvent();
+    function _toConsumableArray(arr) {
+      return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+    }
+    __name(_toConsumableArray, "_toConsumableArray");
+    function _nonIterableSpread() {
+      throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    __name(_nonIterableSpread, "_nonIterableSpread");
+    function _unsupportedIterableToArray(o, minLen) {
+      if (!o) return;
+      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+      var n = Object.prototype.toString.call(o).slice(8, -1);
+      if (n === "Object" && o.constructor) n = o.constructor.name;
+      if (n === "Map" || n === "Set") return Array.from(o);
+      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+    }
+    __name(_unsupportedIterableToArray, "_unsupportedIterableToArray");
+    function _iterableToArray(iter) {
+      if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+    }
+    __name(_iterableToArray, "_iterableToArray");
+    function _arrayWithoutHoles(arr) {
+      if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+    }
+    __name(_arrayWithoutHoles, "_arrayWithoutHoles");
+    function _arrayLikeToArray(arr, len) {
+      if (len == null || len > arr.length) len = arr.length;
+      for (var i = 0, arr2 = new Array(len); i < len; i++) {
+        arr2[i] = arr[i];
+      }
+      return arr2;
+    }
+    __name(_arrayLikeToArray, "_arrayLikeToArray");
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        enumerableOnly && (symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        })), keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    __name(ownKeys, "ownKeys");
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = null != arguments[i] ? arguments[i] : {};
+        i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+      return target;
+    }
+    __name(_objectSpread, "_objectSpread");
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    __name(_defineProperties, "_defineProperties");
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    __name(_createClass, "_createClass");
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      Object.defineProperty(subClass, "prototype", { writable: false });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    __name(_inherits, "_inherits");
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      }, "_setPrototypeOf");
+      return _setPrototypeOf(o, p);
+    }
+    __name(_setPrototypeOf, "_setPrototypeOf");
+    function _createSuper(Derived) {
+      var hasNativeReflectConstruct = _isNativeReflectConstruct();
+      return /* @__PURE__ */ __name(function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+          var NewTarget = _getPrototypeOf(this).constructor;
+          result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+          result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+      }, "_createSuperInternal");
+    }
+    __name(_createSuper, "_createSuper");
+    function _possibleConstructorReturn(self, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      } else if (call !== void 0) {
+        throw new TypeError("Derived constructors may only return object or undefined");
+      }
+      return _assertThisInitialized(self);
+    }
+    __name(_possibleConstructorReturn, "_possibleConstructorReturn");
+    function _assertThisInitialized(self) {
+      if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self;
+    }
+    __name(_assertThisInitialized, "_assertThisInitialized");
+    function _isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+      if (Reflect.construct.sham) return false;
+      if (typeof Proxy === "function") return true;
+      try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    __name(_isNativeReflectConstruct, "_isNativeReflectConstruct");
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      }, "_getPrototypeOf");
+      return _getPrototypeOf(o);
+    }
+    __name(_getPrototypeOf, "_getPrototypeOf");
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(_defineProperty, "_defineProperty");
+    var PollAnswerSubevent = /* @__PURE__ */ (function(_MessageEvent) {
+      _inherits(PollAnswerSubevent2, _MessageEvent);
+      var _super = _createSuper(PollAnswerSubevent2);
+      function PollAnswerSubevent2(wireFormat) {
+        var _this;
+        _classCallCheck(this, PollAnswerSubevent2);
+        _this = _super.call(this, wireFormat);
+        _defineProperty(_assertThisInitialized(_this), "id", void 0);
+        var id = wireFormat.content.id;
+        if (!id || typeof id !== "string") {
+          throw new _InvalidEventError.InvalidEventError("Answer ID must be a non-empty string");
+        }
+        _this.id = id;
+        return _this;
+      }
+      __name(PollAnswerSubevent2, "PollAnswerSubevent");
+      _createClass(PollAnswerSubevent2, [{
+        key: "serialize",
+        value: /* @__PURE__ */ __name(function serialize() {
+          return {
+            type: "org.matrix.sdk.poll.answer",
+            content: _objectSpread({
+              id: this.id
+            }, this.serializeMMessageOnly())
+          };
+        }, "serialize")
+        /**
+         * Creates a new PollAnswerSubevent from ID and text.
+         * @param {string} id The answer ID (unique within the poll).
+         * @param {string} text The text.
+         * @returns {PollAnswerSubevent} The representative answer.
+         */
+      }], [{
+        key: "from",
+        value: /* @__PURE__ */ __name(function from(id, text) {
+          return new PollAnswerSubevent2({
+            type: "org.matrix.sdk.poll.answer",
+            content: _defineProperty({
+              id
+            }, _message_types.M_TEXT.name, text)
+          });
+        }, "from")
+      }]);
+      return PollAnswerSubevent2;
+    })(_MessageEvent2.MessageEvent);
+    exports.PollAnswerSubevent = PollAnswerSubevent;
+    var PollStartEvent = /* @__PURE__ */ (function(_ExtensibleEvent) {
+      _inherits(PollStartEvent2, _ExtensibleEvent);
+      var _super2 = _createSuper(PollStartEvent2);
+      function PollStartEvent2(wireFormat) {
+        var _this2;
+        _classCallCheck(this, PollStartEvent2);
+        _this2 = _super2.call(this, wireFormat);
+        _defineProperty(_assertThisInitialized(_this2), "question", void 0);
+        _defineProperty(_assertThisInitialized(_this2), "kind", void 0);
+        _defineProperty(_assertThisInitialized(_this2), "rawKind", void 0);
+        _defineProperty(_assertThisInitialized(_this2), "maxSelections", void 0);
+        _defineProperty(_assertThisInitialized(_this2), "answers", void 0);
+        var poll = _poll_types.M_POLL_START.findIn(_this2.wireContent);
+        if (!poll.question) {
+          throw new _InvalidEventError.InvalidEventError("A question is required");
+        }
+        _this2.question = new _MessageEvent2.MessageEvent({
+          type: "org.matrix.sdk.poll.question",
+          content: poll.question
+        });
+        _this2.rawKind = poll.kind;
+        if (_poll_types.M_POLL_KIND_DISCLOSED.matches(_this2.rawKind)) {
+          _this2.kind = _poll_types.M_POLL_KIND_DISCLOSED;
+        } else {
+          _this2.kind = _poll_types.M_POLL_KIND_UNDISCLOSED;
+        }
+        _this2.maxSelections = Number.isFinite(poll.max_selections) && poll.max_selections > 0 ? poll.max_selections : 1;
+        if (!Array.isArray(poll.answers)) {
+          throw new _InvalidEventError.InvalidEventError("Poll answers must be an array");
+        }
+        var answers = poll.answers.slice(0, 20).map(function(a) {
+          return new PollAnswerSubevent({
+            type: "org.matrix.sdk.poll.answer",
+            content: a
+          });
+        });
+        if (answers.length <= 0) {
+          throw new _InvalidEventError.InvalidEventError("No answers available");
+        }
+        _this2.answers = answers;
+        return _this2;
+      }
+      __name(PollStartEvent2, "PollStartEvent");
+      _createClass(PollStartEvent2, [{
+        key: "isEquivalentTo",
+        value: /* @__PURE__ */ __name(function isEquivalentTo(primaryEventType) {
+          return (0, _events.isEventTypeSame)(primaryEventType, _poll_types.M_POLL_START);
+        }, "isEquivalentTo")
+      }, {
+        key: "serialize",
+        value: /* @__PURE__ */ __name(function serialize() {
+          var _content2;
+          return {
+            type: _poll_types.M_POLL_START.name,
+            content: (_content2 = {}, _defineProperty(_content2, _poll_types.M_POLL_START.name, {
+              question: this.question.serialize().content,
+              kind: this.rawKind,
+              max_selections: this.maxSelections,
+              answers: this.answers.map(function(a) {
+                return a.serialize().content;
+              })
+            }), _defineProperty(_content2, _message_types.M_TEXT.name, "".concat(this.question.text, "\n").concat(this.answers.map(function(a, i) {
+              return "".concat(i + 1, ". ").concat(a.text);
+            }).join("\n"))), _content2)
+          };
+        }, "serialize")
+        /**
+         * Creates a new PollStartEvent from question, answers, and metadata.
+         * @param {string} question The question to ask.
+         * @param {string} answers The answers. Should be unique within each other.
+         * @param {KNOWN_POLL_KIND|string} kind The kind of poll.
+         * @param {number} maxSelections The maximum number of selections. Must be 1 or higher.
+         * @returns {PollStartEvent} The representative poll start event.
+         */
+      }], [{
+        key: "from",
+        value: /* @__PURE__ */ __name(function from(question, answers, kind) {
+          var _content3;
+          var maxSelections = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 1;
+          return new PollStartEvent2({
+            type: _poll_types.M_POLL_START.name,
+            content: (_content3 = {}, _defineProperty(_content3, _message_types.M_TEXT.name, question), _defineProperty(_content3, _poll_types.M_POLL_START.name, {
+              question: _defineProperty({}, _message_types.M_TEXT.name, question),
+              kind: kind instanceof _NamespacedValue.NamespacedValue ? kind.name : kind,
+              max_selections: maxSelections,
+              answers: answers.map(function(a) {
+                return _defineProperty({
+                  id: makeId()
+                }, _message_types.M_TEXT.name, a);
+              })
+            }), _content3)
+          });
+        }, "from")
+      }]);
+      return PollStartEvent2;
+    })(_ExtensibleEvent2.ExtensibleEvent);
+    exports.PollStartEvent = PollStartEvent;
+    var LETTERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    function makeId() {
+      return _toConsumableArray(Array(16)).map(function() {
+        return LETTERS.charAt(Math.floor(Math.random() * LETTERS.length));
+      }).join("");
+    }
+    __name(makeId, "makeId");
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/events/relationship_types.js
+var require_relationship_types = __commonJS({
+  "node_modules/matrix-events-sdk/lib/events/relationship_types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.REFERENCE_RELATION = void 0;
+    var _NamespacedValue = require_NamespacedValue();
+    var REFERENCE_RELATION = new _NamespacedValue.NamespacedValue("m.reference");
+    exports.REFERENCE_RELATION = REFERENCE_RELATION;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/events/PollResponseEvent.js
+var require_PollResponseEvent = __commonJS({
+  "node_modules/matrix-events-sdk/lib/events/PollResponseEvent.js"(exports) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    __name(_typeof, "_typeof");
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.PollResponseEvent = void 0;
+    var _ExtensibleEvent2 = require_ExtensibleEvent();
+    var _poll_types = require_poll_types();
+    var _InvalidEventError = require_InvalidEventError();
+    var _relationship_types = require_relationship_types();
+    var _events = require_events();
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    __name(_defineProperties, "_defineProperties");
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    __name(_createClass, "_createClass");
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      Object.defineProperty(subClass, "prototype", { writable: false });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    __name(_inherits, "_inherits");
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      }, "_setPrototypeOf");
+      return _setPrototypeOf(o, p);
+    }
+    __name(_setPrototypeOf, "_setPrototypeOf");
+    function _createSuper(Derived) {
+      var hasNativeReflectConstruct = _isNativeReflectConstruct();
+      return /* @__PURE__ */ __name(function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+          var NewTarget = _getPrototypeOf(this).constructor;
+          result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+          result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+      }, "_createSuperInternal");
+    }
+    __name(_createSuper, "_createSuper");
+    function _possibleConstructorReturn(self, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      } else if (call !== void 0) {
+        throw new TypeError("Derived constructors may only return object or undefined");
+      }
+      return _assertThisInitialized(self);
+    }
+    __name(_possibleConstructorReturn, "_possibleConstructorReturn");
+    function _assertThisInitialized(self) {
+      if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self;
+    }
+    __name(_assertThisInitialized, "_assertThisInitialized");
+    function _isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+      if (Reflect.construct.sham) return false;
+      if (typeof Proxy === "function") return true;
+      try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    __name(_isNativeReflectConstruct, "_isNativeReflectConstruct");
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      }, "_getPrototypeOf");
+      return _getPrototypeOf(o);
+    }
+    __name(_getPrototypeOf, "_getPrototypeOf");
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(_defineProperty, "_defineProperty");
+    var PollResponseEvent = /* @__PURE__ */ (function(_ExtensibleEvent) {
+      _inherits(PollResponseEvent2, _ExtensibleEvent);
+      var _super = _createSuper(PollResponseEvent2);
+      function PollResponseEvent2(wireFormat) {
+        var _this;
+        _classCallCheck(this, PollResponseEvent2);
+        _this = _super.call(this, wireFormat);
+        _defineProperty(_assertThisInitialized(_this), "internalAnswerIds", void 0);
+        _defineProperty(_assertThisInitialized(_this), "internalSpoiled", void 0);
+        _defineProperty(_assertThisInitialized(_this), "pollEventId", void 0);
+        var rel = _this.wireContent["m.relates_to"];
+        if (!_relationship_types.REFERENCE_RELATION.matches(rel === null || rel === void 0 ? void 0 : rel.rel_type) || typeof (rel === null || rel === void 0 ? void 0 : rel.event_id) !== "string") {
+          throw new _InvalidEventError.InvalidEventError("Relationship must be a reference to an event");
+        }
+        _this.pollEventId = rel.event_id;
+        _this.validateAgainst(null);
+        return _this;
+      }
+      __name(PollResponseEvent2, "PollResponseEvent");
+      _createClass(PollResponseEvent2, [{
+        key: "answerIds",
+        get: (
+          /**
+           * The provided answers for the poll. Note that this may be falsy/unpredictable if
+           * the `spoiled` property is true.
+           */
+          /* @__PURE__ */ __name(function get() {
+            return this.internalAnswerIds;
+          }, "get")
+        )
+        /**
+         * The poll start event ID referenced by the response.
+         */
+      }, {
+        key: "spoiled",
+        get: (
+          /**
+           * Whether the vote is spoiled.
+           */
+          /* @__PURE__ */ __name(function get() {
+            return this.internalSpoiled;
+          }, "get")
+        )
+      }, {
+        key: "validateAgainst",
+        value: /* @__PURE__ */ __name(function validateAgainst(poll) {
+          var response = _poll_types.M_POLL_RESPONSE.findIn(this.wireContent);
+          if (!Array.isArray(response === null || response === void 0 ? void 0 : response.answers)) {
+            this.internalSpoiled = true;
+            this.internalAnswerIds = [];
+            return;
+          }
+          var answers = response.answers;
+          if (answers.some(function(a) {
+            return typeof a !== "string";
+          }) || answers.length === 0) {
+            this.internalSpoiled = true;
+            this.internalAnswerIds = [];
+            return;
+          }
+          if (poll) {
+            if (answers.some(function(a) {
+              return !poll.answers.some(function(pa) {
+                return pa.id === a;
+              });
+            })) {
+              this.internalSpoiled = true;
+              this.internalAnswerIds = [];
+              return;
+            }
+            answers = answers.slice(0, poll.maxSelections);
+          }
+          this.internalAnswerIds = answers;
+          this.internalSpoiled = false;
+        }, "validateAgainst")
+      }, {
+        key: "isEquivalentTo",
+        value: /* @__PURE__ */ __name(function isEquivalentTo(primaryEventType) {
+          return (0, _events.isEventTypeSame)(primaryEventType, _poll_types.M_POLL_RESPONSE);
+        }, "isEquivalentTo")
+      }, {
+        key: "serialize",
+        value: /* @__PURE__ */ __name(function serialize() {
+          return {
+            type: _poll_types.M_POLL_RESPONSE.name,
+            content: _defineProperty({
+              "m.relates_to": {
+                rel_type: _relationship_types.REFERENCE_RELATION.name,
+                event_id: this.pollEventId
+              }
+            }, _poll_types.M_POLL_RESPONSE.name, {
+              answers: this.spoiled ? void 0 : this.answerIds
+            })
+          };
+        }, "serialize")
+        /**
+         * Creates a new PollResponseEvent from a set of answers. To spoil the vote, pass an empty
+         * answers array.
+         * @param {string} answers The user's answers. Should be valid from a poll's answer IDs.
+         * @param {string} pollEventId The poll start event ID.
+         * @returns {PollStartEvent} The representative poll response event.
+         */
+      }], [{
+        key: "from",
+        value: /* @__PURE__ */ __name(function from(answers, pollEventId) {
+          return new PollResponseEvent2({
+            type: _poll_types.M_POLL_RESPONSE.name,
+            content: _defineProperty({
+              "m.relates_to": {
+                rel_type: _relationship_types.REFERENCE_RELATION.name,
+                event_id: pollEventId
+              }
+            }, _poll_types.M_POLL_RESPONSE.name, {
+              answers
+            })
+          });
+        }, "from")
+      }]);
+      return PollResponseEvent2;
+    })(_ExtensibleEvent2.ExtensibleEvent);
+    exports.PollResponseEvent = PollResponseEvent;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/events/PollEndEvent.js
+var require_PollEndEvent = __commonJS({
+  "node_modules/matrix-events-sdk/lib/events/PollEndEvent.js"(exports) {
+    "use strict";
+    function _typeof(obj) {
+      "@babel/helpers - typeof";
+      return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+        return typeof obj2;
+      } : function(obj2) {
+        return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    __name(_typeof, "_typeof");
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.PollEndEvent = void 0;
+    var _poll_types = require_poll_types();
+    var _InvalidEventError = require_InvalidEventError();
+    var _relationship_types = require_relationship_types();
+    var _MessageEvent = require_MessageEvent();
+    var _message_types = require_message_types();
+    var _events = require_events();
+    var _ExtensibleEvent2 = require_ExtensibleEvent();
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        enumerableOnly && (symbols = symbols.filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        })), keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    __name(ownKeys, "ownKeys");
+    function _objectSpread(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = null != arguments[i] ? arguments[i] : {};
+        i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+      }
+      return target;
+    }
+    __name(_objectSpread, "_objectSpread");
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    __name(_defineProperties, "_defineProperties");
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    __name(_createClass, "_createClass");
+    function _inherits(subClass, superClass) {
+      if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+      }
+      subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+      Object.defineProperty(subClass, "prototype", { writable: false });
+      if (superClass) _setPrototypeOf(subClass, superClass);
+    }
+    __name(_inherits, "_inherits");
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf || /* @__PURE__ */ __name(function _setPrototypeOf2(o2, p2) {
+        o2.__proto__ = p2;
+        return o2;
+      }, "_setPrototypeOf");
+      return _setPrototypeOf(o, p);
+    }
+    __name(_setPrototypeOf, "_setPrototypeOf");
+    function _createSuper(Derived) {
+      var hasNativeReflectConstruct = _isNativeReflectConstruct();
+      return /* @__PURE__ */ __name(function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+          var NewTarget = _getPrototypeOf(this).constructor;
+          result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+          result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+      }, "_createSuperInternal");
+    }
+    __name(_createSuper, "_createSuper");
+    function _possibleConstructorReturn(self, call) {
+      if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+      } else if (call !== void 0) {
+        throw new TypeError("Derived constructors may only return object or undefined");
+      }
+      return _assertThisInitialized(self);
+    }
+    __name(_possibleConstructorReturn, "_possibleConstructorReturn");
+    function _assertThisInitialized(self) {
+      if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      }
+      return self;
+    }
+    __name(_assertThisInitialized, "_assertThisInitialized");
+    function _isNativeReflectConstruct() {
+      if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+      if (Reflect.construct.sham) return false;
+      if (typeof Proxy === "function") return true;
+      try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+        }));
+        return true;
+      } catch (e) {
+        return false;
+      }
+    }
+    __name(_isNativeReflectConstruct, "_isNativeReflectConstruct");
+    function _getPrototypeOf(o) {
+      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : /* @__PURE__ */ __name(function _getPrototypeOf2(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      }, "_getPrototypeOf");
+      return _getPrototypeOf(o);
+    }
+    __name(_getPrototypeOf, "_getPrototypeOf");
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(_defineProperty, "_defineProperty");
+    var PollEndEvent = /* @__PURE__ */ (function(_ExtensibleEvent) {
+      _inherits(PollEndEvent2, _ExtensibleEvent);
+      var _super = _createSuper(PollEndEvent2);
+      function PollEndEvent2(wireFormat) {
+        var _this;
+        _classCallCheck(this, PollEndEvent2);
+        _this = _super.call(this, wireFormat);
+        _defineProperty(_assertThisInitialized(_this), "pollEventId", void 0);
+        _defineProperty(_assertThisInitialized(_this), "closingMessage", void 0);
+        var rel = _this.wireContent["m.relates_to"];
+        if (!_relationship_types.REFERENCE_RELATION.matches(rel === null || rel === void 0 ? void 0 : rel.rel_type) || typeof (rel === null || rel === void 0 ? void 0 : rel.event_id) !== "string") {
+          throw new _InvalidEventError.InvalidEventError("Relationship must be a reference to an event");
+        }
+        _this.pollEventId = rel.event_id;
+        _this.closingMessage = new _MessageEvent.MessageEvent(_this.wireFormat);
+        return _this;
+      }
+      __name(PollEndEvent2, "PollEndEvent");
+      _createClass(PollEndEvent2, [{
+        key: "isEquivalentTo",
+        value: /* @__PURE__ */ __name(function isEquivalentTo(primaryEventType) {
+          return (0, _events.isEventTypeSame)(primaryEventType, _poll_types.M_POLL_END);
+        }, "isEquivalentTo")
+      }, {
+        key: "serialize",
+        value: /* @__PURE__ */ __name(function serialize() {
+          return {
+            type: _poll_types.M_POLL_END.name,
+            content: _objectSpread(_defineProperty({
+              "m.relates_to": {
+                rel_type: _relationship_types.REFERENCE_RELATION.name,
+                event_id: this.pollEventId
+              }
+            }, _poll_types.M_POLL_END.name, {}), this.closingMessage.serialize().content)
+          };
+        }, "serialize")
+        /**
+         * Creates a new PollEndEvent from a poll event ID.
+         * @param {string} pollEventId The poll start event ID.
+         * @param {string} message A closing message, typically revealing the top answer.
+         * @returns {PollStartEvent} The representative poll closure event.
+         */
+      }], [{
+        key: "from",
+        value: /* @__PURE__ */ __name(function from(pollEventId, message) {
+          var _content;
+          return new PollEndEvent2({
+            type: _poll_types.M_POLL_END.name,
+            content: (_content = {
+              "m.relates_to": {
+                rel_type: _relationship_types.REFERENCE_RELATION.name,
+                event_id: pollEventId
+              }
+            }, _defineProperty(_content, _poll_types.M_POLL_END.name, {}), _defineProperty(_content, _message_types.M_TEXT.name, message), _content)
+          });
+        }, "from")
+      }]);
+      return PollEndEvent2;
+    })(_ExtensibleEvent2.ExtensibleEvent);
+    exports.PollEndEvent = PollEndEvent;
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/interpreters/modern/MPoll.js
+var require_MPoll = __commonJS({
+  "node_modules/matrix-events-sdk/lib/interpreters/modern/MPoll.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.parseMPoll = parseMPoll;
+    var _poll_types = require_poll_types();
+    var _PollStartEvent = require_PollStartEvent();
+    var _PollResponseEvent = require_PollResponseEvent();
+    var _PollEndEvent = require_PollEndEvent();
+    function parseMPoll(wireEvent) {
+      if (_poll_types.M_POLL_START.matches(wireEvent.type)) {
+        return new _PollStartEvent.PollStartEvent(wireEvent);
+      } else if (_poll_types.M_POLL_RESPONSE.matches(wireEvent.type)) {
+        return new _PollResponseEvent.PollResponseEvent(wireEvent);
+      } else if (_poll_types.M_POLL_END.matches(wireEvent.type)) {
+        return new _PollEndEvent.PollEndEvent(wireEvent);
+      }
+      return null;
+    }
+    __name(parseMPoll, "parseMPoll");
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/ExtensibleEvents.js
+var require_ExtensibleEvents = __commonJS({
+  "node_modules/matrix-events-sdk/lib/ExtensibleEvents.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.ExtensibleEvents = void 0;
+    var _NamespacedMap = require_NamespacedMap();
+    var _InvalidEventError = require_InvalidEventError();
+    var _MRoomMessage = require_MRoomMessage();
+    var _MMessage = require_MMessage();
+    var _message_types = require_message_types();
+    var _poll_types = require_poll_types();
+    var _MPoll = require_MPoll();
+    function _createForOfIteratorHelper(o, allowArrayLike) {
+      var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+      if (!it) {
+        if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+          if (it) o = it;
+          var i = 0;
+          var F = /* @__PURE__ */ __name(function F2() {
+          }, "F");
+          return { s: F, n: /* @__PURE__ */ __name(function n() {
+            if (i >= o.length) return { done: true };
+            return { done: false, value: o[i++] };
+          }, "n"), e: /* @__PURE__ */ __name(function e(_e) {
+            throw _e;
+          }, "e"), f: F };
+        }
+        throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+      }
+      var normalCompletion = true, didErr = false, err;
+      return { s: /* @__PURE__ */ __name(function s() {
+        it = it.call(o);
+      }, "s"), n: /* @__PURE__ */ __name(function n() {
+        var step = it.next();
+        normalCompletion = step.done;
+        return step;
+      }, "n"), e: /* @__PURE__ */ __name(function e(_e2) {
+        didErr = true;
+        err = _e2;
+      }, "e"), f: /* @__PURE__ */ __name(function f() {
+        try {
+          if (!normalCompletion && it["return"] != null) it["return"]();
+        } finally {
+          if (didErr) throw err;
+        }
+      }, "f") };
+    }
+    __name(_createForOfIteratorHelper, "_createForOfIteratorHelper");
+    function _unsupportedIterableToArray(o, minLen) {
+      if (!o) return;
+      if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+      var n = Object.prototype.toString.call(o).slice(8, -1);
+      if (n === "Object" && o.constructor) n = o.constructor.name;
+      if (n === "Map" || n === "Set") return Array.from(o);
+      if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+    }
+    __name(_unsupportedIterableToArray, "_unsupportedIterableToArray");
+    function _arrayLikeToArray(arr, len) {
+      if (len == null || len > arr.length) len = arr.length;
+      for (var i = 0, arr2 = new Array(len); i < len; i++) {
+        arr2[i] = arr[i];
+      }
+      return arr2;
+    }
+    __name(_arrayLikeToArray, "_arrayLikeToArray");
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    __name(_classCallCheck, "_classCallCheck");
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    __name(_defineProperties, "_defineProperties");
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", { writable: false });
+      return Constructor;
+    }
+    __name(_createClass, "_createClass");
+    function _defineProperty(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    __name(_defineProperty, "_defineProperty");
+    var ExtensibleEvents = /* @__PURE__ */ (function() {
+      function ExtensibleEvents2() {
+        _classCallCheck(this, ExtensibleEvents2);
+        _defineProperty(this, "interpreters", new _NamespacedMap.NamespacedMap([
+          // Remember to add your unit test when adding to this! ("known events" test description)
+          [_MRoomMessage.LEGACY_M_ROOM_MESSAGE, _MRoomMessage.parseMRoomMessage],
+          [_message_types.M_MESSAGE, _MMessage.parseMMessage],
+          [_message_types.M_EMOTE, _MMessage.parseMMessage],
+          [_message_types.M_NOTICE, _MMessage.parseMMessage],
+          [_poll_types.M_POLL_START, _MPoll.parseMPoll],
+          [_poll_types.M_POLL_RESPONSE, _MPoll.parseMPoll],
+          [_poll_types.M_POLL_END, _MPoll.parseMPoll]
+        ]));
+        _defineProperty(this, "_unknownInterpretOrder", [_message_types.M_MESSAGE]);
+      }
+      __name(ExtensibleEvents2, "ExtensibleEvents");
+      _createClass(ExtensibleEvents2, [{
+        key: "unknownInterpretOrder",
+        get: (
+          /**
+           * Gets the order the internal processor will use for unknown primary
+           * event types.
+           */
+          /* @__PURE__ */ __name(function get() {
+            var _this$_unknownInterpr;
+            return (_this$_unknownInterpr = this._unknownInterpretOrder) !== null && _this$_unknownInterpr !== void 0 ? _this$_unknownInterpr : [];
+          }, "get")
+        ),
+        set: /* @__PURE__ */ __name(function set(val) {
+          this._unknownInterpretOrder = val;
+        }, "set")
+        /**
+         * Gets the order the internal processor will use for unknown primary
+         * event types.
+         */
+      }, {
+        key: "registerInterpreter",
+        value: (
+          /**
+           * Registers a primary event type interpreter. Note that the interpreter might be
+           * called with non-primary events if the event is being parsed as a fallback.
+           * @param {NamespacedValue<string, string>} wireEventType The event type.
+           * @param {EventInterpreter} interpreter The interpreter.
+           */
+          /* @__PURE__ */ __name(function registerInterpreter(wireEventType, interpreter) {
+            this.interpreters.set(wireEventType, interpreter);
+          }, "registerInterpreter")
+        )
+        /**
+         * Registers a primary event type interpreter. Note that the interpreter might be
+         * called with non-primary events if the event is being parsed as a fallback.
+         * @param {NamespacedValue<string, string>} wireEventType The event type.
+         * @param {EventInterpreter} interpreter The interpreter.
+         */
+      }, {
+        key: "parse",
+        value: (
+          /**
+           * Parses an event, trying the primary event type first. If the primary type is not known
+           * then the content will be inspected to find the most suitable fallback.
+           *
+           * If the parsing failed or was a completely unknown type, this will return falsy.
+           * @param {IPartialEvent<object>} wireFormat The event to parse.
+           * @returns {Optional<ExtensibleEvent>} The parsed extensible event.
+           */
+          /* @__PURE__ */ __name(function parse(wireFormat) {
+            try {
+              if (this.interpreters.hasNamespaced(wireFormat.type)) {
+                return this.interpreters.getNamespaced(wireFormat.type)(wireFormat);
+              }
+              var _iterator = _createForOfIteratorHelper(this.unknownInterpretOrder), _step;
+              try {
+                for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+                  var tryType = _step.value;
+                  if (this.interpreters.has(tryType)) {
+                    var val = this.interpreters.get(tryType)(wireFormat);
+                    if (val) return val;
+                  }
+                }
+              } catch (err) {
+                _iterator.e(err);
+              } finally {
+                _iterator.f();
+              }
+              return null;
+            } catch (e) {
+              if (e instanceof _InvalidEventError.InvalidEventError) {
+                return null;
+              }
+              throw e;
+            }
+          }, "parse")
+        )
+        /**
+         * Parses an event, trying the primary event type first. If the primary type is not known
+         * then the content will be inspected to find the most suitable fallback.
+         *
+         * If the parsing failed or was a completely unknown type, this will return falsy.
+         * @param {IPartialEvent<object>} wireFormat The event to parse.
+         * @returns {Optional<ExtensibleEvent>} The parsed extensible event.
+         */
+      }], [{
+        key: "defaultInstance",
+        get: /* @__PURE__ */ __name(function get() {
+          return ExtensibleEvents2._defaultInstance;
+        }, "get")
+      }, {
+        key: "unknownInterpretOrder",
+        get: /* @__PURE__ */ __name(function get() {
+          return ExtensibleEvents2.defaultInstance.unknownInterpretOrder;
+        }, "get"),
+        set: /* @__PURE__ */ __name(function set(val) {
+          ExtensibleEvents2.defaultInstance.unknownInterpretOrder = val;
+        }, "set")
+      }, {
+        key: "registerInterpreter",
+        value: /* @__PURE__ */ __name(function registerInterpreter(wireEventType, interpreter) {
+          ExtensibleEvents2.defaultInstance.registerInterpreter(wireEventType, interpreter);
+        }, "registerInterpreter")
+      }, {
+        key: "parse",
+        value: /* @__PURE__ */ __name(function parse(wireFormat) {
+          return ExtensibleEvents2.defaultInstance.parse(wireFormat);
+        }, "parse")
+      }]);
+      return ExtensibleEvents2;
+    })();
+    exports.ExtensibleEvents = ExtensibleEvents;
+    _defineProperty(ExtensibleEvents, "_defaultInstance", new ExtensibleEvents());
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/IPartialEvent.js
+var require_IPartialEvent = __commonJS({
+  "node_modules/matrix-events-sdk/lib/IPartialEvent.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/utility/MessageMatchers.js
+var require_MessageMatchers = __commonJS({
+  "node_modules/matrix-events-sdk/lib/utility/MessageMatchers.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.LegacyMsgType = void 0;
+    exports.isEventLike = isEventLike;
+    var _message_types = require_message_types();
+    var LegacyMsgType;
+    exports.LegacyMsgType = LegacyMsgType;
+    (function(LegacyMsgType2) {
+      LegacyMsgType2["Text"] = "m.text";
+      LegacyMsgType2["Notice"] = "m.notice";
+      LegacyMsgType2["Emote"] = "m.emote";
+    })(LegacyMsgType || (exports.LegacyMsgType = LegacyMsgType = {}));
+    function isEventLike(event, msgtype) {
+      var content = event.content;
+      if (msgtype === LegacyMsgType.Text) {
+        return _message_types.M_MESSAGE.matches(event.type) || event.type === "m.room.message" && (content === null || content === void 0 ? void 0 : content["msgtype"]) === "m.text";
+      } else if (msgtype === LegacyMsgType.Emote) {
+        return _message_types.M_EMOTE.matches(event.type) || event.type === "m.room.message" && (content === null || content === void 0 ? void 0 : content["msgtype"]) === "m.emote";
+      } else if (msgtype === LegacyMsgType.Notice) {
+        return _message_types.M_NOTICE.matches(event.type) || event.type === "m.room.message" && (content === null || content === void 0 ? void 0 : content["msgtype"]) === "m.notice";
+      }
+      return false;
+    }
+    __name(isEventLike, "isEventLike");
+  }
+});
+
+// node_modules/matrix-events-sdk/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/matrix-events-sdk/lib/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    var _ExtensibleEvents = require_ExtensibleEvents();
+    Object.keys(_ExtensibleEvents).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _ExtensibleEvents[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _ExtensibleEvents[key];
+        }, "get")
+      });
+    });
+    var _IPartialEvent = require_IPartialEvent();
+    Object.keys(_IPartialEvent).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _IPartialEvent[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _IPartialEvent[key];
+        }, "get")
+      });
+    });
+    var _InvalidEventError = require_InvalidEventError();
+    Object.keys(_InvalidEventError).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _InvalidEventError[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _InvalidEventError[key];
+        }, "get")
+      });
+    });
+    var _NamespacedValue = require_NamespacedValue();
+    Object.keys(_NamespacedValue).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _NamespacedValue[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _NamespacedValue[key];
+        }, "get")
+      });
+    });
+    var _NamespacedMap = require_NamespacedMap();
+    Object.keys(_NamespacedMap).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _NamespacedMap[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _NamespacedMap[key];
+        }, "get")
+      });
+    });
+    var _types = require_types();
+    Object.keys(_types).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _types[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _types[key];
+        }, "get")
+      });
+    });
+    var _MessageMatchers = require_MessageMatchers();
+    Object.keys(_MessageMatchers).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _MessageMatchers[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _MessageMatchers[key];
+        }, "get")
+      });
+    });
+    var _events = require_events();
+    Object.keys(_events).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _events[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _events[key];
+        }, "get")
+      });
+    });
+    var _MRoomMessage = require_MRoomMessage();
+    Object.keys(_MRoomMessage).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _MRoomMessage[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _MRoomMessage[key];
+        }, "get")
+      });
+    });
+    var _MMessage = require_MMessage();
+    Object.keys(_MMessage).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _MMessage[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _MMessage[key];
+        }, "get")
+      });
+    });
+    var _MPoll = require_MPoll();
+    Object.keys(_MPoll).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _MPoll[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _MPoll[key];
+        }, "get")
+      });
+    });
+    var _relationship_types = require_relationship_types();
+    Object.keys(_relationship_types).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _relationship_types[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _relationship_types[key];
+        }, "get")
+      });
+    });
+    var _ExtensibleEvent = require_ExtensibleEvent();
+    Object.keys(_ExtensibleEvent).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _ExtensibleEvent[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _ExtensibleEvent[key];
+        }, "get")
+      });
+    });
+    var _message_types = require_message_types();
+    Object.keys(_message_types).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _message_types[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _message_types[key];
+        }, "get")
+      });
+    });
+    var _MessageEvent = require_MessageEvent();
+    Object.keys(_MessageEvent).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _MessageEvent[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _MessageEvent[key];
+        }, "get")
+      });
+    });
+    var _EmoteEvent = require_EmoteEvent();
+    Object.keys(_EmoteEvent).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _EmoteEvent[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _EmoteEvent[key];
+        }, "get")
+      });
+    });
+    var _NoticeEvent = require_NoticeEvent();
+    Object.keys(_NoticeEvent).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _NoticeEvent[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _NoticeEvent[key];
+        }, "get")
+      });
+    });
+    var _poll_types = require_poll_types();
+    Object.keys(_poll_types).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _poll_types[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _poll_types[key];
+        }, "get")
+      });
+    });
+    var _PollStartEvent = require_PollStartEvent();
+    Object.keys(_PollStartEvent).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _PollStartEvent[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _PollStartEvent[key];
+        }, "get")
+      });
+    });
+    var _PollResponseEvent = require_PollResponseEvent();
+    Object.keys(_PollResponseEvent).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _PollResponseEvent[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _PollResponseEvent[key];
+        }, "get")
+      });
+    });
+    var _PollEndEvent = require_PollEndEvent();
+    Object.keys(_PollEndEvent).forEach(function(key) {
+      if (key === "default" || key === "__esModule") return;
+      if (key in exports && exports[key] === _PollEndEvent[key]) return;
+      Object.defineProperty(exports, key, {
+        enumerable: true,
+        get: /* @__PURE__ */ __name(function get() {
+          return _PollEndEvent[key];
+        }, "get")
+      });
+    });
+  }
+});
+
+// node_modules/matrix-js-sdk/lib/@types/polls.js
+var import_matrix_events_sdk = __toESM(require_lib(), 1);
+var M_POLL_KIND_DISCLOSED = new import_matrix_events_sdk.UnstableValue("m.poll.disclosed", "org.matrix.msc3381.poll.disclosed");
+var M_POLL_KIND_UNDISCLOSED = new import_matrix_events_sdk.UnstableValue("m.poll.undisclosed", "org.matrix.msc3381.poll.undisclosed");
+var M_POLL_START = new import_matrix_events_sdk.UnstableValue("m.poll.start", "org.matrix.msc3381.poll.start");
+var M_POLL_RESPONSE = new import_matrix_events_sdk.UnstableValue("m.poll.response", "org.matrix.msc3381.poll.response");
+var M_POLL_END = new import_matrix_events_sdk.UnstableValue("m.poll.end", "org.matrix.msc3381.poll.end");
+export {
+  M_POLL_END,
+  M_POLL_KIND_DISCLOSED,
+  M_POLL_KIND_UNDISCLOSED,
+  M_POLL_RESPONSE,
+  M_POLL_START
+};