{"version":3,"file":"bundles/af727d0960b2852f82f5/bundle.js","mappings":"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","sources":["webpack://element-web/webpack/runtime/chunk loaded","webpack://element-web/webpack/runtime/create fake namespace object","webpack://element-web/webpack/runtime/load script","webpack://element-web/webpack/runtime/chunk preload trigger","webpack://element-web/./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack://element-web/./node_modules/@babel/runtime/helpers/esm/toPrimitive.js","webpack://element-web/./node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","webpack://element-web/./node_modules/@babel/runtime/helpers/esm/typeof.js","webpack://element-web/./node_modules/@formatjs/intl-segmenter/should-polyfill.js","webpack://element-web/./node_modules/loglevel/lib/loglevel.js","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/location.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/@types/read_receipts.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/NamespacedValue.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/logger.ts","webpack://element-web/./node_modules/matrix-js-sdk/src/utils.ts","webpack://element-web/./node_modules/p-retry/index.js","webpack://element-web/./node_modules/retry/index.js","webpack://element-web/./node_modules/retry/lib/retry.js","webpack://element-web/./node_modules/retry/lib/retry_operation.js","webpack://element-web/./node_modules/unhomoglyph/index.js","webpack://element-web/./src/vector/index.ts","webpack://element-web/./src/vector/localstorage-fix.ts","webpack://element-web/./src/vector/modernizr.js","webpack://element-web/./src/vector/url_utils.ts","webpack://element-web/webpack/bootstrap","webpack://element-web/webpack/runtime/amd define","webpack://element-web/webpack/runtime/amd options","webpack://element-web/webpack/runtime/chunk preload function","webpack://element-web/webpack/runtime/compat get default export","webpack://element-web/webpack/runtime/define property getters","webpack://element-web/webpack/runtime/ensure chunk","webpack://element-web/webpack/runtime/get javascript chunk filename","webpack://element-web/webpack/runtime/get mini-css chunk filename","webpack://element-web/webpack/runtime/getFullHash","webpack://element-web/webpack/runtime/global","webpack://element-web/webpack/runtime/hasOwnProperty shorthand","webpack://element-web/webpack/runtime/make namespace object","webpack://element-web/webpack/runtime/node module decorator","webpack://element-web/webpack/runtime/wasm loading","webpack://element-web/webpack/runtime/publicPath","webpack://element-web/webpack/runtime/compat","webpack://element-web/webpack/runtime/css loading","webpack://element-web/webpack/runtime/jsonp chunk loading","webpack://element-web/webpack/runtime/nonce","webpack://element-web/webpack/startup"],"sourcesContent":["var deferred = [];\n__webpack_require__.O = (result, chunkIds, fn, priority) => {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar [chunkIds, fn, priority] = deferred[i];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tvar r = fn();\n\t\t\tif (r !== undefined) result = r;\n\t\t}\n\t}\n\treturn result;\n};","var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);\nvar leafPrototypes;\n// create a fake namespace object\n// mode & 1: value is a module id, require it\n// mode & 2: merge all properties of value into the ns\n// mode & 4: return value when already ns object\n// mode & 16: return value when it's Promise-like\n// mode & 8|1: behave like require\n__webpack_require__.t = function(value, mode) {\n\tif(mode & 1) value = this(value);\n\tif(mode & 8) return value;\n\tif(typeof value === 'object' && value) {\n\t\tif((mode & 4) && value.__esModule) return value;\n\t\tif((mode & 16) && typeof value.then === 'function') return value;\n\t}\n\tvar ns = Object.create(null);\n\t__webpack_require__.r(ns);\n\tvar def = {};\n\tleafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];\n\tfor(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {\n\t\tObject.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));\n\t}\n\tdef['default'] = () => (value);\n\t__webpack_require__.d(ns, def);\n\treturn ns;\n};","var inProgress = {};\nvar dataWebpackPrefix = \"element-web:\";\n// loadScript function to load a script via script tag\n__webpack_require__.l = (url, done, key, chunkId) => {\n\tif(inProgress[url]) { inProgress[url].push(done); return; }\n\tvar script, needAttach;\n\tif(key !== undefined) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tfor(var i = 0; i < scripts.length; i++) {\n\t\t\tvar s = scripts[i];\n\t\t\tif(s.getAttribute(\"src\") == url || s.getAttribute(\"data-webpack\") == dataWebpackPrefix + key) { script = s; break; }\n\t\t}\n\t}\n\tif(!script) {\n\t\tneedAttach = true;\n\t\tscript = document.createElement('script');\n\n\t\tscript.charset = 'utf-8';\n\t\tscript.timeout = 120;\n\t\tif (__webpack_require__.nc) {\n\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tscript.setAttribute(\"data-webpack\", dataWebpackPrefix + key);\n\n\t\tscript.src = url;\n\t}\n\tinProgress[url] = [done];\n\tvar onScriptComplete = (prev, event) => {\n\t\t// avoid mem leaks in IE.\n\t\tscript.onerror = script.onload = null;\n\t\tclearTimeout(timeout);\n\t\tvar doneFns = inProgress[url];\n\t\tdelete inProgress[url];\n\t\tscript.parentNode && script.parentNode.removeChild(script);\n\t\tdoneFns && doneFns.forEach((fn) => (fn(event)));\n\t\tif(prev) return prev(event);\n\t}\n\tvar timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);\n\tscript.onerror = onScriptComplete.bind(null, script.onerror);\n\tscript.onload = onScriptComplete.bind(null, script.onload);\n\tneedAttach && document.head.appendChild(script);\n};","var chunkToChildrenMap = {\n\t\"5385\": [\n\t\t1869,\n\t\t3323,\n\t\t246,\n\t\t2702\n\t]\n};\n__webpack_require__.f.preload = (chunkId) => {\n\tvar chunks = chunkToChildrenMap[chunkId];\n\tArray.isArray(chunks) && chunks.map(__webpack_require__.G);\n};","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperty(e, r, t) {\n  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: !0,\n    configurable: !0,\n    writable: !0\n  }) : e[r] = t, e;\n}\nexport { _defineProperty as default };","import _typeof from \"./typeof.js\";\nfunction toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nexport { toPrimitive as default };","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nfunction toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : i + \"\";\n}\nexport { toPropertyKey as default };","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}\nexport { _typeof as default };","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.shouldPolyfill = shouldPolyfill;\nfunction shouldPolyfill() {\n    return !Intl.Segmenter;\n}\n","/*\n* loglevel - https://github.com/pimterry/loglevel\n*\n* Copyright (c) 2013 Tim Perry\n* Licensed under the MIT license.\n*/\n(function (root, definition) {\n    \"use strict\";\n    if (typeof define === 'function' && define.amd) {\n        define(definition);\n    } else if (typeof module === 'object' && module.exports) {\n        module.exports = definition();\n    } else {\n        root.log = definition();\n    }\n}(this, function () {\n    \"use strict\";\n\n    // Slightly dubious tricks to cut down minimized file size\n    var noop = function() {};\n    var undefinedType = \"undefined\";\n    var isIE = (typeof window !== undefinedType) && (typeof window.navigator !== undefinedType) && (\n        /Trident\\/|MSIE /.test(window.navigator.userAgent)\n    );\n\n    var logMethods = [\n        \"trace\",\n        \"debug\",\n        \"info\",\n        \"warn\",\n        \"error\"\n    ];\n\n    var _loggersByName = {};\n    var defaultLogger = null;\n\n    // Cross-browser bind equivalent that works at least back to IE6\n    function bindMethod(obj, methodName) {\n        var method = obj[methodName];\n        if (typeof method.bind === 'function') {\n            return method.bind(obj);\n        } else {\n            try {\n                return Function.prototype.bind.call(method, obj);\n            } catch (e) {\n                // Missing bind shim or IE8 + Modernizr, fallback to wrapping\n                return function() {\n                    return Function.prototype.apply.apply(method, [obj, arguments]);\n                };\n            }\n        }\n    }\n\n    // Trace() doesn't print the message in IE, so for that case we need to wrap it\n    function traceForIE() {\n        if (console.log) {\n            if (console.log.apply) {\n                console.log.apply(console, arguments);\n            } else {\n                // In old IE, native console methods themselves don't have apply().\n                Function.prototype.apply.apply(console.log, [console, arguments]);\n            }\n        }\n        if (console.trace) console.trace();\n    }\n\n    // Build the best logging method possible for this env\n    // Wherever possible we want to bind, not wrap, to preserve stack traces\n    function realMethod(methodName) {\n        if (methodName === 'debug') {\n            methodName = 'log';\n        }\n\n        if (typeof console === undefinedType) {\n            return false; // No method possible, for now - fixed later by enableLoggingWhenConsoleArrives\n        } else if (methodName === 'trace' && isIE) {\n            return traceForIE;\n        } else if (console[methodName] !== undefined) {\n            return bindMethod(console, methodName);\n        } else if (console.log !== undefined) {\n            return bindMethod(console, 'log');\n        } else {\n            return noop;\n        }\n    }\n\n    // These private functions always need `this` to be set properly\n\n    function replaceLoggingMethods() {\n        /*jshint validthis:true */\n        var level = this.getLevel();\n\n        // Replace the actual methods.\n        for (var i = 0; i < logMethods.length; i++) {\n            var methodName = logMethods[i];\n            this[methodName] = (i < level) ?\n                noop :\n                this.methodFactory(methodName, level, this.name);\n        }\n\n        // Define log.log as an alias for log.debug\n        this.log = this.debug;\n\n        // Return any important warnings.\n        if (typeof console === undefinedType && level < this.levels.SILENT) {\n            return \"No console available for logging\";\n        }\n    }\n\n    // In old IE versions, the console isn't present until you first open it.\n    // We build realMethod() replacements here that regenerate logging methods\n    function enableLoggingWhenConsoleArrives(methodName) {\n        return function () {\n            if (typeof console !== undefinedType) {\n                replaceLoggingMethods.call(this);\n                this[methodName].apply(this, arguments);\n            }\n        };\n    }\n\n    // By default, we use closely bound real methods wherever possible, and\n    // otherwise we wait for a console to appear, and then try again.\n    function defaultMethodFactory(methodName, _level, _loggerName) {\n        /*jshint validthis:true */\n        return realMethod(methodName) ||\n               enableLoggingWhenConsoleArrives.apply(this, arguments);\n    }\n\n    function Logger(name, factory) {\n      // Private instance variables.\n      var self = this;\n      /**\n       * The level inherited from a parent logger (or a global default). We\n       * cache this here rather than delegating to the parent so that it stays\n       * in sync with the actual logging methods that we have installed (the\n       * parent could change levels but we might not have rebuilt the loggers\n       * in this child yet).\n       * @type {number}\n       */\n      var inheritedLevel;\n      /**\n       * The default level for this logger, if any. If set, this overrides\n       * `inheritedLevel`.\n       * @type {number|null}\n       */\n      var defaultLevel;\n      /**\n       * A user-specific level for this logger. If set, this overrides\n       * `defaultLevel`.\n       * @type {number|null}\n       */\n      var userLevel;\n\n      var storageKey = \"loglevel\";\n      if (typeof name === \"string\") {\n        storageKey += \":\" + name;\n      } else if (typeof name === \"symbol\") {\n        storageKey = undefined;\n      }\n\n      function persistLevelIfPossible(levelNum) {\n          var levelName = (logMethods[levelNum] || 'silent').toUpperCase();\n\n          if (typeof window === undefinedType || !storageKey) return;\n\n          // Use localStorage if available\n          try {\n              window.localStorage[storageKey] = levelName;\n              return;\n          } catch (ignore) {}\n\n          // Use session cookie as fallback\n          try {\n              window.document.cookie =\n                encodeURIComponent(storageKey) + \"=\" + levelName + \";\";\n          } catch (ignore) {}\n      }\n\n      function getPersistedLevel() {\n          var storedLevel;\n\n          if (typeof window === undefinedType || !storageKey) return;\n\n          try {\n              storedLevel = window.localStorage[storageKey];\n          } catch (ignore) {}\n\n          // Fallback to cookies if local storage gives us nothing\n          if (typeof storedLevel === undefinedType) {\n              try {\n                  var cookie = window.document.cookie;\n                  var cookieName = encodeURIComponent(storageKey);\n                  var location = cookie.indexOf(cookieName + \"=\");\n                  if (location !== -1) {\n                      storedLevel = /^([^;]+)/.exec(\n                          cookie.slice(location + cookieName.length + 1)\n                      )[1];\n                  }\n              } catch (ignore) {}\n          }\n\n          // If the stored level is not valid, treat it as if nothing was stored.\n          if (self.levels[storedLevel] === undefined) {\n              storedLevel = undefined;\n          }\n\n          return storedLevel;\n      }\n\n      function clearPersistedLevel() {\n          if (typeof window === undefinedType || !storageKey) return;\n\n          // Use localStorage if available\n          try {\n              window.localStorage.removeItem(storageKey);\n          } catch (ignore) {}\n\n          // Use session cookie as fallback\n          try {\n              window.document.cookie =\n                encodeURIComponent(storageKey) + \"=; expires=Thu, 01 Jan 1970 00:00:00 UTC\";\n          } catch (ignore) {}\n      }\n\n      function normalizeLevel(input) {\n          var level = input;\n          if (typeof level === \"string\" && self.levels[level.toUpperCase()] !== undefined) {\n              level = self.levels[level.toUpperCase()];\n          }\n          if (typeof level === \"number\" && level >= 0 && level <= self.levels.SILENT) {\n              return level;\n          } else {\n              throw new TypeError(\"log.setLevel() called with invalid level: \" + input);\n          }\n      }\n\n      /*\n       *\n       * Public logger API - see https://github.com/pimterry/loglevel for details\n       *\n       */\n\n      self.name = name;\n\n      self.levels = { \"TRACE\": 0, \"DEBUG\": 1, \"INFO\": 2, \"WARN\": 3,\n          \"ERROR\": 4, \"SILENT\": 5};\n\n      self.methodFactory = factory || defaultMethodFactory;\n\n      self.getLevel = function () {\n          if (userLevel != null) {\n            return userLevel;\n          } else if (defaultLevel != null) {\n            return defaultLevel;\n          } else {\n            return inheritedLevel;\n          }\n      };\n\n      self.setLevel = function (level, persist) {\n          userLevel = normalizeLevel(level);\n          if (persist !== false) {  // defaults to true\n              persistLevelIfPossible(userLevel);\n          }\n\n          // NOTE: in v2, this should call rebuild(), which updates children.\n          return replaceLoggingMethods.call(self);\n      };\n\n      self.setDefaultLevel = function (level) {\n          defaultLevel = normalizeLevel(level);\n          if (!getPersistedLevel()) {\n              self.setLevel(level, false);\n          }\n      };\n\n      self.resetLevel = function () {\n          userLevel = null;\n          clearPersistedLevel();\n          replaceLoggingMethods.call(self);\n      };\n\n      self.enableAll = function(persist) {\n          self.setLevel(self.levels.TRACE, persist);\n      };\n\n      self.disableAll = function(persist) {\n          self.setLevel(self.levels.SILENT, persist);\n      };\n\n      self.rebuild = function () {\n          if (defaultLogger !== self) {\n              inheritedLevel = normalizeLevel(defaultLogger.getLevel());\n          }\n          replaceLoggingMethods.call(self);\n\n          if (defaultLogger === self) {\n              for (var childName in _loggersByName) {\n                _loggersByName[childName].rebuild();\n              }\n          }\n      };\n\n      // Initialize all the internal levels.\n      inheritedLevel = normalizeLevel(\n          defaultLogger ? defaultLogger.getLevel() : \"WARN\"\n      );\n      var initialLevel = getPersistedLevel();\n      if (initialLevel != null) {\n          userLevel = normalizeLevel(initialLevel);\n      }\n      replaceLoggingMethods.call(self);\n    }\n\n    /*\n     *\n     * Top-level API\n     *\n     */\n\n    defaultLogger = new Logger();\n\n    defaultLogger.getLogger = function getLogger(name) {\n        if ((typeof name !== \"symbol\" && typeof name !== \"string\") || name === \"\") {\n            throw new TypeError(\"You must supply a name when creating a logger.\");\n        }\n\n        var logger = _loggersByName[name];\n        if (!logger) {\n            logger = _loggersByName[name] = new Logger(\n                name,\n                defaultLogger.methodFactory\n            );\n        }\n        return logger;\n    };\n\n    // Grab the current global log variable in case of overwrite\n    var _log = (typeof window !== undefinedType) ? window.log : undefined;\n    defaultLogger.noConflict = function() {\n        if (typeof window !== undefinedType &&\n               window.log === defaultLogger) {\n            window.log = _log;\n        }\n\n        return defaultLogger;\n    };\n\n    defaultLogger.getLoggers = function getLoggers() {\n        return _loggersByName;\n    };\n\n    // ES6 default export, for compatibility\n    defaultLogger['default'] = defaultLogger;\n\n    return defaultLogger;\n}));\n","/*\nCopyright 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n// Types for MSC3488 - m.location: Extending events with location data\nimport { type EitherAnd } from \"matrix-events-sdk\";\n\nimport { UnstableValue } from \"../NamespacedValue.ts\";\nimport { type M_TEXT } from \"./extensible_events.ts\";\n\nexport enum LocationAssetType {\n    Self = \"m.self\",\n    Pin = \"m.pin\",\n}\n\nexport const M_ASSET = new UnstableValue(\"m.asset\", \"org.matrix.msc3488.asset\");\nexport type MAssetContent = { type: LocationAssetType };\n/**\n * The event definition for an m.asset event (in content)\n */\nexport type MAssetEvent = EitherAnd<{ [M_ASSET.name]: MAssetContent }, { [M_ASSET.altName]: MAssetContent }>;\n\nexport const M_TIMESTAMP = new UnstableValue(\"m.ts\", \"org.matrix.msc3488.ts\");\n/**\n * The event definition for an m.ts event (in content)\n */\nexport type MTimestampEvent = EitherAnd<{ [M_TIMESTAMP.name]: number }, { [M_TIMESTAMP.altName]: number }>;\n\nexport const M_LOCATION = new UnstableValue(\"m.location\", \"org.matrix.msc3488.location\");\n\nexport type MLocationContent = {\n    uri: string;\n    description?: string | null;\n};\n\nexport type MLocationEvent = EitherAnd<\n    { [M_LOCATION.name]: MLocationContent },\n    { [M_LOCATION.altName]: MLocationContent }\n>;\n\nexport type MTextEvent = EitherAnd<{ [M_TEXT.name]: string }, { [M_TEXT.altName]: string }>;\n\n/* From the spec at:\n * https://github.com/matrix-org/matrix-doc/blob/matthew/location/proposals/3488-location.md\n{\n    \"type\": \"m.room.message\",\n    \"content\": {\n        \"body\": \"Matthew was at geo:51.5008,0.1247;u=35 as of Sat Nov 13 18:50:58 2021\",\n        \"msgtype\": \"m.location\",\n        \"geo_uri\": \"geo:51.5008,0.1247;u=35\",\n        \"m.location\": {\n            \"uri\": \"geo:51.5008,0.1247;u=35\",\n            \"description\": \"Matthew's whereabouts\",\n        },\n        \"m.asset\": {\n            \"type\": \"m.self\"\n        },\n        \"m.text\": \"Matthew was at geo:51.5008,0.1247;u=35 as of Sat Nov 13 18:50:58 2021\",\n        \"m.ts\": 1636829458432,\n    }\n}\n*/\ntype OptionalTimestampEvent = MTimestampEvent | undefined;\n/**\n * The content for an m.location event\n */\nexport type MLocationEventContent = MLocationEvent & MAssetEvent & MTextEvent & OptionalTimestampEvent;\n\nexport type LegacyLocationEventContent = {\n    body: string;\n    msgtype: string;\n    geo_uri: string;\n};\n\n/**\n * Possible content for location events as sent over the wire\n */\nexport type LocationEventWireContent = Partial<LegacyLocationEventContent & MLocationEventContent>;\n\nexport type ILocationContent = MLocationEventContent & LegacyLocationEventContent;\n","/*\nCopyright 2022 Šimon Brandner <simon.bra.ag@gmail.com>\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nexport enum ReceiptType {\n    Read = \"m.read\",\n    FullyRead = \"m.fully_read\",\n    ReadPrivate = \"m.read.private\",\n}\n\nexport const MAIN_ROOM_TIMELINE = \"main\";\n\nexport interface Receipt {\n    ts: number;\n    thread_id?: string;\n}\n\nexport interface WrappedReceipt {\n    eventId: string;\n    data: Receipt;\n}\n\nexport interface CachedReceipt {\n    type: ReceiptType;\n    userId: string;\n    data: Receipt;\n}\n\nexport type ReceiptCache = Map<string, CachedReceipt[]>;\n\nexport interface ReceiptContent {\n    [eventId: string]: {\n        [key in ReceiptType | string]: {\n            [userId: string]: Receipt;\n        };\n    };\n}\n\n// We will only hold a synthetic receipt if we do not have a real receipt or the synthetic is newer.\n// map: receipt type → user Id → receipt\nexport type Receipts = Map<string, Map<string, [real: WrappedReceipt | null, synthetic: WrappedReceipt | null]>>;\n\nexport type CachedReceiptStructure = {\n    eventId: string;\n    receiptType: string | ReceiptType;\n    userId: string;\n    receipt: Receipt;\n    synthetic: boolean;\n};\n","/*\nCopyright 2021 - 2022 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport { type Optional } from \"matrix-events-sdk/lib/types\";\n\n/**\n * Represents a simple Matrix namespaced value. This will assume that if a stable prefix\n * is provided that the stable prefix should be used when representing the identifier.\n */\nexport class NamespacedValue<S extends string, U extends string> {\n    // Stable is optional, but one of the two parameters is required, hence the weird-looking types.\n    // Goal is to to have developers explicitly say there is no stable value (if applicable).\n    public constructor(stable: S, unstable: U);\n    public constructor(stable: S, unstable?: U);\n    public constructor(stable: null | undefined, unstable: U);\n    public constructor(\n        public readonly stable?: S | null,\n        public readonly unstable?: U,\n    ) {\n        if (!this.unstable && !this.stable) {\n            throw new Error(\"One of stable or unstable values must be supplied\");\n        }\n    }\n\n    public get name(): U | S {\n        if (this.stable) {\n            return this.stable;\n        }\n        return this.unstable!;\n    }\n\n    public get altName(): U | S | null | undefined {\n        if (!this.stable) {\n            return null;\n        }\n        return this.unstable;\n    }\n\n    public get names(): (U | S)[] {\n        const names = [this.name];\n        const altName = this.altName;\n        if (altName) names.push(altName);\n        return names;\n    }\n\n    public matches(val: string): boolean {\n        return this.name === val || this.altName === val;\n    }\n\n    // this desperately wants https://github.com/microsoft/TypeScript/pull/26349 at the top level of the class\n    // so we can instantiate `NamespacedValue<string, _, _>` as a default type for that namespace.\n    public findIn<T>(obj: any): Optional<T> {\n        let val: T | undefined = undefined;\n        if (this.name) {\n            val = obj?.[this.name];\n        }\n        if (!val && this.altName) {\n            val = obj?.[this.altName];\n        }\n        return val;\n    }\n\n    public includedIn(arr: any[]): boolean {\n        let included = false;\n        if (this.name) {\n            included = arr.includes(this.name);\n        }\n        if (!included && this.altName) {\n            included = arr.includes(this.altName);\n        }\n        return included;\n    }\n}\n\nexport class ServerControlledNamespacedValue<S extends string, U extends string> extends NamespacedValue<S, U> {\n    private preferUnstable = false;\n\n    public setPreferUnstable(preferUnstable: boolean): void {\n        this.preferUnstable = preferUnstable;\n    }\n\n    public get name(): U | S {\n        if (this.stable && !this.preferUnstable) {\n            return this.stable;\n        }\n        return this.unstable!;\n    }\n}\n\n/**\n * Represents a namespaced value which prioritizes the unstable value over the stable\n * value.\n */\nexport class UnstableValue<S extends string, U extends string> extends NamespacedValue<S, U> {\n    // Note: Constructor difference is that `unstable` is *required*.\n    public constructor(stable: S, unstable: U) {\n        super(stable, unstable);\n        if (!this.unstable) {\n            throw new Error(\"Unstable value must be supplied\");\n        }\n    }\n\n    public get name(): U {\n        return this.unstable!;\n    }\n\n    public get altName(): S {\n        return this.stable!;\n    }\n}\n","/*\nCopyright 2018 André Jaenisch\nCopyright 2019, 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport loglevel from \"loglevel\";\n\n/** Backwards-compatibility hack to expose `log` to applications that might still be relying on it. */\ninterface LoggerWithLogMethod extends Logger {\n    /**\n     * Output debug message to the logger.\n     *\n     * @param msg - Data to log.\n     *\n     * @deprecated prefer {@link Logger.debug}.\n     */\n    log(...msg: any[]): void;\n}\n\n/** Logger interface used within the js-sdk codebase */\nexport interface Logger extends BaseLogger {\n    /**\n     * Create a child logger.\n     *\n     * @param namespace - name to add to the current logger to generate the child. Some implementations of `Logger`\n     *    use this as a prefix; others use a different mechanism.\n     */\n    getChild(namespace: string): Logger;\n}\n\n/** The basic interface for a logger which doesn't support children */\nexport interface BaseLogger {\n    /**\n     * Output trace message to the logger, with stack trace.\n     *\n     * @param msg - Data to log.\n     */\n    trace(...msg: any[]): void;\n\n    /**\n     * Output debug message to the logger.\n     *\n     * @param msg - Data to log.\n     */\n    debug(...msg: any[]): void;\n\n    /**\n     * Output info message to the logger.\n     *\n     * @param msg - Data to log.\n     */\n    info(...msg: any[]): void;\n\n    /**\n     * Output warn message to the logger.\n     *\n     * @param msg - Data to log.\n     */\n    warn(...msg: any[]): void;\n\n    /**\n     * Output error message to the logger.\n     *\n     * @param msg - Data to log.\n     */\n    error(...msg: any[]): void;\n}\n\n// This is to demonstrate, that you can use any namespace you want.\n// Namespaces allow you to turn on/off the logging for specific parts of the\n// application.\n// An idea would be to control this via an environment variable (on Node.js).\n// See https://www.npmjs.com/package/debug to see how this could be implemented\n// Part of #332 is introducing a logging library in the first place.\nconst DEFAULT_NAMESPACE = \"matrix\";\n\n// because rageshakes in react-sdk hijack the console log, also at module load time,\n// initializing the logger here races with the initialization of rageshakes.\n// to avoid the issue, we override the methodFactory of loglevel that binds to the\n// console methods at initialization time by a factory that looks up the console methods\n// when logging so we always get the current value of console methods.\nloglevel.methodFactory = function (methodName, logLevel, loggerName) {\n    return function (this: PrefixedLogger, ...args): void {\n        /* eslint-disable @typescript-eslint/no-invalid-this */\n        if (this.prefix) {\n            args.unshift(this.prefix);\n        }\n        /* eslint-enable @typescript-eslint/no-invalid-this */\n        const supportedByConsole =\n            methodName === \"error\" ||\n            methodName === \"warn\" ||\n            methodName === \"trace\" ||\n            methodName === \"info\" ||\n            methodName === \"debug\";\n        /* eslint-disable no-console */\n        if (supportedByConsole) {\n            return console[methodName](...args);\n        } else {\n            return console.log(...args);\n        }\n        /* eslint-enable no-console */\n    };\n};\n\n/**\n * Implementation of {@link Logger} based on `loglevel`.\n */\ninterface PrefixedLogger extends loglevel.Logger, LoggerWithLogMethod {\n    prefix?: string;\n}\n\n/**\n * Internal utility function: gets a {@link Logger} based on `loglevel`.\n *\n * Child loggers produced by {@link Logger.getChild} add the name of the child logger as a prefix on each log line.\n *\n * @param prefix Prefix to add to each logged line. If undefined, no prefix will be added.\n */\nfunction getPrefixedLogger(prefix?: string): LoggerWithLogMethod {\n    const loggerName = DEFAULT_NAMESPACE + (prefix === undefined ? \"\" : `-${prefix}`);\n    const prefixLogger = loglevel.getLogger(loggerName) as PrefixedLogger;\n\n    if (prefixLogger.getChild === undefined) {\n        // This is a new loglevel Logger which has not been turned into a PrefixedLogger yet.\n        prefixLogger.prefix = prefix;\n        prefixLogger.getChild = (childPrefix): Logger => getPrefixedLogger((prefix ?? \"\") + childPrefix);\n        prefixLogger.setLevel(loglevel.levels.DEBUG, false);\n    }\n\n    return prefixLogger;\n}\n\n/**\n * Drop-in replacement for `console` using {@link https://www.npmjs.com/package/loglevel|loglevel}.\n * Can be tailored down to specific use cases if needed.\n */\nexport const logger = getPrefixedLogger();\n\n/**\n * A \"span\" for grouping related log lines together.\n *\n * The current implementation just adds the name at the start of each log line.\n *\n * This offers a lighter-weight alternative to 'child' loggers returned by {@link Logger#getChild}. In particular,\n * it's not possible to apply individual filters to the LogSpan such as setting the verbosity level. On the other hand,\n * no reference to the LogSpan is retained in the logging framework, so it is safe to make lots of them over the course\n * of an application's life and just drop references to them when the job is done.\n */\nexport class LogSpan implements BaseLogger {\n    private readonly name;\n\n    public constructor(\n        private readonly parent: BaseLogger,\n        name: string,\n    ) {\n        this.name = name + \":\";\n    }\n\n    public trace(...msg: any[]): void {\n        this.parent.trace(this.name, ...msg);\n    }\n\n    public debug(...msg: any[]): void {\n        this.parent.debug(this.name, ...msg);\n    }\n\n    public info(...msg: any[]): void {\n        this.parent.info(this.name, ...msg);\n    }\n\n    public warn(...msg: any[]): void {\n        this.parent.warn(this.name, ...msg);\n    }\n\n    public error(...msg: any[]): void {\n        this.parent.error(this.name, ...msg);\n    }\n}\n","/*\nCopyright 2015, 2016, 2019, 2023 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\n/**\n * This is an internal module.\n */\n\nimport unhomoglyph from \"unhomoglyph\";\nimport promiseRetry from \"p-retry\";\nimport { type Optional } from \"matrix-events-sdk\";\n\nimport { type IEvent, type MatrixEvent } from \"./models/event.ts\";\nimport { M_TIMESTAMP } from \"./@types/location.ts\";\nimport { ReceiptType } from \"./@types/read_receipts.ts\";\nimport { type BaseLogger } from \"./logger.ts\";\n\nconst interns = new Map<string, string>();\n\n/**\n * Internalises a string, reusing a known pointer or storing the pointer\n * if needed for future strings.\n * @param str - The string to internalise.\n * @returns The internalised string.\n */\nexport function internaliseString(str: string): string {\n    // Unwrap strings before entering the map, if we somehow got a wrapped\n    // string as our input. This should only happen from tests.\n    if ((str as unknown) instanceof String) {\n        str = str.toString();\n    }\n\n    // Check the map to see if we can store the value\n    if (!interns.has(str)) {\n        interns.set(str, str);\n    }\n\n    // Return any cached string reference\n    return interns.get(str)!;\n}\n\n/**\n * Encode a dictionary of query parameters.\n * Omits any undefined/null values.\n * @param params - A dict of key/values to encode e.g.\n * `{\"foo\": \"bar\", \"baz\": \"taz\"}`\n * @returns The encoded string e.g. foo=bar&baz=taz\n */\nexport function encodeParams(params: QueryDict, urlSearchParams?: URLSearchParams): URLSearchParams {\n    const searchParams = urlSearchParams ?? new URLSearchParams();\n    for (const [key, val] of Object.entries(params)) {\n        if (val !== undefined && val !== null) {\n            if (Array.isArray(val)) {\n                val.forEach((v) => {\n                    searchParams.append(key, String(v));\n                });\n            } else {\n                searchParams.append(key, String(val));\n            }\n        }\n    }\n    return searchParams;\n}\n\nexport type QueryDict = Record<string, string[] | string | number | boolean | undefined>;\n\n/**\n * Replace a stable parameter with the unstable naming for params\n */\nexport function replaceParam(stable: string, unstable: string, dict: QueryDict): QueryDict {\n    const result = {\n        ...dict,\n        [unstable]: dict[stable],\n    };\n    delete result[stable];\n    return result;\n}\n\n/**\n * Decode a query string in `application/x-www-form-urlencoded` format.\n * @param query - A query string to decode e.g.\n * foo=bar&via=server1&server2\n * @returns The decoded object, if any keys occurred multiple times\n * then the value will be an array of strings, else it will be an array.\n * This behaviour matches Node's qs.parse but is built on URLSearchParams\n * for native web compatibility\n */\nexport function decodeParams(query: string): Record<string, string | string[]> {\n    const o: Record<string, string | string[]> = {};\n    const params = new URLSearchParams(query);\n    for (const key of params.keys()) {\n        const val = params.getAll(key);\n        o[key] = val.length === 1 ? val[0] : val;\n    }\n    return o;\n}\n\n/**\n * Encodes a URI according to a set of template variables. Variables will be\n * passed through encodeURIComponent.\n * @param pathTemplate - The path with template variables e.g. '/foo/$bar'.\n * @param variables - The key/value pairs to replace the template\n * variables with. E.g. `{ \"$bar\": \"baz\" }`.\n * @returns The result of replacing all template variables e.g. '/foo/baz'.\n */\nexport function encodeUri(pathTemplate: string, variables: Record<string, Optional<string>>): string {\n    for (const key in variables) {\n        if (!variables.hasOwnProperty(key)) {\n            continue;\n        }\n        const value = variables[key];\n        if (value === undefined || value === null) {\n            continue;\n        }\n        pathTemplate = pathTemplate.replace(key, encodeURIComponent(value));\n    }\n    return pathTemplate;\n}\n\n/**\n * The removeElement() method removes the first element in the array that\n * satisfies (returns true) the provided testing function.\n * @param array - The array.\n * @param fn - Function to execute on each value in the array, with the\n * function signature `fn(element, index, array)`. Return true to\n * remove this element and break.\n * @param reverse - True to search in reverse order.\n * @returns True if an element was removed.\n */\nexport function removeElement<T>(array: T[], fn: (t: T, i?: number, a?: T[]) => boolean, reverse?: boolean): boolean {\n    let i: number;\n    if (reverse) {\n        for (i = array.length - 1; i >= 0; i--) {\n            if (fn(array[i], i, array)) {\n                array.splice(i, 1);\n                return true;\n            }\n        }\n    } else {\n        for (i = 0; i < array.length; i++) {\n            if (fn(array[i], i, array)) {\n                array.splice(i, 1);\n                return true;\n            }\n        }\n    }\n    return false;\n}\n\n/**\n * Checks if the given thing is a function.\n * @param value - The thing to check.\n * @returns True if it is a function.\n */\nexport function isFunction(value: any): boolean {\n    return Object.prototype.toString.call(value) === \"[object Function]\";\n}\n\n/**\n * Checks that the given object has the specified keys.\n * @param obj - The object to check.\n * @param keys - The list of keys that 'obj' must have.\n * @throws If the object is missing keys.\n */\n// note using 'keys' here would shadow the 'keys' function defined above\nexport function checkObjectHasKeys(obj: object, keys: string[]): void {\n    for (const key of keys) {\n        if (!obj.hasOwnProperty(key)) {\n            throw new Error(\"Missing required key: \" + key);\n        }\n    }\n}\n\n/**\n * Deep copy the given object. The object MUST NOT have circular references and\n * MUST NOT have functions.\n * @param obj - The object to deep copy.\n * @returns A copy of the object without any references to the original.\n */\nexport function deepCopy<T>(obj: T): T {\n    return JSON.parse(JSON.stringify(obj));\n}\n\n/**\n * Compare two objects for equality. The objects MUST NOT have circular references.\n *\n * @param x - The first object to compare.\n * @param y - The second object to compare.\n *\n * @returns true if the two objects are equal\n */\nexport function deepCompare(x: any, y: any): boolean {\n    // Inspired by\n    // http://stackoverflow.com/questions/1068834/object-comparison-in-javascript#1144249\n\n    // Compare primitives and functions.\n    // Also check if both arguments link to the same object.\n    if (x === y) {\n        return true;\n    }\n\n    if (typeof x !== typeof y) {\n        return false;\n    }\n\n    // special-case NaN (since NaN !== NaN)\n    if (typeof x === \"number\" && isNaN(x) && isNaN(y)) {\n        return true;\n    }\n\n    // special-case null (since typeof null == 'object', but null.constructor\n    // throws)\n    if (x === null || y === null) {\n        return x === y;\n    }\n\n    // everything else is either an unequal primitive, or an object\n    if (!(x instanceof Object)) {\n        return false;\n    }\n\n    // check they are the same type of object\n    if (x.constructor !== y.constructor || x.prototype !== y.prototype) {\n        return false;\n    }\n\n    // special-casing for some special types of object\n    if (x instanceof RegExp || x instanceof Date) {\n        return x.toString() === y.toString();\n    }\n\n    // the object algorithm works for Array, but it's sub-optimal.\n    if (Array.isArray(x)) {\n        if (x.length !== y.length) {\n            return false;\n        }\n\n        for (let i = 0; i < x.length; i++) {\n            if (!deepCompare(x[i], y[i])) {\n                return false;\n            }\n        }\n    } else {\n        // check that all of y's direct keys are in x\n        for (const p in y) {\n            if (y.hasOwnProperty(p) !== x.hasOwnProperty(p)) {\n                return false;\n            }\n        }\n\n        // finally, compare each of x's keys with y\n        for (const p in x) {\n            if (y.hasOwnProperty(p) !== x.hasOwnProperty(p) || !deepCompare(x[p], y[p])) {\n                return false;\n            }\n        }\n    }\n    return true;\n}\n\n// Dev note: This returns an array of tuples, but jsdoc doesn't like that. https://github.com/jsdoc/jsdoc/issues/1703\n/**\n * Creates an array of object properties/values (entries) then\n * sorts the result by key, recursively. The input object must\n * ensure it does not have loops. If the input is not an object\n * then it will be returned as-is.\n * @param obj - The object to get entries of\n * @returns The entries, sorted by key.\n */\nexport function deepSortedObjectEntries(obj: any): [string, any][] {\n    if (typeof obj !== \"object\") return obj;\n\n    // Apparently these are object types...\n    if (obj === null || obj === undefined || Array.isArray(obj)) return obj;\n\n    const pairs: [string, any][] = [];\n    for (const [k, v] of Object.entries(obj)) {\n        pairs.push([k, deepSortedObjectEntries(v)]);\n    }\n\n    // lexicographicCompare is faster than localeCompare, so let's use that.\n    pairs.sort((a, b) => lexicographicCompare(a[0], b[0]));\n\n    return pairs;\n}\n\n/**\n * Returns whether the given value is a finite number without type-coercion\n *\n * @param value - the value to test\n * @returns whether or not value is a finite number without type-coercion\n */\nexport function isNumber(value: any): value is number {\n    return typeof value === \"number\" && isFinite(value);\n}\n\n/**\n * Removes zero width chars, diacritics and whitespace from the string\n * Also applies an unhomoglyph on the string, to prevent similar looking chars\n * @param str - the string to remove hidden characters from\n * @returns a string with the hidden characters removed\n */\nexport function removeHiddenChars(str: string): string {\n    if (typeof str === \"string\") {\n        return unhomoglyph(str.normalize(\"NFD\").replace(removeHiddenCharsRegex, \"\"));\n    }\n    return \"\";\n}\n\n/**\n * Removes the direction override characters from a string\n * @returns string with chars removed\n */\nexport function removeDirectionOverrideChars(str: string): string {\n    if (typeof str === \"string\") {\n        return str.replace(/[\\u202d-\\u202e]/g, \"\");\n    }\n    return \"\";\n}\n\nexport function normalize(str: string): string {\n    // Note: we have to match the filter with the removeHiddenChars() because the\n    // function strips spaces and other characters (M becomes RN for example, in lowercase).\n    return (\n        removeHiddenChars(str.toLowerCase())\n            // Strip all punctuation\n            .replace(/[\\\\'!\"#$%&()*+,\\-./:;<=>?@[\\]^_`{|}~\\u2000-\\u206f\\u2e00-\\u2e7f]/g, \"\")\n            // We also doubly convert to lowercase to work around oddities of the library.\n            .toLowerCase()\n    );\n}\n\n// Regex matching bunch of unicode control characters and otherwise misleading/invisible characters.\n// Includes:\n// various width spaces U+2000 - U+200D\n// LTR and RTL marks U+200E and U+200F\n// LTR/RTL and other directional formatting marks U+202A - U+202F\n// Arabic Letter RTL mark U+061C\n// Combining characters U+0300 - U+036F\n// Zero width no-break space (BOM) U+FEFF\n// Blank/invisible characters (U2800, U2062-U2063)\n// eslint-disable-next-line no-misleading-character-class\nconst removeHiddenCharsRegex = /[\\u2000-\\u200F\\u202A-\\u202F\\u0300-\\u036F\\uFEFF\\u061C\\u2800\\u2062-\\u2063\\s]/g;\n\nexport function escapeRegExp(string: string): string {\n    return string.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Converts Matrix glob-style string to a regular expression\n * https://spec.matrix.org/v1.7/appendices/#glob-style-matching\n * @param glob - Matrix glob-style string\n * @returns regular expression\n */\nexport function globToRegexp(glob: string): string {\n    return escapeRegExp(glob).replace(/\\\\\\*/g, \".*\").replace(/\\?/g, \".\");\n}\n\nexport function ensureNoTrailingSlash(url: string): string;\nexport function ensureNoTrailingSlash(url: undefined): undefined;\nexport function ensureNoTrailingSlash(url?: string): string | undefined;\nexport function ensureNoTrailingSlash(url?: string): string | undefined {\n    if (url?.endsWith(\"/\")) {\n        return url.slice(0, -1);\n    } else {\n        return url;\n    }\n}\n\n/**\n * Returns a promise which resolves with a given value after the given number of ms\n */\nexport function sleep<T>(ms: number, value?: T): Promise<T> {\n    return new Promise((resolve) => {\n        setTimeout(resolve, ms, value);\n    });\n}\n\n/**\n * Utility to log the duration of a promise.\n *\n * @param logger - The logger to log to.\n * @param name - The name of the operation.\n * @param block - The block to execute.\n */\nexport async function logDuration<T>(logger: BaseLogger, name: string, block: () => Promise<T>): Promise<T> {\n    const start = Date.now();\n    try {\n        return await block();\n    } finally {\n        const end = Date.now();\n        logger.debug(`[Perf]: ${name} took ${end - start}ms`);\n    }\n}\n\n/**\n * Promise/async version of {@link setImmediate}.\n *\n * Implementation is based on `setTimeout` for wider compatibility.\n * @deprecated Use {@link sleep} instead.\n */\nexport function immediate(): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve));\n}\n\nexport function isNullOrUndefined(val: any): boolean {\n    return val === null || val === undefined;\n}\n\nexport interface IDeferred<T> {\n    resolve: (value: T | Promise<T>) => void;\n    reject: (reason?: any) => void;\n    promise: Promise<T>;\n}\n\n// Returns a Deferred\nexport function defer<T = void>(): IDeferred<T> {\n    let resolve!: IDeferred<T>[\"resolve\"];\n    let reject!: IDeferred<T>[\"reject\"];\n\n    const promise = new Promise<T>((_resolve, _reject) => {\n        resolve = _resolve;\n        reject = _reject;\n    });\n\n    return { resolve, reject, promise };\n}\n\nexport async function promiseMapSeries<T>(\n    promises: Array<T | Promise<T>>,\n    fn: (t: T) => Promise<unknown> | undefined, // if async we don't care about the type as we only await resolution\n): Promise<void> {\n    for (const o of promises) {\n        await fn(await o);\n    }\n}\n\nexport function promiseTry<T>(fn: () => T | Promise<T>): Promise<T> {\n    return Promise.resolve(fn());\n}\n\n// Creates and awaits all promises, running no more than `chunkSize` at the same time\nexport async function chunkPromises<T>(fns: (() => Promise<T>)[], chunkSize: number): Promise<T[]> {\n    const results: T[] = [];\n    for (let i = 0; i < fns.length; i += chunkSize) {\n        results.push(...(await Promise.all(fns.slice(i, i + chunkSize).map((fn) => fn()))));\n    }\n    return results;\n}\n\n/**\n * Retries the function until it succeeds or is interrupted. The given function must return\n * a promise which throws/rejects on error, otherwise the retry will assume the request\n * succeeded. The promise chain returned will contain the successful promise. The given function\n * should always return a new promise.\n * @param promiseFn - The function to call to get a fresh promise instance. Takes an\n * attempt count as an argument, for logging/debugging purposes.\n * @returns The promise for the retried operation.\n */\nexport function simpleRetryOperation<T>(promiseFn: (attempt: number) => Promise<T>): Promise<T> {\n    return promiseRetry(\n        (attempt: number) => {\n            return promiseFn(attempt);\n        },\n        {\n            forever: true,\n            factor: 2,\n            minTimeout: 3000, // ms\n            maxTimeout: 15000, // ms\n        },\n    );\n}\n\n// String averaging inspired by https://stackoverflow.com/a/2510816\n// Dev note: We make the alphabet a string because it's easier to write syntactically\n// than arrays. Thankfully, strings implement the useful parts of the Array interface\n// anyhow.\n\n/**\n * The default alphabet used by string averaging in this SDK. This matches\n * all usefully printable ASCII characters (0x20-0x7E, inclusive).\n */\nexport const DEFAULT_ALPHABET = ((): string => {\n    let str = \"\";\n    for (let c = 0x20; c <= 0x7e; c++) {\n        str += String.fromCharCode(c);\n    }\n    return str;\n})();\n\n/**\n * Pads a string using the given alphabet as a base. The returned string will be\n * padded at the end with the first character in the alphabet.\n *\n * This is intended for use with string averaging.\n * @param s - The string to pad.\n * @param n - The length to pad to.\n * @param alphabet - The alphabet to use as a single string.\n * @returns The padded string.\n */\nexport function alphabetPad(s: string, n: number, alphabet = DEFAULT_ALPHABET): string {\n    return s.padEnd(n, alphabet[0]);\n}\n\n/**\n * Converts a baseN number to a string, where N is the alphabet's length.\n *\n * This is intended for use with string averaging.\n * @param n - The baseN number.\n * @param alphabet - The alphabet to use as a single string.\n * @returns The baseN number encoded as a string from the alphabet.\n */\nexport function baseToString(n: bigint, alphabet = DEFAULT_ALPHABET): string {\n    // Developer note: the stringToBase() function offsets the character set by 1 so that repeated\n    // characters (ie: \"aaaaaa\" in a..z) don't come out as zero. We have to reverse this here as\n    // otherwise we'll be wrong in our conversion. Undoing a +1 before an exponent isn't very fun\n    // though, so we rely on a lengthy amount of `x - 1` and integer division rules to reach a\n    // sane state. This also means we have to do rollover detection: see below.\n\n    const len = BigInt(alphabet.length);\n    if (n <= len) {\n        return alphabet[Number(n) - 1] ?? \"\";\n    }\n\n    let d = n / len;\n    let r = Number(n % len) - 1;\n\n    // Rollover detection: if the remainder is negative, it means that the string needs\n    // to roll over by 1 character downwards (ie: in a..z, the previous to \"aaa\" would be\n    // \"zz\").\n    if (r < 0) {\n        d -= BigInt(Math.abs(r)); // abs() is just to be clear what we're doing. Could also `+= r`.\n        r = Number(len) - 1;\n    }\n\n    return baseToString(d, alphabet) + alphabet[r];\n}\n\n/**\n * Converts a string to a baseN number, where N is the alphabet's length.\n *\n * This is intended for use with string averaging.\n * @param s - The string to convert to a number.\n * @param alphabet - The alphabet to use as a single string.\n * @returns The baseN number.\n */\nexport function stringToBase(s: string, alphabet = DEFAULT_ALPHABET): bigint {\n    const len = BigInt(alphabet.length);\n\n    // In our conversion to baseN we do a couple performance optimizations to avoid using\n    // excess CPU and such. To create baseN numbers, the input string needs to be reversed\n    // so the exponents stack up appropriately, as the last character in the unreversed\n    // string has less impact than the first character (in \"abc\" the A is a lot more important\n    // for lexicographic sorts). We also do a trick with the character codes to optimize the\n    // alphabet lookup, avoiding an index scan of `alphabet.indexOf(reversedStr[i])` - we know\n    // that the alphabet and (theoretically) the input string are constrained on character sets\n    // and thus can do simple subtraction to end up with the same result.\n\n    // Developer caution: we carefully cast to BigInt here to avoid losing precision. We cannot\n    // rely on Math.pow() (for example) to be capable of handling our insane numbers.\n\n    let result = BigInt(0);\n    for (let i = s.length - 1, j = BigInt(0); i >= 0; i--, j++) {\n        const charIndex = s.charCodeAt(i) - alphabet.charCodeAt(0);\n\n        // We add 1 to the char index to offset the whole numbering scheme. We unpack this in\n        // the baseToString() function.\n        result += BigInt(1 + charIndex) * len ** j;\n    }\n    return result;\n}\n\n/**\n * Averages two strings, returning the midpoint between them. This is accomplished by\n * converting both to baseN numbers (where N is the alphabet's length) then averaging\n * those before re-encoding as a string.\n * @param a - The first string.\n * @param b - The second string.\n * @param alphabet - The alphabet to use as a single string.\n * @returns The midpoint between the strings, as a string.\n */\nexport function averageBetweenStrings(a: string, b: string, alphabet = DEFAULT_ALPHABET): string {\n    const padN = Math.max(a.length, b.length);\n    const baseA = stringToBase(alphabetPad(a, padN, alphabet), alphabet);\n    const baseB = stringToBase(alphabetPad(b, padN, alphabet), alphabet);\n    const avg = (baseA + baseB) / BigInt(2);\n\n    // Detect integer division conflicts. This happens when two numbers are divided too close so\n    // we lose a .5 precision. We need to add a padding character in these cases.\n    if (avg === baseA || avg == baseB) {\n        return baseToString(avg, alphabet) + alphabet[0];\n    }\n\n    return baseToString(avg, alphabet);\n}\n\n/**\n * Finds the next string using the alphabet provided. This is done by converting the\n * string to a baseN number, where N is the alphabet's length, then adding 1 before\n * converting back to a string.\n * @param s - The string to start at.\n * @param alphabet - The alphabet to use as a single string.\n * @returns The string which follows the input string.\n */\nexport function nextString(s: string, alphabet = DEFAULT_ALPHABET): string {\n    return baseToString(stringToBase(s, alphabet) + BigInt(1), alphabet);\n}\n\n/**\n * Finds the previous string using the alphabet provided. This is done by converting the\n * string to a baseN number, where N is the alphabet's length, then subtracting 1 before\n * converting back to a string.\n * @param s - The string to start at.\n * @param alphabet - The alphabet to use as a single string.\n * @returns The string which precedes the input string.\n */\nexport function prevString(s: string, alphabet = DEFAULT_ALPHABET): string {\n    return baseToString(stringToBase(s, alphabet) - BigInt(1), alphabet);\n}\n\n/**\n * Compares strings lexicographically as a sort-safe function.\n * @param a - The first (reference) string.\n * @param b - The second (compare) string.\n * @returns Negative if the reference string is before the compare string;\n * positive if the reference string is after; and zero if equal.\n */\nexport function lexicographicCompare(a: string, b: string): number {\n    // Dev note: this exists because I'm sad that you can use math operators on strings, so I've\n    // hidden the operation in this function.\n    if (a < b) {\n        return -1;\n    } else if (a > b) {\n        return 1;\n    } else {\n        return 0;\n    }\n}\n\n/**\n * This function is similar to Object.assign() but it assigns recursively and\n * allows you to ignore nullish values from the source\n *\n * @returns the target object\n */\nexport function recursivelyAssign<T1 extends T2, T2 extends Record<string, any>>(\n    target: T1,\n    source: T2,\n    ignoreNullish = false,\n): T1 & T2 {\n    for (const [sourceKey, sourceValue] of Object.entries(source)) {\n        if (target[sourceKey] instanceof Object && sourceValue) {\n            recursivelyAssign(target[sourceKey], sourceValue);\n            continue;\n        }\n        if ((sourceValue !== null && sourceValue !== undefined) || !ignoreNullish) {\n            safeSet(target, sourceKey, sourceValue);\n            continue;\n        }\n    }\n    return target as T1 & T2;\n}\n\nfunction getContentTimestampWithFallback(event: MatrixEvent): number {\n    return M_TIMESTAMP.findIn<number>(event.getContent()) ?? -1;\n}\n\n/**\n * Sort events by their content m.ts property\n * Latest timestamp first\n */\nexport function sortEventsByLatestContentTimestamp(left: MatrixEvent, right: MatrixEvent): number {\n    return getContentTimestampWithFallback(right) - getContentTimestampWithFallback(left);\n}\n\nexport function isSupportedReceiptType(receiptType: string): boolean {\n    return [ReceiptType.Read, ReceiptType.ReadPrivate].includes(receiptType as ReceiptType);\n}\n\n/**\n * Determines whether two maps are equal.\n * @param eq - The equivalence relation to compare values by. Defaults to strict equality.\n */\nexport function mapsEqual<K, V>(x: Map<K, V>, y: Map<K, V>, eq = (v1: V, v2: V): boolean => v1 === v2): boolean {\n    if (x.size !== y.size) return false;\n    for (const [k, v1] of x) {\n        const v2 = y.get(k);\n        if (v2 === undefined || !eq(v1, v2)) return false;\n    }\n    return true;\n}\n\nfunction processMapToObjectValue(value: any): any {\n    if (value instanceof Map) {\n        // Value is a Map. Recursively map it to an object.\n        return recursiveMapToObject(value);\n    } else if (Array.isArray(value)) {\n        // Value is an Array. Recursively map the value (e.g. to cover Array of Arrays).\n        return value.map((v) => processMapToObjectValue(v));\n    } else {\n        return value;\n    }\n}\n\n/**\n * Recursively converts Maps to plain objects.\n * Also supports sub-lists of Maps.\n */\nexport function recursiveMapToObject(map: Map<any, any>): Record<any, any> {\n    const targetMap = new Map();\n\n    for (const [key, value] of map) {\n        targetMap.set(key, processMapToObjectValue(value));\n    }\n\n    return Object.fromEntries(targetMap.entries());\n}\n\nexport function unsafeProp<K extends keyof any | undefined>(prop: K): boolean {\n    return prop === \"__proto__\" || prop === \"prototype\" || prop === \"constructor\";\n}\n\nexport function safeSet<O extends Record<any, any>, K extends keyof O>(obj: O, prop: K, value: O[K]): void {\n    if (unsafeProp(prop)) {\n        throw new Error(\"Trying to modify prototype or constructor\");\n    }\n\n    obj[prop] = value;\n}\n\nexport function noUnsafeEventProps(event: Partial<IEvent>): boolean {\n    return !(unsafeProp(event.room_id) || unsafeProp(event.sender) || unsafeProp(event.event_id));\n}\n\nexport class MapWithDefault<K, V> extends Map<K, V> {\n    public constructor(private createDefault: () => V) {\n        super();\n    }\n\n    /**\n     * Returns the value if the key already exists.\n     * If not, it creates a new value under that key using the ctor callback and returns it.\n     */\n    public getOrCreate(key: K): V {\n        if (!this.has(key)) {\n            this.set(key, this.createDefault());\n        }\n\n        return this.get(key)!;\n    }\n}\n","'use strict';\nconst retry = require('retry');\n\nconst networkErrorMsgs = [\n\t'Failed to fetch', // Chrome\n\t'NetworkError when attempting to fetch resource.', // Firefox\n\t'The Internet connection appears to be offline.', // Safari\n\t'Network request failed' // `cross-fetch`\n];\n\nclass AbortError extends Error {\n\tconstructor(message) {\n\t\tsuper();\n\n\t\tif (message instanceof Error) {\n\t\t\tthis.originalError = message;\n\t\t\t({message} = message);\n\t\t} else {\n\t\t\tthis.originalError = new Error(message);\n\t\t\tthis.originalError.stack = this.stack;\n\t\t}\n\n\t\tthis.name = 'AbortError';\n\t\tthis.message = message;\n\t}\n}\n\nconst decorateErrorWithCounts = (error, attemptNumber, options) => {\n\t// Minus 1 from attemptNumber because the first attempt does not count as a retry\n\tconst retriesLeft = options.retries - (attemptNumber - 1);\n\n\terror.attemptNumber = attemptNumber;\n\terror.retriesLeft = retriesLeft;\n\treturn error;\n};\n\nconst isNetworkError = errorMessage => networkErrorMsgs.includes(errorMessage);\n\nconst pRetry = (input, options) => new Promise((resolve, reject) => {\n\toptions = {\n\t\tonFailedAttempt: () => {},\n\t\tretries: 10,\n\t\t...options\n\t};\n\n\tconst operation = retry.operation(options);\n\n\toperation.attempt(async attemptNumber => {\n\t\ttry {\n\t\t\tresolve(await input(attemptNumber));\n\t\t} catch (error) {\n\t\t\tif (!(error instanceof Error)) {\n\t\t\t\treject(new TypeError(`Non-error was thrown: \"${error}\". You should only throw errors.`));\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif (error instanceof AbortError) {\n\t\t\t\toperation.stop();\n\t\t\t\treject(error.originalError);\n\t\t\t} else if (error instanceof TypeError && !isNetworkError(error.message)) {\n\t\t\t\toperation.stop();\n\t\t\t\treject(error);\n\t\t\t} else {\n\t\t\t\tdecorateErrorWithCounts(error, attemptNumber, options);\n\n\t\t\t\ttry {\n\t\t\t\t\tawait options.onFailedAttempt(error);\n\t\t\t\t} catch (error) {\n\t\t\t\t\treject(error);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (!operation.retry(error)) {\n\t\t\t\t\treject(operation.mainError());\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t});\n});\n\nmodule.exports = pRetry;\n// TODO: remove this in the next major version\nmodule.exports.default = pRetry;\n\nmodule.exports.AbortError = AbortError;\n","module.exports = require('./lib/retry');","var RetryOperation = require('./retry_operation');\n\nexports.operation = function(options) {\n  var timeouts = exports.timeouts(options);\n  return new RetryOperation(timeouts, {\n      forever: options && (options.forever || options.retries === Infinity),\n      unref: options && options.unref,\n      maxRetryTime: options && options.maxRetryTime\n  });\n};\n\nexports.timeouts = function(options) {\n  if (options instanceof Array) {\n    return [].concat(options);\n  }\n\n  var opts = {\n    retries: 10,\n    factor: 2,\n    minTimeout: 1 * 1000,\n    maxTimeout: Infinity,\n    randomize: false\n  };\n  for (var key in options) {\n    opts[key] = options[key];\n  }\n\n  if (opts.minTimeout > opts.maxTimeout) {\n    throw new Error('minTimeout is greater than maxTimeout');\n  }\n\n  var timeouts = [];\n  for (var i = 0; i < opts.retries; i++) {\n    timeouts.push(this.createTimeout(i, opts));\n  }\n\n  if (options && options.forever && !timeouts.length) {\n    timeouts.push(this.createTimeout(i, opts));\n  }\n\n  // sort the array numerically ascending\n  timeouts.sort(function(a,b) {\n    return a - b;\n  });\n\n  return timeouts;\n};\n\nexports.createTimeout = function(attempt, opts) {\n  var random = (opts.randomize)\n    ? (Math.random() + 1)\n    : 1;\n\n  var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));\n  timeout = Math.min(timeout, opts.maxTimeout);\n\n  return timeout;\n};\n\nexports.wrap = function(obj, options, methods) {\n  if (options instanceof Array) {\n    methods = options;\n    options = null;\n  }\n\n  if (!methods) {\n    methods = [];\n    for (var key in obj) {\n      if (typeof obj[key] === 'function') {\n        methods.push(key);\n      }\n    }\n  }\n\n  for (var i = 0; i < methods.length; i++) {\n    var method   = methods[i];\n    var original = obj[method];\n\n    obj[method] = function retryWrapper(original) {\n      var op       = exports.operation(options);\n      var args     = Array.prototype.slice.call(arguments, 1);\n      var callback = args.pop();\n\n      args.push(function(err) {\n        if (op.retry(err)) {\n          return;\n        }\n        if (err) {\n          arguments[0] = op.mainError();\n        }\n        callback.apply(this, arguments);\n      });\n\n      op.attempt(function() {\n        original.apply(obj, args);\n      });\n    }.bind(obj, original);\n    obj[method].options = options;\n  }\n};\n","function RetryOperation(timeouts, options) {\n  // Compatibility for the old (timeouts, retryForever) signature\n  if (typeof options === 'boolean') {\n    options = { forever: options };\n  }\n\n  this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));\n  this._timeouts = timeouts;\n  this._options = options || {};\n  this._maxRetryTime = options && options.maxRetryTime || Infinity;\n  this._fn = null;\n  this._errors = [];\n  this._attempts = 1;\n  this._operationTimeout = null;\n  this._operationTimeoutCb = null;\n  this._timeout = null;\n  this._operationStart = null;\n  this._timer = null;\n\n  if (this._options.forever) {\n    this._cachedTimeouts = this._timeouts.slice(0);\n  }\n}\nmodule.exports = RetryOperation;\n\nRetryOperation.prototype.reset = function() {\n  this._attempts = 1;\n  this._timeouts = this._originalTimeouts.slice(0);\n}\n\nRetryOperation.prototype.stop = function() {\n  if (this._timeout) {\n    clearTimeout(this._timeout);\n  }\n  if (this._timer) {\n    clearTimeout(this._timer);\n  }\n\n  this._timeouts       = [];\n  this._cachedTimeouts = null;\n};\n\nRetryOperation.prototype.retry = function(err) {\n  if (this._timeout) {\n    clearTimeout(this._timeout);\n  }\n\n  if (!err) {\n    return false;\n  }\n  var currentTime = new Date().getTime();\n  if (err && currentTime - this._operationStart >= this._maxRetryTime) {\n    this._errors.push(err);\n    this._errors.unshift(new Error('RetryOperation timeout occurred'));\n    return false;\n  }\n\n  this._errors.push(err);\n\n  var timeout = this._timeouts.shift();\n  if (timeout === undefined) {\n    if (this._cachedTimeouts) {\n      // retry forever, only keep last error\n      this._errors.splice(0, this._errors.length - 1);\n      timeout = this._cachedTimeouts.slice(-1);\n    } else {\n      return false;\n    }\n  }\n\n  var self = this;\n  this._timer = setTimeout(function() {\n    self._attempts++;\n\n    if (self._operationTimeoutCb) {\n      self._timeout = setTimeout(function() {\n        self._operationTimeoutCb(self._attempts);\n      }, self._operationTimeout);\n\n      if (self._options.unref) {\n          self._timeout.unref();\n      }\n    }\n\n    self._fn(self._attempts);\n  }, timeout);\n\n  if (this._options.unref) {\n      this._timer.unref();\n  }\n\n  return true;\n};\n\nRetryOperation.prototype.attempt = function(fn, timeoutOps) {\n  this._fn = fn;\n\n  if (timeoutOps) {\n    if (timeoutOps.timeout) {\n      this._operationTimeout = timeoutOps.timeout;\n    }\n    if (timeoutOps.cb) {\n      this._operationTimeoutCb = timeoutOps.cb;\n    }\n  }\n\n  var self = this;\n  if (this._operationTimeoutCb) {\n    this._timeout = setTimeout(function() {\n      self._operationTimeoutCb();\n    }, self._operationTimeout);\n  }\n\n  this._operationStart = new Date().getTime();\n\n  this._fn(this._attempts);\n};\n\nRetryOperation.prototype.try = function(fn) {\n  console.log('Using RetryOperation.try() is deprecated');\n  this.attempt(fn);\n};\n\nRetryOperation.prototype.start = function(fn) {\n  console.log('Using RetryOperation.start() is deprecated');\n  this.attempt(fn);\n};\n\nRetryOperation.prototype.start = RetryOperation.prototype.try;\n\nRetryOperation.prototype.errors = function() {\n  return this._errors;\n};\n\nRetryOperation.prototype.attempts = function() {\n  return this._attempts;\n};\n\nRetryOperation.prototype.mainError = function() {\n  if (this._errors.length === 0) {\n    return null;\n  }\n\n  var counts = {};\n  var mainError = null;\n  var mainErrorCount = 0;\n\n  for (var i = 0; i < this._errors.length; i++) {\n    var error = this._errors[i];\n    var message = error.message;\n    var count = (counts[message] || 0) + 1;\n\n    counts[message] = count;\n\n    if (count >= mainErrorCount) {\n      mainError = error;\n      mainErrorCount = count;\n    }\n  }\n\n  return mainError;\n};\n","'use strict';\n\n\nvar data = require('./data.json');\n\nfunction escapeRegexp(str) {\n  return str.replace(/([.?*+^$[\\]\\\\(){}|-])/g, '\\\\$1');\n}\n\nvar REPLACE_RE = RegExp(Object.keys(data).map(escapeRegexp).join('|'), 'g');\n\nfunction replace_fn(match) {\n  return data[match];\n}\n\nfunction unhomoglyph(str) {\n  return str.replace(REPLACE_RE, replace_fn);\n}\n\nmodule.exports = unhomoglyph;\n","/*\nCopyright 2024 New Vector Ltd.\nCopyright 2020 The Matrix.org Foundation C.I.C.\nCopyright 2019 Michael Telatynski <7t3chguy@gmail.com>\nCopyright 2018, 2019 New Vector Ltd\nCopyright 2017 Vector Creations Ltd\nCopyright 2015, 2016 OpenMarket Ltd\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport { logger } from \"matrix-js-sdk/src/logger\";\nimport { shouldPolyfill as shouldPolyFillIntlSegmenter } from \"@formatjs/intl-segmenter/should-polyfill\";\n\n// These are things that can run before the skin loads - be careful not to reference the react-sdk though.\nimport { parseQsFromFragment } from \"./url_utils\";\nimport \"./modernizr\";\n\n// Require common CSS here; this will make webpack process it into bundle.css.\n// Our own CSS (which is themed) is imported via separate webpack entry points\n// in webpack.config.js\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nrequire(\"katex/dist/katex.css\");\n\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nrequire(\"./localstorage-fix\");\n\nasync function settled(...promises: Array<Promise<any>>): Promise<void> {\n    for (const prom of promises) {\n        try {\n            await prom;\n        } catch (e) {\n            logger.error(e);\n        }\n    }\n}\n\nfunction checkBrowserFeatures(): boolean {\n    if (!window.Modernizr) {\n        logger.error(\"Cannot check features - Modernizr global is missing.\");\n        return false;\n    }\n\n    // Custom checks atop Modernizr because it doesn't have checks in it for\n    // some features we depend on.\n    // Modernizr requires rules to be lowercase with no punctuation.\n    // ES2018: http://262.ecma-international.org/9.0/#sec-promise.prototype.finally\n    window.Modernizr.addTest(\"promiseprototypefinally\", () => typeof window.Promise?.prototype?.finally === \"function\");\n    // ES2020: http://262.ecma-international.org/#sec-promise.allsettled\n    window.Modernizr.addTest(\"promiseallsettled\", () => typeof window.Promise?.allSettled === \"function\");\n    // ES2018: https://262.ecma-international.org/9.0/#sec-get-regexp.prototype.dotAll\n    window.Modernizr.addTest(\n        \"regexpdotall\",\n        () => window.RegExp?.prototype && !!Object.getOwnPropertyDescriptor(window.RegExp.prototype, \"dotAll\")?.get,\n    );\n    // ES2019: http://262.ecma-international.org/10.0/#sec-object.fromentries\n    window.Modernizr.addTest(\"objectfromentries\", () => typeof window.Object?.fromEntries === \"function\");\n    // ES2024: https://402.ecma-international.org/9.0/#sec-intl.segmenter\n    // The built-in modernizer 'intl' check only checks for the presence of the Intl object, not the Segmenter,\n    // and older Firefox has the former but not the latter, so we add our own.\n    // This is polyfilled now, but we still want to show the warning because we want to remove the polyfill\n    // at some point.\n    window.Modernizr.addTest(\"intlsegmenter\", () => typeof window.Intl?.Segmenter === \"function\");\n\n    // Basic test for WebAssembly support. We could also try instantiating a simple module,\n    // although this would start to make (more) assumptions about how rust-crypto loads its wasm.\n    window.Modernizr.addTest(\"wasm\", () => typeof WebAssembly === \"object\" && typeof WebAssembly.Module === \"function\");\n\n    // Check that the session is in a secure context otherwise most Crypto & WebRTC APIs will be unavailable\n    // https://developer.mozilla.org/en-US/docs/Web/API/Window/isSecureContext\n    window.Modernizr.addTest(\"securecontext\", () => window.isSecureContext);\n\n    const featureList = Object.keys(window.Modernizr) as Array<keyof ModernizrStatic>;\n\n    let featureComplete = true;\n    for (const feature of featureList) {\n        if (window.Modernizr[feature] === undefined) {\n            logger.error(\n                \"Looked for feature '%s' but Modernizr has no results for this. \" + \"Has it been configured correctly?\",\n                feature,\n            );\n            return false;\n        }\n        if (window.Modernizr[feature] === false) {\n            logger.error(\"Browser missing feature: '%s'\", feature);\n            // toggle flag rather than return early so we log all missing features rather than just the first.\n            featureComplete = false;\n        }\n    }\n    return featureComplete;\n}\n\nconst supportedBrowser = checkBrowserFeatures();\n\n// React depends on Map & Set which we check for using modernizr's es6collections\n// if modernizr fails we may not have a functional react to show the error message.\n// try in react but fallback to an `alert`\n// We start loading stuff but don't block on it until as late as possible to allow\n// the browser to use as much parallelism as it can.\n// Load parallelism is based on research in https://github.com/element-hq/element-web/issues/12253\nasync function start(): Promise<void> {\n    if (shouldPolyFillIntlSegmenter()) {\n        await import(/* webpackChunkName: \"intl-segmenter-polyfill\" */ \"@formatjs/intl-segmenter/polyfill-force\");\n    }\n\n    // load init.ts async so that its code is not executed immediately and we can catch any exceptions\n    const {\n        rageshakePromise,\n        setupLogStorage,\n        preparePlatform,\n        loadConfig,\n        loadLanguage,\n        loadTheme,\n        loadApp,\n        loadModules,\n        loadPlugins,\n        showError,\n        showIncompatibleBrowser,\n        _t,\n        extractErrorMessageFromError,\n    } = await import(\n        /* webpackChunkName: \"init\" */\n        /* webpackPreload: true */\n        \"./init\"\n    );\n\n    // Now perform the next stage of initialisation. This has its own try/catch in which we render\n    // a react error page on failure.\n    try {\n        // give rageshake a chance to load/fail, we don't actually assert rageshake loads, we allow it to fail if no IDB\n        await settled(rageshakePromise);\n\n        const fragparts = parseQsFromFragment(window.location);\n\n        // don't try to redirect to the native apps if we're\n        // verifying a 3pid (but after we've loaded the config)\n        // or if the user is following a deep link\n        // (https://github.com/element-hq/element-web/issues/7378)\n        const preventRedirect = fragparts.params.client_secret || fragparts.location.length > 0;\n\n        if (!preventRedirect) {\n            const isIos = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;\n            const isAndroid = /Android/.test(navigator.userAgent);\n            if (isIos || isAndroid) {\n                if (document.cookie.indexOf(\"element_mobile_redirect_to_guide=false\") === -1) {\n                    window.location.href = \"mobile_guide/\";\n                    return;\n                }\n            }\n        }\n\n        // set the platform for react sdk\n        preparePlatform();\n        // load config requires the platform to be ready\n        const loadConfigPromise = loadConfig();\n        await settled(loadConfigPromise); // wait for it to settle\n        // keep initialising so that we can show any possible error with as many features (theme, i18n) as possible\n\n        // now that the config is ready, try to persist logs\n        const persistLogsPromise = setupLogStorage();\n\n        // Load modules & plugins before language to ensure any custom translations are respected, and any app\n        // startup functionality is run\n        const loadModulesPromise = loadModules();\n        await settled(loadModulesPromise);\n        const loadPluginsPromise = loadPlugins();\n        await settled(loadPluginsPromise);\n\n        // Load language after loading config.json so that settingsDefaults.language can be applied\n        const loadLanguagePromise = loadLanguage();\n        // as quickly as we possibly can, set a default theme...\n        const loadThemePromise = loadTheme();\n\n        // await things settling so that any errors we have to render have features like i18n running\n        await settled(loadThemePromise, loadLanguagePromise);\n\n        let acceptBrowser = supportedBrowser;\n        if (!acceptBrowser && window.localStorage) {\n            acceptBrowser = Boolean(window.localStorage.getItem(\"mx_accepts_unsupported_browser\"));\n        }\n\n        // ##########################\n        // error handling begins here\n        // ##########################\n        if (!acceptBrowser) {\n            await new Promise<void>((resolve, reject) => {\n                logger.error(\"Browser is missing required features.\");\n                // take to a different landing page to AWOOOOOGA at the user\n                showIncompatibleBrowser(() => {\n                    if (window.localStorage) {\n                        window.localStorage.setItem(\"mx_accepts_unsupported_browser\", String(true));\n                    }\n                    logger.log(\"User accepts the compatibility risks.\");\n                    resolve();\n                }).catch(reject);\n            });\n        }\n\n        try {\n            // await config here\n            await loadConfigPromise;\n        } catch (error) {\n            // Now that we've loaded the theme (CSS), display the config syntax error if needed.\n            if (error instanceof SyntaxError) {\n                // This uses the default brand since the app config is unavailable.\n                return showError(_t(\"error|misconfigured\"), [\n                    _t(\"error|invalid_json\"),\n                    _t(\"error|invalid_json_detail\", {\n                        message: error.message || _t(\"error|invalid_json_generic\"),\n                    }),\n                ]);\n            }\n            return showError(_t(\"error|cannot_load_config\"));\n        }\n\n        // ##################################\n        // app load critical path starts here\n        // assert things started successfully\n        // ##################################\n        await loadPluginsPromise;\n        await loadModulesPromise;\n        await loadThemePromise;\n        await loadLanguagePromise;\n\n        // We don't care if the log persistence made it through successfully, but we do want to\n        // make sure it had a chance to load before we move on. It's prepared much higher up in\n        // the process, making this the first time we check that it did something.\n        await settled(persistLogsPromise);\n\n        // Finally, load the app. All of the other react-sdk imports are in this file which causes the skinner to\n        // run on the components.\n        await loadApp(fragparts.params);\n    } catch (err) {\n        logger.error(err);\n        // Like the compatibility page, AWOOOOOGA at the user\n        // This uses the default brand since the app config is unavailable.\n        await showError(_t(\"error|misconfigured\"), [\n            extractErrorMessageFromError(err, _t(\"error|app_launch_unexpected_error\")),\n        ]);\n    }\n}\n\nstart().catch((err) => {\n    // If we get here, things have gone terribly wrong and we cannot load the app javascript at all.\n    // Show a different, very simple iframed-static error page. Or actually, one of two different ones\n    // depending on whether the browser is supported (ie. we think we should be able to load but\n    // failed) or unsupported (where we tried anyway and, lo and behold, we failed).\n    logger.error(err);\n    // show the static error in an iframe to not lose any context / console data\n    // with some basic styling to make the iframe full page\n    document.body.style.removeProperty(\"height\");\n    const iframe = document.createElement(\"iframe\");\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore - typescript seems to only like the IE syntax for iframe sandboxing\n    iframe[\"sandbox\"] = \"\";\n    iframe.src = supportedBrowser ? \"static/unable-to-load.html\" : \"static/incompatible-browser.html\";\n    iframe.style.width = \"100%\";\n    iframe.style.height = \"100%\";\n    iframe.style.position = \"absolute\";\n    iframe.style.top = \"0\";\n    iframe.style.left = \"0\";\n    iframe.style.right = \"0\";\n    iframe.style.bottom = \"0\";\n    iframe.style.border = \"0\";\n    document.getElementById(\"matrixchat\")?.appendChild(iframe);\n});\n","/*\nCopyright 2024 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\n/**\n * Because we've been saving a lot of additional logger data in the localStorage for no particular reason\n * we need to, hopefully, unbrick user's devices by geting rid of unnecessary data.\n * */\n\nif (window.localStorage) {\n    Object.keys(window.localStorage).forEach((key) => {\n        if (key.startsWith(\"loglevel:\")) {\n            window.localStorage.removeItem(key);\n        }\n    });\n}\n","/*!\n * modernizr v3.13.0\n * Build https://modernizr.com/download?-cors-cryptography-cssanimations-cssfilters-displaytable-es5date-es5function-es5object-es5undefined-es6array-es6collections-es6string-fetch-flexbox-json-localstorage-objectfit-promises-resizeobserver-sandbox-svg-svgasimg-svgfilters-urlparser-urlsearchparams-webaudio-dontmin\n *\n * Copyright (c)\n *  Faruk Ates\n *  Paul Irish\n *  Alex Sexton\n *  Ryan Seddon\n *  Patrick Kettner\n *  Stu Cox\n *  Richard Herrera\n *  Veeck\n\n * MIT License\n */\n\n/*\n * Modernizr tests which native CSS3 and HTML5 features are available in the\n * current UA and makes the results available to you in two ways: as properties on\n * a global `Modernizr` object, and as classes on the `<html>` element. This\n * information allows you to progressively enhance your pages with a granular level\n * of control over the experience.\n*/\n\n;(function(scriptGlobalObject, window, document, undefined){\n\n  var tests = [];\n  \n\n  /**\n   * ModernizrProto is the constructor for Modernizr\n   *\n   * @class\n   * @access public\n   */\n  var ModernizrProto = {\n    _version: '3.13.0',\n\n    // Any settings that don't work as separate modules\n    // can go in here as configuration.\n    _config: {\n      'classPrefix': '',\n      'enableClasses': false,\n      'enableJSClass': true,\n      'usePrefixes': true\n    },\n\n    // Queue of tests\n    _q: [],\n\n    // Stub these for people who are listening\n    on: function(test, cb) {\n      // I don't really think people should do this, but we can\n      // safe guard it a bit.\n      // -- NOTE:: this gets WAY overridden in src/addTest for actual async tests.\n      // This is in case people listen to synchronous tests. I would leave it out,\n      // but the code to *disallow* sync tests in the real version of this\n      // function is actually larger than this.\n      var self = this;\n      setTimeout(function() {\n        cb(self[test]);\n      }, 0);\n    },\n\n    addTest: function(name, fn, options) {\n      tests.push({name: name, fn: fn, options: options});\n    },\n\n    addAsyncTest: function(fn) {\n      tests.push({name: null, fn: fn});\n    }\n  };\n\n  \n\n  // Fake some of Object.create so we can force non test results to be non \"own\" properties.\n  var Modernizr = function() {};\n  Modernizr.prototype = ModernizrProto;\n\n  // Leak modernizr globally when you `require` it rather than force it here.\n  // Overwrite name so constructor name is nicer :D\n  Modernizr = new Modernizr();\n\n  \n\n  var classes = [];\n  \n\n  /**\n   * is returns a boolean if the typeof an obj is exactly type.\n   *\n   * @access private\n   * @function is\n   * @param {*} obj - A thing we want to check the type of\n   * @param {string} type - A string to compare the typeof against\n   * @returns {boolean} true if the typeof the first parameter is exactly the specified type, false otherwise\n   */\n  function is(obj, type) {\n    return typeof obj === type;\n  }\n\n  ;\n\n  /**\n   * Run through all tests and detect their support in the current UA.\n   *\n   * @access private\n   * @returns {void}\n   */\n  function testRunner() {\n    var featureNames;\n    var feature;\n    var aliasIdx;\n    var result;\n    var nameIdx;\n    var featureName;\n    var featureNameSplit;\n\n    for (var featureIdx in tests) {\n      if (tests.hasOwnProperty(featureIdx)) {\n        featureNames = [];\n        feature = tests[featureIdx];\n        // run the test, throw the return value into the Modernizr,\n        // then based on that boolean, define an appropriate className\n        // and push it into an array of classes we'll join later.\n        //\n        // If there is no name, it's an 'async' test that is run,\n        // but not directly added to the object. That should\n        // be done with a post-run addTest call.\n        if (feature.name) {\n          featureNames.push(feature.name.toLowerCase());\n\n          if (feature.options && feature.options.aliases && feature.options.aliases.length) {\n            // Add all the aliases into the names list\n            for (aliasIdx = 0; aliasIdx < feature.options.aliases.length; aliasIdx++) {\n              featureNames.push(feature.options.aliases[aliasIdx].toLowerCase());\n            }\n          }\n        }\n\n        // Run the test, or use the raw value if it's not a function\n        result = is(feature.fn, 'function') ? feature.fn() : feature.fn;\n\n        // Set each of the names on the Modernizr object\n        for (nameIdx = 0; nameIdx < featureNames.length; nameIdx++) {\n          featureName = featureNames[nameIdx];\n          // Support dot properties as sub tests. We don't do checking to make sure\n          // that the implied parent tests have been added. You must call them in\n          // order (either in the test, or make the parent test a dependency).\n          //\n          // Cap it to TWO to make the logic simple and because who needs that kind of subtesting\n          // hashtag famous last words\n          featureNameSplit = featureName.split('.');\n\n          if (featureNameSplit.length === 1) {\n            Modernizr[featureNameSplit[0]] = result;\n          } else {\n            // cast to a Boolean, if not one already or if it doesnt exist yet (like inputtypes)\n            if (!Modernizr[featureNameSplit[0]] || Modernizr[featureNameSplit[0]] && !(Modernizr[featureNameSplit[0]] instanceof Boolean)) {\n              Modernizr[featureNameSplit[0]] = new Boolean(Modernizr[featureNameSplit[0]]);\n            }\n\n            Modernizr[featureNameSplit[0]][featureNameSplit[1]] = result;\n          }\n\n          classes.push((result ? '' : 'no-') + featureNameSplit.join('-'));\n        }\n      }\n    }\n  }\n  ;\n\n  /**\n   * If the browsers follow the spec, then they would expose vendor-specific styles as:\n   *   elem.style.WebkitBorderRadius\n   * instead of something like the following (which is technically incorrect):\n   *   elem.style.webkitBorderRadius\n   *\n   * WebKit ghosts their properties in lowercase but Opera & Moz do not.\n   * Microsoft uses a lowercase `ms` instead of the correct `Ms` in IE8+\n   *   erik.eae.net/archives/2008/03/10/21.48.10/\n   *\n   * More here: github.com/Modernizr/Modernizr/issues/issue/21\n   *\n   * @access private\n   * @returns {string} The string representing the vendor-specific style properties\n   */\n  var omPrefixes = 'Moz O ms Webkit';\n  \n\n  var cssomPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.split(' ') : []);\n  ModernizrProto._cssomPrefixes = cssomPrefixes;\n  \n\n  /**\n   * contains checks to see if a string contains another string\n   *\n   * @access private\n   * @function contains\n   * @param {string} str - The string we want to check for substrings\n   * @param {string} substr - The substring we want to search the first string for\n   * @returns {boolean} true if and only if the first string 'str' contains the second string 'substr'\n   */\n  function contains(str, substr) {\n    return !!~('' + str).indexOf(substr);\n  }\n\n  ;\n\n  /**\n   * docElement is a convenience wrapper to grab the root element of the document\n   *\n   * @access private\n   * @returns {HTMLElement|SVGElement} The root element of the document\n   */\n  var docElement = document.documentElement;\n  \n\n  /**\n   * A convenience helper to check if the document we are running in is an SVG document\n   *\n   * @access private\n   * @returns {boolean}\n   */\n  var isSVG = docElement.nodeName.toLowerCase() === 'svg';\n\n  \n\n  /**\n   * createElement is a convenience wrapper around document.createElement. Since we\n   * use createElement all over the place, this allows for (slightly) smaller code\n   * as well as abstracting away issues with creating elements in contexts other than\n   * HTML documents (e.g. SVG documents).\n   *\n   * @access private\n   * @function createElement\n   * @returns {HTMLElement|SVGElement} An HTML or SVG element\n   */\n  function createElement() {\n    if (typeof document.createElement !== 'function') {\n      // This is the case in IE7, where the type of createElement is \"object\".\n      // For this reason, we cannot call apply() as Object is not a Function.\n      return document.createElement(arguments[0]);\n    } else if (isSVG) {\n      return document.createElementNS.call(document, 'http://www.w3.org/2000/svg', arguments[0]);\n    } else {\n      return document.createElement.apply(document, arguments);\n    }\n  }\n\n  ;\n\n  /**\n   * Create our \"modernizr\" element that we do most feature tests on.\n   *\n   * @access private\n   */\n  var modElem = {\n    elem: createElement('modernizr')\n  };\n\n  // Clean up this element\n  Modernizr._q.push(function() {\n    delete modElem.elem;\n  });\n\n  \n\n  var mStyle = {\n    style: modElem.elem.style\n  };\n\n  // kill ref for gc, must happen before mod.elem is removed, so we unshift on to\n  // the front of the queue.\n  Modernizr._q.unshift(function() {\n    delete mStyle.style;\n  });\n\n  \n\n  /**\n   * getBody returns the body of a document, or an element that can stand in for\n   * the body if a real body does not exist\n   *\n   * @access private\n   * @function getBody\n   * @returns {HTMLElement|SVGElement} Returns the real body of a document, or an\n   * artificially created element that stands in for the body\n   */\n  function getBody() {\n    // After page load injecting a fake body doesn't work so check if body exists\n    var body = document.body;\n\n    if (!body) {\n      // Can't use the real body create a fake one.\n      body = createElement(isSVG ? 'svg' : 'body');\n      body.fake = true;\n    }\n\n    return body;\n  }\n\n  ;\n\n  /**\n   * injectElementWithStyles injects an element with style element and some CSS rules\n   *\n   * @access private\n   * @function injectElementWithStyles\n   * @param {string} rule - String representing a css rule\n   * @param {Function} callback - A function that is used to test the injected element\n   * @param {number} [nodes] - An integer representing the number of additional nodes you want injected\n   * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes\n   * @returns {boolean} the result of the specified callback test\n   */\n  function injectElementWithStyles(rule, callback, nodes, testnames) {\n    var mod = 'modernizr';\n    var style;\n    var ret;\n    var node;\n    var docOverflow;\n    var div = createElement('div');\n    var body = getBody();\n\n    if (parseInt(nodes, 10)) {\n      // In order not to give false positives we create a node for each test\n      // This also allows the method to scale for unspecified uses\n      while (nodes--) {\n        node = createElement('div');\n        node.id = testnames ? testnames[nodes] : mod + (nodes + 1);\n        div.appendChild(node);\n      }\n    }\n\n    style = createElement('style');\n    style.type = 'text/css';\n    style.id = 's' + mod;\n\n    // IE6 will false positive on some tests due to the style element inside the test div somehow interfering offsetHeight, so insert it into body or fakebody.\n    // Opera will act all quirky when injecting elements in documentElement when page is served as xml, needs fakebody too. #270\n    (!body.fake ? div : body).appendChild(style);\n    body.appendChild(div);\n\n    if (style.styleSheet) {\n      style.styleSheet.cssText = rule;\n    } else {\n      style.appendChild(document.createTextNode(rule));\n    }\n    div.id = mod;\n\n    if (body.fake) {\n      //avoid crashing IE8, if background image is used\n      body.style.background = '';\n      //Safari 5.13/5.1.4 OSX stops loading if ::-webkit-scrollbar is used and scrollbars are visible\n      body.style.overflow = 'hidden';\n      docOverflow = docElement.style.overflow;\n      docElement.style.overflow = 'hidden';\n      docElement.appendChild(body);\n    }\n\n    ret = callback(div, rule);\n    // If this is done after page load we don't want to remove the body so check if body exists\n    if (body.fake && body.parentNode) {\n      body.parentNode.removeChild(body);\n      docElement.style.overflow = docOverflow;\n      // Trigger layout so kinetic scrolling isn't disabled in iOS6+\n      // eslint-disable-next-line\n      docElement.offsetHeight;\n    } else {\n      div.parentNode.removeChild(div);\n    }\n\n    return !!ret;\n  }\n\n  ;\n\n  /**\n   * domToCSS takes a camelCase string and converts it to hyphen-case\n   * e.g. boxSizing -> box-sizing\n   *\n   * @access private\n   * @function domToCSS\n   * @param {string} name - String name of camelCase prop we want to convert\n   * @returns {string} The hyphen-case version of the supplied name\n   */\n  function domToCSS(name) {\n    return name.replace(/([A-Z])/g, function(str, m1) {\n      return '-' + m1.toLowerCase();\n    }).replace(/^ms-/, '-ms-');\n  }\n\n  ;\n\n\n  /**\n   * wrapper around getComputedStyle, to fix issues with Firefox returning null when\n   * called inside of a hidden iframe\n   *\n   * @access private\n   * @function computedStyle\n   * @param {HTMLElement|SVGElement} elem - The element we want to find the computed styles of\n   * @param {string|null} [pseudo] - An optional pseudo element selector (e.g. :before), of null if none\n   * @param {string} prop - A CSS property\n   * @returns {CSSStyleDeclaration} the value of the specified CSS property\n   */\n  function computedStyle(elem, pseudo, prop) {\n    var result;\n\n    if ('getComputedStyle' in window) {\n      result = getComputedStyle.call(window, elem, pseudo);\n      var console = window.console;\n\n      if (result !== null) {\n        if (prop) {\n          result = result.getPropertyValue(prop);\n        }\n      } else {\n        if (console) {\n          var method = console.error ? 'error' : 'log';\n          console[method].call(console, 'getComputedStyle returning null, its possible modernizr test results are inaccurate');\n        }\n      }\n    } else {\n      result = !pseudo && elem.currentStyle && elem.currentStyle[prop];\n    }\n\n    return result;\n  }\n\n  ;\n\n  /**\n   * nativeTestProps allows for us to use native feature detection functionality if available.\n   * some prefixed form, or false, in the case of an unsupported rule\n   *\n   * @access private\n   * @function nativeTestProps\n   * @param {Array} props - An array of property names\n   * @param {string} value - A string representing the value we want to check via @supports\n   * @returns {boolean|undefined} A boolean when @supports exists, undefined otherwise\n   */\n  // Accepts a list of property names and a single value\n  // Returns `undefined` if native detection not available\n  function nativeTestProps(props, value) {\n    var i = props.length;\n    // Start with the JS API: https://www.w3.org/TR/css3-conditional/#the-css-interface\n    if ('CSS' in window && 'supports' in window.CSS) {\n      // Try every prefixed variant of the property\n      while (i--) {\n        if (window.CSS.supports(domToCSS(props[i]), value)) {\n          return true;\n        }\n      }\n      return false;\n    }\n    // Otherwise fall back to at-rule (for Opera 12.x)\n    else if ('CSSSupportsRule' in window) {\n      // Build a condition string for every prefixed variant\n      var conditionText = [];\n      while (i--) {\n        conditionText.push('(' + domToCSS(props[i]) + ':' + value + ')');\n      }\n      conditionText = conditionText.join(' or ');\n      return injectElementWithStyles('@supports (' + conditionText + ') { #modernizr { position: absolute; } }', function(node) {\n        return computedStyle(node, null, 'position') === 'absolute';\n      });\n    }\n    return undefined;\n  }\n  ;\n\n  /**\n   * cssToDOM takes a hyphen-case string and converts it to camelCase\n   * e.g. box-sizing -> boxSizing\n   *\n   * @access private\n   * @function cssToDOM\n   * @param {string} name - String name of hyphen-case prop we want to convert\n   * @returns {string} The camelCase version of the supplied name\n   */\n  function cssToDOM(name) {\n    return name.replace(/([a-z])-([a-z])/g, function(str, m1, m2) {\n      return m1 + m2.toUpperCase();\n    }).replace(/^-/, '');\n  }\n\n  ;\n\n  // testProps is a generic CSS / DOM property test.\n\n  // In testing support for a given CSS property, it's legit to test:\n  //    `elem.style[styleName] !== undefined`\n  // If the property is supported it will return an empty string,\n  // if unsupported it will return undefined.\n\n  // We'll take advantage of this quick test and skip setting a style\n  // on our modernizr element, but instead just testing undefined vs\n  // empty string.\n\n  // Property names can be provided in either camelCase or hyphen-case.\n\n  function testProps(props, prefixed, value, skipValueTest) {\n    skipValueTest = is(skipValueTest, 'undefined') ? false : skipValueTest;\n\n    // Try native detect first\n    if (!is(value, 'undefined')) {\n      var result = nativeTestProps(props, value);\n      if (!is(result, 'undefined')) {\n        return result;\n      }\n    }\n\n    // Otherwise do it properly\n    var afterInit, i, propsLength, prop, before;\n\n    // If we don't have a style element, that means we're running async or after\n    // the core tests, so we'll need to create our own elements to use.\n\n    // Inside of an SVG element, in certain browsers, the `style` element is only\n    // defined for valid tags. Therefore, if `modernizr` does not have one, we\n    // fall back to a less used element and hope for the best.\n    // For strict XHTML browsers the hardly used samp element is used.\n    var elems = ['modernizr', 'tspan', 'samp'];\n    while (!mStyle.style && elems.length) {\n      afterInit = true;\n      mStyle.modElem = createElement(elems.shift());\n      mStyle.style = mStyle.modElem.style;\n    }\n\n    // Delete the objects if we created them.\n    function cleanElems() {\n      if (afterInit) {\n        delete mStyle.style;\n        delete mStyle.modElem;\n      }\n    }\n\n    propsLength = props.length;\n    for (i = 0; i < propsLength; i++) {\n      prop = props[i];\n      before = mStyle.style[prop];\n\n      if (contains(prop, '-')) {\n        prop = cssToDOM(prop);\n      }\n\n      if (mStyle.style[prop] !== undefined) {\n\n        // If value to test has been passed in, do a set-and-check test.\n        // 0 (integer) is a valid property value, so check that `value` isn't\n        // undefined, rather than just checking it's truthy.\n        if (!skipValueTest && !is(value, 'undefined')) {\n\n          // Needs a try catch block because of old IE. This is slow, but will\n          // be avoided in most cases because `skipValueTest` will be used.\n          try {\n            mStyle.style[prop] = value;\n          } catch (e) {}\n\n          // If the property value has changed, we assume the value used is\n          // supported. If `value` is empty string, it'll fail here (because\n          // it hasn't changed), which matches how browsers have implemented\n          // CSS.supports()\n          if (mStyle.style[prop] !== before) {\n            cleanElems();\n            return prefixed === 'pfx' ? prop : true;\n          }\n        }\n        // Otherwise just return true, or the property name if this is a\n        // `prefixed()` call\n        else {\n          cleanElems();\n          return prefixed === 'pfx' ? prop : true;\n        }\n      }\n    }\n    cleanElems();\n    return false;\n  }\n\n  ;\n\n  /**\n   * List of JavaScript DOM values used for tests\n   *\n   * @memberOf Modernizr\n   * @name Modernizr._domPrefixes\n   * @optionName Modernizr._domPrefixes\n   * @optionProp domPrefixes\n   * @access public\n   * @example\n   *\n   * Modernizr._domPrefixes is exactly the same as [_prefixes](#modernizr-_prefixes), but rather\n   * than hyphen-case properties, all properties are their Capitalized variant\n   *\n   * ```js\n   * Modernizr._domPrefixes === [ \"Moz\", \"O\", \"ms\", \"Webkit\" ];\n   * ```\n   */\n  var domPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.toLowerCase().split(' ') : []);\n  ModernizrProto._domPrefixes = domPrefixes;\n  \n\n  /**\n   * fnBind is a super small [bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind) polyfill.\n   *\n   * @access private\n   * @function fnBind\n   * @param {Function} fn - a function you want to change `this` reference to\n   * @param {object} that - the `this` you want to call the function with\n   * @returns {Function} The wrapped version of the supplied function\n   */\n  function fnBind(fn, that) {\n    return function() {\n      return fn.apply(that, arguments);\n    };\n  }\n\n  ;\n\n  /**\n   * testDOMProps is a generic DOM property test; if a browser supports\n   *   a certain property, it won't return undefined for it.\n   *\n   * @access private\n   * @function testDOMProps\n   * @param {Array<string>} props - An array of properties to test for\n   * @param {object} obj - An object or Element you want to use to test the parameters again\n   * @param {boolean|object} elem - An Element to bind the property lookup again. Use `false` to prevent the check\n   * @returns {boolean|*} returns `false` if the prop is unsupported, otherwise the value that is supported\n   */\n  function testDOMProps(props, obj, elem) {\n    var item;\n\n    for (var i in props) {\n      if (props[i] in obj) {\n\n        // return the property name as a string\n        if (elem === false) {\n          return props[i];\n        }\n\n        item = obj[props[i]];\n\n        // let's bind a function\n        if (is(item, 'function')) {\n          // bind to obj unless overridden\n          return fnBind(item, elem || obj);\n        }\n\n        // return the unbound function or obj or value\n        return item;\n      }\n    }\n    return false;\n  }\n\n  ;\n\n  /**\n   * testPropsAll tests a list of DOM properties we want to check against.\n   * We specify literally ALL possible (known and/or likely) properties on\n   * the element including the non-vendor prefixed one, for forward-\n   * compatibility.\n   *\n   * @access private\n   * @function testPropsAll\n   * @param {string} prop - A string of the property to test for\n   * @param {string|object} [prefixed] - An object to check the prefixed properties on. Use a string to skip\n   * @param {HTMLElement|SVGElement} [elem] - An element used to test the property and value against\n   * @param {string} [value] - A string of a css value\n   * @param {boolean} [skipValueTest] - An boolean representing if you want to test if value sticks when set\n   * @returns {string|boolean} returns the string version of the property, or `false` if it is unsupported\n   */\n  function testPropsAll(prop, prefixed, elem, value, skipValueTest) {\n\n    var ucProp = prop.charAt(0).toUpperCase() + prop.slice(1),\n      props = (prop + ' ' + cssomPrefixes.join(ucProp + ' ') + ucProp).split(' ');\n\n    // did they call .prefixed('boxSizing') or are we just testing a prop?\n    if (is(prefixed, 'string') || is(prefixed, 'undefined')) {\n      return testProps(props, prefixed, value, skipValueTest);\n\n      // otherwise, they called .prefixed('requestAnimationFrame', window[, elem])\n    } else {\n      props = (prop + ' ' + (domPrefixes).join(ucProp + ' ') + ucProp).split(' ');\n      return testDOMProps(props, prefixed, elem);\n    }\n  }\n\n  // Modernizr.testAllProps() investigates whether a given style property,\n  // or any of its vendor-prefixed variants, is recognized\n  //\n  // Note that the property names must be provided in the camelCase variant.\n  // Modernizr.testAllProps('boxSizing')\n  ModernizrProto.testAllProps = testPropsAll;\n\n  \n\n  /**\n   * testAllProps determines whether a given CSS property is supported in the browser\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.testAllProps\n   * @optionName Modernizr.testAllProps()\n   * @optionProp testAllProps\n   * @access public\n   * @function testAllProps\n   * @param {string} prop - String naming the property to test (either camelCase or hyphen-case)\n   * @param {string} [value] - String of the value to test\n   * @param {boolean} [skipValueTest=false] - Whether to skip testing that the value is supported when using non-native detection\n   * @returns {string|boolean} returns the string version of the property, or `false` if it is unsupported\n   * @example\n   *\n   * testAllProps determines whether a given CSS property, in some prefixed form,\n   * is supported by the browser.\n   *\n   * ```js\n   * testAllProps('boxSizing')  // true\n   * ```\n   *\n   * It can optionally be given a CSS value in string form to test if a property\n   * value is valid\n   *\n   * ```js\n   * testAllProps('display', 'block') // true\n   * testAllProps('display', 'penguin') // false\n   * ```\n   *\n   * A boolean can be passed as a third parameter to skip the value check when\n   * native detection (@supports) isn't available.\n   *\n   * ```js\n   * testAllProps('shapeOutside', 'content-box', true);\n   * ```\n   */\n  function testAllProps(prop, value, skipValueTest) {\n    return testPropsAll(prop, undefined, undefined, value, skipValueTest);\n  }\n\n  ModernizrProto.testAllProps = testAllProps;\n\n  \n/*!\n{\n  \"name\": \"CSS Animations\",\n  \"property\": \"cssanimations\",\n  \"caniuse\": \"css-animation\",\n  \"polyfills\": [\"transformie\", \"csssandpaper\"],\n  \"tags\": [\"css\"],\n  \"warnings\": [\"Android < 4 will pass this test, but can only animate a single property at a time\"],\n  \"notes\": [{\n    \"name\": \"Article: 'Dispelling the Android CSS animation myths'\",\n    \"href\": \"https://web.archive.org/web/20180602074607/https://daneden.me/2011/12/14/putting-up-with-androids-bullshit/\"\n  }]\n}\n!*/\n/* DOC\nDetects whether or not elements can be animated using CSS\n*/\n\n  Modernizr.addTest('cssanimations', testAllProps('animationName', 'a', true));\n\n\n  /**\n   * testStyles injects an element with style element and some CSS rules\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.testStyles\n   * @optionName Modernizr.testStyles()\n   * @optionProp testStyles\n   * @access public\n   * @function testStyles\n   * @param {string} rule - String representing a css rule\n   * @param {Function} callback - A function that is used to test the injected element\n   * @param {number} [nodes] - An integer representing the number of additional nodes you want injected\n   * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes\n   * @returns {boolean}\n   * @example\n   *\n   * `Modernizr.testStyles` takes a CSS rule and injects it onto the current page\n   * along with (possibly multiple) DOM elements. This lets you check for features\n   * that can not be detected by simply checking the [IDL](https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Interface_development_guide/IDL_interface_rules).\n   *\n   * ```js\n   * Modernizr.testStyles('#modernizr { width: 9px; color: papayawhip; }', function(elem, rule) {\n   *   // elem is the first DOM node in the page (by default #modernizr)\n   *   // rule is the first argument you supplied - the CSS rule in string form\n   *\n   *   addTest('widthworks', elem.style.width === '9px')\n   * });\n   * ```\n   *\n   * If your test requires multiple nodes, you can include a third argument\n   * indicating how many additional div elements to include on the page. The\n   * additional nodes are injected as children of the `elem` that is returned as\n   * the first argument to the callback.\n   *\n   * ```js\n   * Modernizr.testStyles('#modernizr {width: 1px}; #modernizr2 {width: 2px}', function(elem) {\n   *   document.getElementById('modernizr').style.width === '1px'; // true\n   *   document.getElementById('modernizr2').style.width === '2px'; // true\n   *   elem.firstChild === document.getElementById('modernizr2'); // true\n   * }, 1);\n   * ```\n   *\n   * By default, all of the additional elements have an ID of `modernizr[n]`, where\n   * `n` is its index (e.g. the first additional, second overall is `#modernizr2`,\n   * the second additional is `#modernizr3`, etc.).\n   * If you want to have more meaningful IDs for your function, you can provide\n   * them as the fourth argument, as an array of strings\n   *\n   * ```js\n   * Modernizr.testStyles('#foo {width: 10px}; #bar {height: 20px}', function(elem) {\n   *   elem.firstChild === document.getElementById('foo'); // true\n   *   elem.lastChild === document.getElementById('bar'); // true\n   * }, 2, ['foo', 'bar']);\n   * ```\n   */\n  var testStyles = ModernizrProto.testStyles = injectElementWithStyles;\n  \n/*!\n{\n  \"name\": \"CSS Display table\",\n  \"property\": \"displaytable\",\n  \"caniuse\": \"css-table\",\n  \"authors\": [\"scottjehl\"],\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_displaytable\"],\n  \"notes\": [{\n    \"name\": \"Detects for all additional table display values\",\n    \"href\": \"https://pastebin.com/Gk9PeVaQ\"\n  }]\n}\n!*/\n/* DOC\n`display: table` and `table-cell` test. (both are tested under one name `table-cell` )\n*/\n\n  // If a document is in rtl mode this test will fail so we force ltr mode on the injected\n  // element https://github.com/Modernizr/Modernizr/issues/716\n  testStyles('#modernizr{display: table; direction: ltr}#modernizr div{display: table-cell; padding: 10px}', function(elem) {\n    var ret;\n    var child = elem.childNodes;\n    ret = child[0].offsetLeft < child[1].offsetLeft;\n    Modernizr.addTest('displaytable', ret, {aliases: ['display-table']});\n  }, 2);\n\n\n  /**\n   * List of property values to set for css tests. See ticket #21\n   * https://github.com/modernizr/modernizr/issues/21\n   *\n   * @memberOf Modernizr\n   * @name Modernizr._prefixes\n   * @optionName Modernizr._prefixes\n   * @optionProp prefixes\n   * @access public\n   * @example\n   *\n   * Modernizr._prefixes is the internal list of prefixes that we test against\n   * inside of things like [prefixed](#modernizr-prefixed) and [prefixedCSS](#-code-modernizr-prefixedcss). It is simply\n   * an array of hyphen-case vendor prefixes you can use within your code.\n   *\n   * Some common use cases include\n   *\n   * Generating all possible prefixed version of a CSS property\n   * ```js\n   * var rule = Modernizr._prefixes.join('transform: rotate(20deg); ');\n   *\n   * rule === 'transform: rotate(20deg); webkit-transform: rotate(20deg); moz-transform: rotate(20deg); o-transform: rotate(20deg); ms-transform: rotate(20deg);'\n   * ```\n   *\n   * Generating all possible prefixed version of a CSS value\n   * ```js\n   * rule = 'display:' +  Modernizr._prefixes.join('flex; display:') + 'flex';\n   *\n   * rule === 'display:flex; display:-webkit-flex; display:-moz-flex; display:-o-flex; display:-ms-flex; display:flex'\n   * ```\n   */\n  // we use ['',''] rather than an empty array in order to allow a pattern of .`join()`ing prefixes to test\n  // values in feature detects to continue to work\n  var prefixes = (ModernizrProto._config.usePrefixes ? ' -webkit- -moz- -o- -ms- '.split(' ') : ['','']);\n\n  // expose these for the plugin API. Look in the source for how to join() them against your input\n  ModernizrProto._prefixes = prefixes;\n\n  \n/*!\n{\n  \"name\": \"CSS Supports\",\n  \"property\": \"supports\",\n  \"caniuse\": \"css-featurequeries\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_supports\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec (The @supports rule)\",\n    \"href\": \"https://dev.w3.org/csswg/css3-conditional/#at-supports\"\n  }, {\n    \"name\": \"Related Github Issue\",\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/648\"\n  }, {\n    \"name\": \"W3C Spec (The CSSSupportsRule interface)\",\n    \"href\": \"https://dev.w3.org/csswg/css3-conditional/#the-csssupportsrule-interface\"\n  }]\n}\n!*/\n\n  var newSyntax = 'CSS' in window && 'supports' in window.CSS;\n  var oldSyntax = 'supportsCSS' in window;\n  Modernizr.addTest('supports', newSyntax || oldSyntax);\n\n/*!\n{\n  \"name\": \"CSS Filters\",\n  \"property\": \"cssfilters\",\n  \"caniuse\": \"css-filters\",\n  \"polyfills\": [\"polyfilter\"],\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_filters\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/filter\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('cssfilters', function() {\n    if (Modernizr.supports) {\n      return testAllProps('filter', 'blur(2px)');\n    } else {\n      var el = createElement('a');\n      el.style.cssText = prefixes.join('filter:blur(2px); ');\n      // https://github.com/Modernizr/Modernizr/issues/615\n      // documentMode is needed for false positives in oldIE, please see issue above\n      return !!el.style.length && ((document.documentMode === undefined || document.documentMode > 9));\n    }\n  });\n\n\n/*!\n{\n  \"name\": \"Flexbox\",\n  \"property\": \"flexbox\",\n  \"caniuse\": \"flexbox\",\n  \"tags\": [\"css\"],\n  \"notes\": [{\n    \"name\": \"The _new_ flexbox\",\n    \"href\": \"https://www.w3.org/TR/css-flexbox-1/\"\n  }],\n  \"warnings\": [\n    \"A `true` result for this detect does not imply that the `flex-wrap` property is supported; see the `flexwrap` detect.\"\n  ]\n}\n!*/\n/* DOC\nDetects support for the Flexible Box Layout model, a.k.a. Flexbox, which allows easy manipulation of layout order and sizing within a container.\n*/\n\n  Modernizr.addTest('flexbox', testAllProps('flexBasis', '1px', true));\n\n\n  /**\n   * atRule returns a given CSS property at-rule (eg @keyframes), possibly in\n   * some prefixed form, or false, in the case of an unsupported rule\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.atRule\n   * @optionName Modernizr.atRule()\n   * @optionProp atRule\n   * @access public\n   * @function atRule\n   * @param {string} prop - String name of the @-rule to test for\n   * @returns {string|boolean} The string representing the (possibly prefixed)\n   * valid version of the @-rule, or `false` when it is unsupported.\n   * @example\n   * ```js\n   *  var keyframes = Modernizr.atRule('@keyframes');\n   *\n   *  if (keyframes) {\n   *    // keyframes are supported\n   *    // could be `@-webkit-keyframes` or `@keyframes`\n   *  } else {\n   *    // keyframes === `false`\n   *  }\n   * ```\n   */\n  var atRule = function(prop) {\n    var length = prefixes.length;\n    var cssrule = window.CSSRule;\n    var rule;\n\n    if (typeof cssrule === 'undefined') {\n      return undefined;\n    }\n\n    if (!prop) {\n      return false;\n    }\n\n    // remove literal @ from beginning of provided property\n    prop = prop.replace(/^@/, '');\n\n    // CSSRules use underscores instead of dashes\n    rule = prop.replace(/-/g, '_').toUpperCase() + '_RULE';\n\n    if (rule in cssrule) {\n      return '@' + prop;\n    }\n\n    for (var i = 0; i < length; i++) {\n      // prefixes gives us something like -o-, and we want O_\n      var prefix = prefixes[i];\n      var thisRule = prefix.toUpperCase() + '_' + rule;\n\n      if (thisRule in cssrule) {\n        return '@-' + prefix.toLowerCase() + '-' + prop;\n      }\n    }\n\n    return false;\n  };\n\n  ModernizrProto.atRule = atRule;\n\n  \n\n  /**\n   * prefixed returns the prefixed or nonprefixed property name variant of your input\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.prefixed\n   * @optionName Modernizr.prefixed()\n   * @optionProp prefixed\n   * @access public\n   * @function prefixed\n   * @param {string} prop - String name of the property to test for\n   * @param {object} [obj] - An object to test for the prefixed properties on\n   * @param {HTMLElement} [elem] - An element used to test specific properties against\n   * @returns {string|boolean} The string representing the (possibly prefixed) valid\n   * version of the property, or `false` when it is unsupported.\n   * @example\n   *\n   * Modernizr.prefixed takes a string css value in the DOM style camelCase (as\n   * opposed to the css style hyphen-case) form and returns the (possibly prefixed)\n   * version of that property that the browser actually supports.\n   *\n   * For example, in older Firefox...\n   * ```js\n   * prefixed('boxSizing')\n   * ```\n   * returns 'MozBoxSizing'\n   *\n   * In newer Firefox, as well as any other browser that support the unprefixed\n   * version would simply return `boxSizing`. Any browser that does not support\n   * the property at all, it will return `false`.\n   *\n   * By default, prefixed is checked against a DOM element. If you want to check\n   * for a property on another object, just pass it as a second argument\n   *\n   * ```js\n   * var rAF = prefixed('requestAnimationFrame', window);\n   *\n   * raf(function() {\n   *  renderFunction();\n   * })\n   * ```\n   *\n   * Note that this will return _the actual function_ - not the name of the function.\n   * If you need the actual name of the property, pass in `false` as a third argument\n   *\n   * ```js\n   * var rAFProp = prefixed('requestAnimationFrame', window, false);\n   *\n   * rafProp === 'WebkitRequestAnimationFrame' // in older webkit\n   * ```\n   *\n   * One common use case for prefixed is if you're trying to determine which transition\n   * end event to bind to, you might do something like...\n   * ```js\n   * var transEndEventNames = {\n   *     'WebkitTransition' : 'webkitTransitionEnd', * Saf 6, Android Browser\n   *     'MozTransition'    : 'transitionend',       * only for FF < 15\n   *     'transition'       : 'transitionend'        * IE10, Opera, Chrome, FF 15+, Saf 7+\n   * };\n   *\n   * var transEndEventName = transEndEventNames[ Modernizr.prefixed('transition') ];\n   * ```\n   *\n   * If you want a similar lookup, but in hyphen-case, you can use [prefixedCSS](#modernizr-prefixedcss).\n   */\n  var prefixed = ModernizrProto.prefixed = function(prop, obj, elem) {\n    if (prop.indexOf('@') === 0) {\n      return atRule(prop);\n    }\n\n    if (prop.indexOf('-') !== -1) {\n      // Convert hyphen-case to camelCase\n      prop = cssToDOM(prop);\n    }\n    if (!obj) {\n      return testPropsAll(prop, 'pfx');\n    } else {\n      // Testing DOM property e.g. Modernizr.prefixed('requestAnimationFrame', window) // 'mozRequestAnimationFrame'\n      return testPropsAll(prop, obj, elem);\n    }\n  };\n\n  \n/*!\n{\n  \"name\": \"CSS Object Fit\",\n  \"caniuse\": \"object-fit\",\n  \"property\": \"objectfit\",\n  \"tags\": [\"css\"],\n  \"builderAliases\": [\"css_objectfit\"],\n  \"notes\": [{\n    \"name\": \"Opera Article on Object Fit\",\n    \"href\": \"https://dev.opera.com/articles/css3-object-fit-object-position/\"\n  }]\n}\n!*/\n\n  Modernizr.addTest('objectfit', !!prefixed('objectFit'), {aliases: ['object-fit']});\n\n/*!\n{\n  \"name\": \"ES5 Date\",\n  \"property\": \"es5date\",\n  \"notes\": [{\n    \"name\": \"ECMAScript 5.1 Language Specification\",\n    \"href\": \"https://www.ecma-international.org/ecma-262/5.1/\"\n  }],\n  \"polyfills\": [\"es5shim\"],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"tags\": [\"es5\"]\n}\n!*/\n/* DOC\nCheck if browser implements ECMAScript 5 Date per specification.\n*/\n\n  Modernizr.addTest('es5date', function() {\n    var isoDate = '2013-04-12T06:06:37.307Z',\n      canParseISODate = false;\n    try {\n      canParseISODate = !!Date.parse(isoDate);\n    } catch (e) {\n      // no ISO date parsing yet\n    }\n    return !!(Date.now &&\n      Date.prototype &&\n      Date.prototype.toISOString &&\n      Date.prototype.toJSON &&\n      canParseISODate);\n  });\n\n/*!\n{\n  \"name\": \"ES5 Function\",\n  \"property\": \"es5function\",\n  \"notes\": [{\n    \"name\": \"ECMAScript 5.1 Language Specification\",\n    \"href\": \"https://www.ecma-international.org/ecma-262/5.1/\"\n  }],\n  \"polyfills\": [\"es5shim\"],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"tags\": [\"es5\"]\n}\n!*/\n/* DOC\nCheck if browser implements ECMAScript 5 Function per specification.\n*/\n\n  Modernizr.addTest('es5function', function() {\n    return !!(Function.prototype && Function.prototype.bind);\n  });\n\n/*!\n{\n  \"name\": \"ES5 Object\",\n  \"property\": \"es5object\",\n  \"notes\": [{\n    \"name\": \"ECMAScript 5.1 Language Specification\",\n    \"href\": \"https://www.ecma-international.org/ecma-262/5.1/\"\n  }],\n  \"polyfills\": [\"es5shim\", \"es5sham\"],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"tags\": [\"es5\"]\n}\n!*/\n/* DOC\nCheck if browser implements ECMAScript 5 Object per specification.\n*/\n\n  Modernizr.addTest('es5object', function() {\n    return !!(Object.keys &&\n      Object.create &&\n      Object.getPrototypeOf &&\n      Object.getOwnPropertyNames &&\n      Object.isSealed &&\n      Object.isFrozen &&\n      Object.isExtensible &&\n      Object.getOwnPropertyDescriptor &&\n      Object.defineProperty &&\n      Object.defineProperties &&\n      Object.seal &&\n      Object.freeze &&\n      Object.preventExtensions);\n  });\n\n/*!\n{\n  \"name\": \"ES5 Immutable Undefined\",\n  \"property\": \"es5undefined\",\n  \"notes\": [{\n    \"name\": \"ECMAScript 5.1 Language Specification\",\n    \"href\": \"https://www.ecma-international.org/ecma-262/5.1/\"\n  }, {\n    \"name\": \"original implementation of detect code\",\n    \"href\": \"https://kangax.github.io/compat-table/es5/\"\n  }],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"tags\": [\"es5\"]\n}\n!*/\n/* DOC\nCheck if browser prevents assignment to global `undefined` per ECMAScript 5.\n*/\n\n  Modernizr.addTest('es5undefined', function() {\n    var result, originalUndefined;\n    try {\n      originalUndefined = window.undefined;\n      window.undefined = 12345;\n      result = typeof window.undefined === 'undefined';\n      window.undefined = originalUndefined;\n    } catch (e) {\n      return false;\n    }\n    return result;\n  });\n\n/*!\n{\n  \"name\": \"ES6 Array\",\n  \"property\": \"es6array\",\n  \"notes\": [{\n    \"name\": \"unofficial ECMAScript 6 draft specification\",\n    \"href\": \"https://web.archive.org/web/20180825202128/https://tc39.github.io/ecma262/\"\n  }],\n  \"polyfills\": [\"es6shim\"],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"warnings\": [\"ECMAScript 6 is still a only a draft, so this detect may not match the final specification or implementations.\"],\n  \"tags\": [\"es6\"]\n}\n!*/\n/* DOC\nCheck if browser implements ECMAScript 6 Array per specification.\n*/\n\n  Modernizr.addTest('es6array', !!(Array.prototype &&\n    Array.prototype.copyWithin &&\n    Array.prototype.fill &&\n    Array.prototype.find &&\n    Array.prototype.findIndex &&\n    Array.prototype.keys &&\n    Array.prototype.entries &&\n    Array.prototype.values &&\n    Array.from &&\n    Array.of));\n\n/*!\n{\n  \"name\": \"ES6 Collections\",\n  \"property\": \"es6collections\",\n  \"notes\": [{\n    \"name\": \"unofficial ECMAScript 6 draft specification\",\n    \"href\": \"https://web.archive.org/web/20180825202128/https://tc39.github.io/ecma262/\"\n  }],\n  \"polyfills\": [\"es6shim\", \"weakmap\"],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"warnings\": [\"ECMAScript 6 is still a only a draft, so this detect may not match the final specification or implementations.\"],\n  \"tags\": [\"es6\"]\n}\n!*/\n/* DOC\nCheck if browser implements ECMAScript 6 Map, Set, WeakMap and WeakSet\n*/\n\n  Modernizr.addTest('es6collections', !!(\n    window.Map && window.Set && window.WeakMap && window.WeakSet\n  ));\n\n/*!\n{\n  \"name\": \"ES6 Promises\",\n  \"property\": \"promises\",\n  \"caniuse\": \"promises\",\n  \"polyfills\": [\"es6promises\"],\n  \"authors\": [\"Krister Kari\", \"Jake Archibald\"],\n  \"tags\": [\"es6\"],\n  \"notes\": [{\n    \"name\": \"The ES6 promises spec\",\n    \"href\": \"https://github.com/domenic/promises-unwrapping\"\n  }, {\n    \"name\": \"Chromium dashboard - ES6 Promises\",\n    \"href\": \"https://www.chromestatus.com/features/5681726336532480\"\n  }, {\n    \"name\": \"JavaScript Promises: an Introduction\",\n    \"href\": \"https://developers.google.com/web/fundamentals/primers/promises/\"\n  }]\n}\n!*/\n/* DOC\nCheck if browser implements ECMAScript 6 Promises per specification.\n*/\n\n  Modernizr.addTest('promises', function() {\n    return 'Promise' in window &&\n    // Some of these methods are missing from\n    // Firefox/Chrome experimental implementations\n    'resolve' in window.Promise &&\n    'reject' in window.Promise &&\n    'all' in window.Promise &&\n    'race' in window.Promise &&\n    // Older version of the spec had a resolver object\n    // as the arg rather than a function\n    (function() {\n      var resolve;\n      new window.Promise(function(r) { resolve = r; });\n      return typeof resolve === 'function';\n    }());\n  });\n\n/*!\n{\n  \"name\": \"ES6 String\",\n  \"property\": \"es6string\",\n  \"notes\": [{\n    \"name\": \"unofficial ECMAScript 6 draft specification\",\n    \"href\": \"https://web.archive.org/web/20180825202128/https://tc39.github.io/ecma262/\"\n  }],\n  \"polyfills\": [\"es6shim\"],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"warnings\": [\"ECMAScript 6 is still a only a draft, so this detect may not match the final specification or implementations.\"],\n  \"tags\": [\"es6\"]\n}\n!*/\n/* DOC\nCheck if browser implements ECMAScript 6 String per specification.\n*/\n\n  Modernizr.addTest('es6string', !!(String.fromCodePoint &&\n    String.raw &&\n    String.prototype.codePointAt &&\n    String.prototype.repeat &&\n    String.prototype.startsWith &&\n    String.prototype.endsWith &&\n    String.prototype.includes));\n\n/*!\n{\n  \"name\": \"SVG\",\n  \"property\": \"svg\",\n  \"caniuse\": \"svg\",\n  \"tags\": [\"svg\"],\n  \"authors\": [\"Erik Dahlstrom\"],\n  \"polyfills\": [\n    \"svgweb\",\n    \"raphael\",\n    \"amplesdk\",\n    \"canvg\",\n    \"svg-boilerplate\",\n    \"sie\",\n    \"dojogfx\",\n    \"fabricjs\"\n  ]\n}\n!*/\n/* DOC\nDetects support for SVG in `<embed>` or `<object>` elements.\n*/\n\n  Modernizr.addTest('svg', !!document.createElementNS && !!document.createElementNS('http://www.w3.org/2000/svg', 'svg').createSVGRect);\n\n\n  /**\n   * hasOwnProp is a shim for hasOwnProperty that is needed for Safari 2.0 support\n   *\n   * @author kangax\n   * @access private\n   * @function hasOwnProp\n   * @param {object} object - The object to check for a property\n   * @param {string} property - The property to check for\n   * @returns {boolean}\n   */\n\n  // hasOwnProperty shim by kangax needed for Safari 2.0 support\n  var hasOwnProp;\n\n  (function() {\n    var _hasOwnProperty = ({}).hasOwnProperty;\n    /* istanbul ignore else */\n    /* we have no way of testing IE 5.5 or safari 2,\n     * so just assume the else gets hit */\n    if (!is(_hasOwnProperty, 'undefined') && !is(_hasOwnProperty.call, 'undefined')) {\n      hasOwnProp = function(object, property) {\n        return _hasOwnProperty.call(object, property);\n      };\n    }\n    else {\n      hasOwnProp = function(object, property) { /* yes, this can give false positives/negatives, but most of the time we don't care about those */\n        return ((property in object) && is(object.constructor.prototype[property], 'undefined'));\n      };\n    }\n  })();\n\n  \n\n  /**\n   * setClasses takes an array of class names and adds them to the root element\n   *\n   * @access private\n   * @function setClasses\n   * @param {string[]} classes - Array of class names\n   */\n  // Pass in an and array of class names, e.g.:\n  //  ['no-webp', 'borderradius', ...]\n  function setClasses(classes) {\n    var className = docElement.className;\n    var classPrefix = Modernizr._config.classPrefix || '';\n\n    if (isSVG) {\n      className = className.baseVal;\n    }\n\n    // Change `no-js` to `js` (independently of the `enableClasses` option)\n    // Handle classPrefix on this too\n    if (Modernizr._config.enableJSClass) {\n      var reJS = new RegExp('(^|\\\\s)' + classPrefix + 'no-js(\\\\s|$)');\n      className = className.replace(reJS, '$1' + classPrefix + 'js$2');\n    }\n\n    if (Modernizr._config.enableClasses) {\n      // Add the new classes\n      if (classes.length > 0) {\n        className += ' ' + classPrefix + classes.join(' ' + classPrefix);\n      }\n      if (isSVG) {\n        docElement.className.baseVal = className;\n      } else {\n        docElement.className = className;\n      }\n    }\n  }\n\n  ;\n\n\n  // _l tracks listeners for async tests, as well as tests that execute after the initial run\n  ModernizrProto._l = {};\n\n  /**\n   * Modernizr.on is a way to listen for the completion of async tests. Being\n   * asynchronous, they may not finish before your scripts run. As a result you\n   * will get a possibly false negative `undefined` value.\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.on\n   * @access public\n   * @function on\n   * @param {string} feature - String name of the feature detect\n   * @param {Function} cb - Callback function returning a Boolean - true if feature is supported, false if not\n   * @returns {void}\n   * @example\n   *\n   * ```js\n   * Modernizr.on('flash', function( result ) {\n   *   if (result) {\n   *    // the browser has flash\n   *   } else {\n   *     // the browser does not have flash\n   *   }\n   * });\n   * ```\n   */\n  ModernizrProto.on = function(feature, cb) {\n    // Create the list of listeners if it doesn't exist\n    if (!this._l[feature]) {\n      this._l[feature] = [];\n    }\n\n    // Push this test on to the listener list\n    this._l[feature].push(cb);\n\n    // If it's already been resolved, trigger it on next tick\n    if (Modernizr.hasOwnProperty(feature)) {\n      // Next Tick\n      setTimeout(function() {\n        Modernizr._trigger(feature, Modernizr[feature]);\n      }, 0);\n    }\n  };\n\n  /**\n   * _trigger is the private function used to signal test completion and run any\n   * callbacks registered through [Modernizr.on](#modernizr-on)\n   *\n   * @memberOf Modernizr\n   * @name Modernizr._trigger\n   * @access private\n   * @function _trigger\n   * @param {string} feature - string name of the feature detect\n   * @param {Function|boolean} [res] - A feature detection function, or the boolean =\n   * result of a feature detection function\n   * @returns {void}\n   */\n  ModernizrProto._trigger = function(feature, res) {\n    if (!this._l[feature]) {\n      return;\n    }\n\n    var cbs = this._l[feature];\n\n    // Force async\n    setTimeout(function() {\n      var i, cb;\n      for (i = 0; i < cbs.length; i++) {\n        cb = cbs[i];\n        cb(res);\n      }\n    }, 0);\n\n    // Don't trigger these again\n    delete this._l[feature];\n  };\n\n  /**\n   * addTest allows you to define your own feature detects that are not currently\n   * included in Modernizr (under the covers it's the exact same code Modernizr\n   * uses for its own [feature detections](https://github.com/Modernizr/Modernizr/tree/master/feature-detects)).\n   * Just like the official detects, the result\n   * will be added onto the Modernizr object, as well as an appropriate className set on\n   * the html element when configured to do so\n   *\n   * @memberOf Modernizr\n   * @name Modernizr.addTest\n   * @optionName Modernizr.addTest()\n   * @optionProp addTest\n   * @access public\n   * @function addTest\n   * @param {string|object} feature - The string name of the feature detect, or an\n   * object of feature detect names and test\n   * @param {Function|boolean} test - Function returning true if feature is supported,\n   * false if not. Otherwise a boolean representing the results of a feature detection\n   * @returns {object} the Modernizr object to allow chaining\n   * @example\n   *\n   * The most common way of creating your own feature detects is by calling\n   * `Modernizr.addTest` with a string (preferably just lowercase, without any\n   * punctuation), and a function you want executed that will return a boolean result\n   *\n   * ```js\n   * Modernizr.addTest('itsTuesday', function() {\n   *  var d = new Date();\n   *  return d.getDay() === 2;\n   * });\n   * ```\n   *\n   * When the above is run, it will set Modernizr.itstuesday to `true` when it is tuesday,\n   * and to `false` every other day of the week. One thing to notice is that the names of\n   * feature detect functions are always lowercased when added to the Modernizr object. That\n   * means that `Modernizr.itsTuesday` will not exist, but `Modernizr.itstuesday` will.\n   *\n   *\n   *  Since we only look at the returned value from any feature detection function,\n   *  you do not need to actually use a function. For simple detections, just passing\n   *  in a statement that will return a boolean value works just fine.\n   *\n   * ```js\n   * Modernizr.addTest('hasjquery', 'jQuery' in window);\n   * ```\n   *\n   * Just like before, when the above runs `Modernizr.hasjquery` will be true if\n   * jQuery has been included on the page. Not using a function saves a small amount\n   * of overhead for the browser, as well as making your code much more readable.\n   *\n   * Finally, you also have the ability to pass in an object of feature names and\n   * their tests. This is handy if you want to add multiple detections in one go.\n   * The keys should always be a string, and the value can be either a boolean or\n   * function that returns a boolean.\n   *\n   * ```js\n   * var detects = {\n   *  'hasjquery': 'jQuery' in window,\n   *  'itstuesday': function() {\n   *    var d = new Date();\n   *    return d.getDay() === 2;\n   *  }\n   * }\n   *\n   * Modernizr.addTest(detects);\n   * ```\n   *\n   * There is really no difference between the first methods and this one, it is\n   * just a convenience to let you write more readable code.\n   */\n  function addTest(feature, test) {\n\n    if (typeof feature === 'object') {\n      for (var key in feature) {\n        if (hasOwnProp(feature, key)) {\n          addTest(key, feature[ key ]);\n        }\n      }\n    } else {\n\n      feature = feature.toLowerCase();\n      var featureNameSplit = feature.split('.');\n      var last = Modernizr[featureNameSplit[0]];\n\n      // Again, we don't check for parent test existence. Get that right, though.\n      if (featureNameSplit.length === 2) {\n        last = last[featureNameSplit[1]];\n      }\n\n      if (typeof last !== 'undefined') {\n        // we're going to quit if you're trying to overwrite an existing test\n        // if we were to allow it, we'd do this:\n        //   var re = new RegExp(\"\\\\b(no-)?\" + feature + \"\\\\b\");\n        //   docElement.className = docElement.className.replace( re, '' );\n        // but, no rly, stuff 'em.\n        return Modernizr;\n      }\n\n      test = typeof test === 'function' ? test() : test;\n\n      // Set the value (this is the magic, right here).\n      if (featureNameSplit.length === 1) {\n        Modernizr[featureNameSplit[0]] = test;\n      } else {\n        // cast to a Boolean, if not one already\n        if (Modernizr[featureNameSplit[0]] && !(Modernizr[featureNameSplit[0]] instanceof Boolean)) {\n          Modernizr[featureNameSplit[0]] = new Boolean(Modernizr[featureNameSplit[0]]);\n        }\n\n        Modernizr[featureNameSplit[0]][featureNameSplit[1]] = test;\n      }\n\n      // Set a single class (either `feature` or `no-feature`)\n      setClasses([(!!test && test !== false ? '' : 'no-') + featureNameSplit.join('-')]);\n\n      // Trigger the event\n      Modernizr._trigger(feature, test);\n    }\n\n    return Modernizr; // allow chaining.\n  }\n\n  // After all the tests are run, add self to the Modernizr prototype\n  Modernizr._q.push(function() {\n    ModernizrProto.addTest = addTest;\n  });\n\n  \n\n/*!\n{\n  \"name\": \"SVG as an <img> tag source\",\n  \"property\": \"svgasimg\",\n  \"caniuse\": \"svg-img\",\n  \"tags\": [\"svg\"],\n  \"aliases\": [\"svgincss\"],\n  \"authors\": [\"Chris Coyier\"],\n  \"notes\": [{\n    \"name\": \"HTML5 Spec\",\n    \"href\": \"https://www.w3.org/TR/html5/embedded-content-0.html#the-img-element\"\n  }]\n}\n!*/\n\n\n  // Original Async test by Stu Cox\n  // https://gist.github.com/chriscoyier/8774501\n\n  // Now a Sync test based on good results here\n  // https://codepen.io/chriscoyier/pen/bADFx\n\n  // Note http://www.w3.org/TR/SVG11/feature#Image is *supposed* to represent\n  // support for the `<image>` tag in SVG, not an SVG file linked from an `<img>`\n  // tag in HTML – but it’s a heuristic which works\n  Modernizr.addTest('svgasimg', document.implementation.hasFeature('http://www.w3.org/TR/SVG11/feature#Image', '1.1'));\n\n/*!\n{\n  \"name\": \"SVG filters\",\n  \"property\": \"svgfilters\",\n  \"caniuse\": \"svg-filters\",\n  \"tags\": [\"svg\"],\n  \"builderAliases\": [\"svg_filters\"],\n  \"authors\": [\"Erik Dahlstrom\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/SVG11/filters.html\"\n  }]\n}\n!*/\n\n  // Should fail in Safari: https://stackoverflow.com/questions/9739955/feature-detecting-support-for-svg-filters.\n  Modernizr.addTest('svgfilters', function() {\n    var result = false;\n    try {\n      result = 'SVGFEColorMatrixElement' in window &&\n        SVGFEColorMatrixElement.SVG_FECOLORMATRIX_TYPE_SATURATE === 2;\n    }\n    catch (e) {}\n    return result;\n  });\n\n/*!\n{\n  \"name\": \"URL parser\",\n  \"property\": \"urlparser\",\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://url.spec.whatwg.org/\"\n  }],\n  \"polyfills\": [\"urlparser\"],\n  \"authors\": [\"Ron Waldon (@jokeyrhyme)\"],\n  \"tags\": [\"url\"]\n}\n!*/\n/* DOC\nCheck if browser implements the URL constructor for parsing URLs.\n*/\n\n  Modernizr.addTest('urlparser', function() {\n    var url;\n    try {\n      // have to actually try use it, because Safari defines a dud constructor\n      url = new URL('http://modernizr.com/');\n      return url.href === 'http://modernizr.com/';\n    } catch (e) {\n      return false;\n    }\n  });\n\n/*!\n{\n  \"property\": \"urlsearchparams\",\n  \"caniuse\": \"urlsearchparams\",\n  \"tags\": [\"querystring\", \"url\"],\n  \"authors\": [\"Cătălin Mariș\"],\n  \"name\": \"URLSearchParams API\",\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://url.spec.whatwg.org/#interface-urlsearchparams\"\n  }, {\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams\"\n  }]\n}\n!*/\n/* DOC\nDetects support for an API that provides utility methods for working with the query string of a URL.\n*/\n\n  Modernizr.addTest('urlsearchparams', 'URLSearchParams' in window);\n\n/*!\n{\n  \"name\": \"Cross-Origin Resource Sharing\",\n  \"property\": \"cors\",\n  \"caniuse\": \"cors\",\n  \"authors\": [\"Theodoor van Donge\"],\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/HTTP/Access_control_CORS\"\n  }],\n  \"polyfills\": [\"pmxdr\", \"ppx\", \"flxhr\"]\n}\n!*/\n/* DOC\nDetects support for Cross-Origin Resource Sharing: method of performing XMLHttpRequests across domains.\n*/\n\n  Modernizr.addTest('cors', 'XMLHttpRequest' in window && 'withCredentials' in new XMLHttpRequest());\n\n/*!\n{\n  \"name\": \"Web Cryptography\",\n  \"property\": \"cryptography\",\n  \"caniuse\": \"cryptography\",\n  \"tags\": [\"crypto\"],\n  \"authors\": [\"roblarsen\"],\n  \"notes\": [{\n    \"name\": \"W3C Editor's Draft Spec\",\n    \"href\": \"https://www.w3.org/TR/WebCryptoAPI/\"\n  }],\n  \"polyfills\": [\"polycrypt\"]\n}\n!*/\n/* DOC\nDetects support for the cryptographic functionality available under window.crypto.subtle\n*/\n\n  var crypto = prefixed('crypto', window);\n  Modernizr.addTest('crypto', !!prefixed('subtle', crypto));\n\n/*!\n{\n  \"name\": \"iframe[sandbox] Attribute\",\n  \"property\": \"sandbox\",\n  \"caniuse\": \"iframe-sandbox\",\n  \"tags\": [\"iframe\"],\n  \"builderAliases\": [\"iframe_sandbox\"],\n  \"notes\": [\n  {\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://html.spec.whatwg.org/multipage/embedded-content.html#attr-iframe-sandbox\"\n  }],\n  \"knownBugs\": [\"False-positive on Firefox < 29\"]\n}\n!*/\n/* DOC\nTest for `sandbox` attribute in iframes.\n*/\n\n  Modernizr.addTest('sandbox', 'sandbox' in createElement('iframe'));\n\n/*!\n{\n  \"name\": \"JSON\",\n  \"property\": \"json\",\n  \"caniuse\": \"json\",\n  \"notes\": [{\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Glossary/JSON\"\n  }],\n  \"polyfills\": [\"json2\"]\n}\n!*/\n/* DOC\nDetects native support for JSON handling functions.\n*/\n\n  // this will also succeed if you've loaded the JSON2.js polyfill ahead of time\n  //   ... but that should be obvious. :)\n\n  Modernizr.addTest('json', 'JSON' in window && 'parse' in JSON && 'stringify' in JSON);\n\n/*!\n{\n  \"name\": \"Fetch API\",\n  \"property\": \"fetch\",\n  \"tags\": [\"network\"],\n  \"caniuse\": \"fetch\",\n  \"notes\": [{\n    \"name\": \"WHATWG Spec\",\n    \"href\": \"https://fetch.spec.whatwg.org/\"\n  }],\n  \"polyfills\": [\"fetch\"]\n}\n!*/\n/* DOC\nDetects support for the fetch API, a modern replacement for XMLHttpRequest.\n*/\n\n  Modernizr.addTest('fetch', 'fetch' in window);\n\n/*!\n{\n  \"name\": \"Local Storage\",\n  \"property\": \"localstorage\",\n  \"caniuse\": \"namevalue-storage\",\n  \"tags\": [\"storage\"],\n  \"polyfills\": [\n    \"joshuabell-polyfill\",\n    \"cupcake\",\n    \"storagepolyfill\",\n    \"amplifyjs\",\n    \"yui-cacheoffline\"\n  ]\n}\n!*/\n\n  // In FF4, if disabled, window.localStorage should === null.\n\n  // Normally, we could not test that directly and need to do a\n  //   `('localStorage' in window)` test first because otherwise Firefox will\n  //   throw bugzil.la/365772 if cookies are disabled\n\n  // Similarly, in Chrome with \"Block third-party cookies and site data\" enabled,\n  // attempting to access `window.sessionStorage` will throw an exception. crbug.com/357625\n\n  // Also in iOS5 Private Browsing mode, attempting to use localStorage.setItem\n  // will throw the exception:\n  //   QUOTA_EXCEEDED_ERROR DOM Exception 22.\n  // Peculiarly, getItem and removeItem calls do not throw.\n\n  // Because we are forced to try/catch this, we'll go aggressive.\n\n  // Just FWIW: IE8 Compat mode supports these features completely:\n  //   www.quirksmode.org/dom/html5.html\n  // But IE8 doesn't support either with local files\n\n  Modernizr.addTest('localstorage', function() {\n    var mod = 'modernizr';\n    try {\n      localStorage.setItem(mod, mod);\n      localStorage.removeItem(mod);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  });\n\n/*!\n{\n  \"name\": \"ResizeObserver\",\n  \"property\": \"resizeobserver\",\n  \"caniuse\": \"resizeobserver\",\n  \"tags\": [\"ResizeObserver\"],\n  \"authors\": [\"Christian Andersson\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://www.w3.org/TR/resize-observer/\"\n  }, {\n    \"name\": \"MDN Docs\",\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver\"\n  }, {\n    \"name\": \"Web.dev Article\",\n    \"href\": \"https://web.dev/resize-observer/\"\n  }, {\n    \"name\": \"Digital Ocean tutorial\",\n    \"href\": \"https://www.digitalocean.com/community/tutorials/js-resize-observer\"\n  }]\n}\n!*/\n\n/* DOC\nDetects support for ResizeObserver.\n*/\n\n  Modernizr.addTest('resizeobserver', 'ResizeObserver' in window);\n\n/*!\n{\n  \"name\": \"Web Audio API\",\n  \"property\": \"webaudio\",\n  \"caniuse\": \"audio-api\",\n  \"polyfills\": [\"xaudiojs\", \"dynamicaudiojs\", \"audiolibjs\"],\n  \"tags\": [\"audio\", \"media\"],\n  \"builderAliases\": [\"audio_webaudio_api\"],\n  \"authors\": [\"Addy Osmani\"],\n  \"notes\": [{\n    \"name\": \"W3C Spec\",\n    \"href\": \"https://dvcs.w3.org/hg/audio/raw-file/tip/webaudio/specification.html\"\n  }]\n}\n!*/\n/* DOC\nDetects the older non standard webaudio API, (as opposed to the standards based AudioContext API)\n*/\n\n  Modernizr.addTest('webaudio', function() {\n    var prefixed = 'webkitAudioContext' in window;\n    var unprefixed = 'AudioContext' in window;\n\n    if (Modernizr._config.usePrefixes) {\n      return prefixed || unprefixed;\n    }\n    return unprefixed;\n  });\n\n\n  // Run each test\n  testRunner();\n\n  delete ModernizrProto.addTest;\n  delete ModernizrProto.addAsyncTest;\n\n  // Run the things that are supposed to run after the tests\n  for (var i = 0; i < Modernizr._q.length; i++) {\n    Modernizr._q[i]();\n  }\n\n  // Leak Modernizr namespace\n  scriptGlobalObject.Modernizr = Modernizr;\n\n\n;\n\n})(window, window, document);\n","/*\nCopyright 2018-2024 New Vector Ltd.\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport { type QueryDict, decodeParams } from \"matrix-js-sdk/src/utils\";\n\n// We want to support some name / value pairs in the fragment\n// so we're re-using query string like format\n//\nexport function parseQsFromFragment(location: Location): { location: string; params: QueryDict } {\n    // if we have a fragment, it will start with '#', which we need to drop.\n    // (if we don't, this will return '').\n    const fragment = location.hash.substring(1);\n\n    // our fragment may contain a query-param-like section. we need to fish\n    // this out *before* URI-decoding because the params may contain ? and &\n    // characters which are only URI-encoded once.\n    const hashparts = fragment.split(\"?\");\n\n    const result = {\n        location: decodeURIComponent(hashparts[0]),\n        params: <QueryDict>{},\n    };\n\n    if (hashparts.length > 1) {\n        result.params = decodeParams(hashparts[1]);\n    }\n    return result;\n}\n\nexport function parseQs(location: Location): QueryDict {\n    return decodeParams(location.search.substring(1));\n}\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","__webpack_require__.amdD = function () {\n\tthrow new Error('define cannot be used indirect');\n};","__webpack_require__.amdO = {};","__webpack_require__.H = {};\n__webpack_require__.G = (chunkId) => {\n\tObject.keys(__webpack_require__.H).map((key) => {\n\t\t__webpack_require__.H[key](chunkId);\n\t});\n}","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"bundles/\" + __webpack_require__.h() + \"/\" + ({\"1869\":\"styles\",\"2585\":\"intl-segmenter-polyfill\",\"2702\":\"element-web-app\",\"3304\":\"playback.worker\",\"3444\":\"indexeddb.worker\",\"4980\":\"blurhash.worker\",\"5385\":\"init\",\"5607\":\"error-view\"}[chunkId] || chunkId) + \".js\";\n};","// This function allow to reference async chunks\n__webpack_require__.miniCssF = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"bundles/\" + __webpack_require__.h() + \"/\" + {\"1869\":\"styles\",\"5607\":\"error-view\"}[chunkId] + \".css\";\n};","__webpack_require__.h = () => (\"af727d0960b2852f82f5\")","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","__webpack_require__.v = (exports, wasmModuleId, wasmModuleHash, importsObj) => {\n\n\tvar req = fetch(__webpack_require__.p + \"bundles/\" + __webpack_require__.h() + \"/\" + wasmModuleHash + \".wasm\");\n\tvar fallback = () => (req\n\t\t.then((x) => (x.arrayBuffer()))\n\t\t.then((bytes) => (WebAssembly.instantiate(bytes, importsObj)))\n\t\t.then((res) => (Object.assign(exports, res.instance.exports))));\n\treturn req.then((res) => {\n\t\tif (typeof WebAssembly.instantiateStreaming === \"function\") {\n\n\t\t\treturn WebAssembly.instantiateStreaming(res, importsObj)\n\t\t\t\t.then(\n\t\t\t\t\t(res) => (Object.assign(exports, res.instance.exports)),\n\t\t\t\t\t(e) => {\n\t\t\t\t\t\tif(res.headers.get(\"Content-Type\") !== \"application/wasm\") {\n\t\t\t\t\t\t\tconsole.warn(\"`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\\n\", e);\n\t\t\t\t\t\t\treturn fallback();\n\t\t\t\t\t\t}\n\t\t\t\t\t\tthrow e;\n\t\t\t\t\t}\n\t\t\t\t);\n\t\t}\n\t\treturn fallback();\n\t});\n};","var scriptUrl;\nif (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + \"\";\nvar document = __webpack_require__.g.document;\nif (!scriptUrl && document) {\n\tif (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT')\n\t\tscriptUrl = document.currentScript.src;\n\tif (!scriptUrl) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tif(scripts.length) {\n\t\t\tvar i = scripts.length - 1;\n\t\t\twhile (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;\n\t\t}\n\t}\n}\n// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration\n// or pass an empty string (\"\") and set the __webpack_public_path__ variable from your code to use your own logic.\nif (!scriptUrl) throw new Error(\"Automatic publicPath is not supported in this browser\");\nscriptUrl = scriptUrl.replace(/^blob:/, \"\").replace(/#.*$/, \"\").replace(/\\?.*$/, \"\").replace(/\\/[^\\/]+$/, \"/\");\n__webpack_require__.p = scriptUrl + \"../../\";","(() => {\n  if (typeof __webpack_require__ !== 'undefined') {\n    var oldGetScript = __webpack_require__.u;\n    var oldLoadScript = __webpack_require__.e;\n    var queryMap = {};\n    var countMap = {};\n    var getRetryDelay = function () {\n      return 500;\n    };\n    __webpack_require__.u = function (chunkId) {\n      var result = oldGetScript(chunkId);\n      return (\n        result +\n        (queryMap.hasOwnProperty(chunkId) ? '?' + queryMap[chunkId] : '')\n      );\n    };\n    __webpack_require__.e = function (chunkId) {\n      var result = oldLoadScript(chunkId);\n      return result.catch(function (error) {\n        var retries = countMap.hasOwnProperty(chunkId) ? countMap[chunkId] : 3;\n        if (retries < 1) {\n          var realSrc = oldGetScript(chunkId);\n          error.message =\n            'Loading chunk ' +\n            chunkId +\n            ' failed after 3 retries.\\n(' +\n            realSrc +\n            ')';\n          error.request = realSrc;\n          throw error;\n        }\n        return new Promise(function (resolve) {\n          var retryAttempt = 3 - retries + 1;\n          setTimeout(function () {\n            var retryAttemptString = '&retry-attempt=' + retryAttempt;\n            var cacheBust = (() => Date.now())();\n            +retryAttemptString;\n            queryMap[chunkId] = cacheBust;\n            countMap[chunkId] = retries - 1;\n            resolve(__webpack_require__.e(chunkId));\n          }, getRetryDelay(retryAttempt));\n        });\n      });\n    };\n  }\n})();\n","if (typeof document === \"undefined\") return;\nvar createStylesheet = (chunkId, fullhref, oldTag, resolve, reject) => {\n\tvar linkTag = document.createElement(\"link\");\n\n\tlinkTag.rel = \"stylesheet\";\n\tlinkTag.type = \"text/css\";\n\tif (__webpack_require__.nc) {\n\t\tlinkTag.nonce = __webpack_require__.nc;\n\t}\n\tvar onLinkComplete = (event) => {\n\t\t// avoid mem leaks.\n\t\tlinkTag.onerror = linkTag.onload = null;\n\t\tif (event.type === 'load') {\n\t\t\tresolve();\n\t\t} else {\n\t\t\tvar errorType = event && event.type;\n\t\t\tvar realHref = event && event.target && event.target.href || fullhref;\n\t\t\tvar err = new Error(\"Loading CSS chunk \" + chunkId + \" failed.\\n(\" + errorType + \": \" + realHref + \")\");\n\t\t\terr.name = \"ChunkLoadError\";\n\t\t\terr.code = \"CSS_CHUNK_LOAD_FAILED\";\n\t\t\terr.type = errorType;\n\t\t\terr.request = realHref;\n\t\t\tif (linkTag.parentNode) linkTag.parentNode.removeChild(linkTag)\n\t\t\treject(err);\n\t\t}\n\t}\n\tlinkTag.onerror = linkTag.onload = onLinkComplete;\n\tlinkTag.href = fullhref;\n\n\n\tif (oldTag) {\n\t\toldTag.parentNode.insertBefore(linkTag, oldTag.nextSibling);\n\t} else {\n\t\tdocument.head.appendChild(linkTag);\n\t}\n\treturn linkTag;\n};\nvar findStylesheet = (href, fullhref) => {\n\tvar existingLinkTags = document.getElementsByTagName(\"link\");\n\tfor(var i = 0; i < existingLinkTags.length; i++) {\n\t\tvar tag = existingLinkTags[i];\n\t\tvar dataHref = tag.getAttribute(\"data-href\") || tag.getAttribute(\"href\");\n\t\tif(tag.rel === \"stylesheet\" && (dataHref === href || dataHref === fullhref)) return tag;\n\t}\n\tvar existingStyleTags = document.getElementsByTagName(\"style\");\n\tfor(var i = 0; i < existingStyleTags.length; i++) {\n\t\tvar tag = existingStyleTags[i];\n\t\tvar dataHref = tag.getAttribute(\"data-href\");\n\t\tif(dataHref === href || dataHref === fullhref) return tag;\n\t}\n};\nvar loadStylesheet = (chunkId) => {\n\treturn new Promise((resolve, reject) => {\n\t\tvar href = __webpack_require__.miniCssF(chunkId);\n\t\tvar fullhref = __webpack_require__.p + href;\n\t\tif(findStylesheet(href, fullhref)) return resolve();\n\t\tcreateStylesheet(chunkId, fullhref, null, resolve, reject);\n\t});\n}\n// object to store loaded CSS chunks\nvar installedCssChunks = {\n\t3023: 0\n};\n\n__webpack_require__.f.miniCss = (chunkId, promises) => {\n\tvar cssChunks = {\"1869\":1,\"5607\":1};\n\tif(installedCssChunks[chunkId]) promises.push(installedCssChunks[chunkId]);\n\telse if(installedCssChunks[chunkId] !== 0 && cssChunks[chunkId]) {\n\t\tpromises.push(installedCssChunks[chunkId] = loadStylesheet(chunkId).then(() => {\n\t\t\tinstalledCssChunks[chunkId] = 0;\n\t\t}, (e) => {\n\t\t\tdelete installedCssChunks[chunkId];\n\t\t\tthrow e;\n\t\t}));\n\t}\n};\n\n// no hmr\n\n// no prefetching\n\n__webpack_require__.H.miniCss = (chunkId) => {\n\tif((!__webpack_require__.o(installedCssChunks, chunkId) || installedCssChunks[chunkId] === undefined) && /^(1869|3023|5607)$/.test(chunkId)) {\n\t\tinstalledCssChunks[chunkId] = null;\n\t\tvar link = document.createElement('link');\n\t\tlink.charset = 'utf-8';\n\t\tif (__webpack_require__.nc) {\n\t\t\tlink.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tlink.rel = \"preload\";\n\t\tlink.as = \"style\";\n\t\tlink.href = __webpack_require__.p + __webpack_require__.miniCssF(chunkId);\n\t\tdocument.head.appendChild(link);\n\t}\n};","__webpack_require__.b = document.baseURI || self.location.href;\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t3023: 0\n};\n\n__webpack_require__.f.j = (chunkId, promises) => {\n\t\t// JSONP chunk loading for javascript\n\t\tvar installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;\n\t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n\t\t\t// a Promise means \"currently loading\".\n\t\t\tif(installedChunkData) {\n\t\t\t\tpromises.push(installedChunkData[2]);\n\t\t\t} else {\n\t\t\t\tif(true) { // all chunks have JS\n\t\t\t\t\t// setup Promise in chunk cache\n\t\t\t\t\tvar promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));\n\t\t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n\t\t\t\t\t// start chunk loading\n\t\t\t\t\tvar url = __webpack_require__.p + __webpack_require__.u(chunkId);\n\t\t\t\t\t// create error before stack unwound to get useful stacktrace later\n\t\t\t\t\tvar error = new Error();\n\t\t\t\t\tvar loadingEnded = (event) => {\n\t\t\t\t\t\tif(__webpack_require__.o(installedChunks, chunkId)) {\n\t\t\t\t\t\t\tinstalledChunkData = installedChunks[chunkId];\n\t\t\t\t\t\t\tif(installedChunkData !== 0) installedChunks[chunkId] = undefined;\n\t\t\t\t\t\t\tif(installedChunkData) {\n\t\t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n\t\t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n\t\t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n\t\t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n\t\t\t\t\t\t\t\terror.type = errorType;\n\t\t\t\t\t\t\t\terror.request = realSrc;\n\t\t\t\t\t\t\t\tinstalledChunkData[1](error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\t__webpack_require__.l(url, loadingEnded, \"chunk-\" + chunkId, chunkId);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n};\n\n// no prefetching\n\n__webpack_require__.H.j = (chunkId) => {\n\tif((!__webpack_require__.o(installedChunks, chunkId) || installedChunks[chunkId] === undefined) && true) {\n\t\tinstalledChunks[chunkId] = null;\n\t\tvar link = document.createElement('link');\n\n\t\tlink.charset = 'utf-8';\n\t\tif (__webpack_require__.nc) {\n\t\t\tlink.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tlink.rel = \"preload\";\n\t\tlink.as = \"script\";\n\t\tlink.href = __webpack_require__.p + __webpack_require__.u(chunkId);\n\t\tdocument.head.appendChild(link);\n\t}\n};\n\n// no HMR\n\n// no HMR manifest\n\n__webpack_require__.O.j = (chunkId) => (installedChunks[chunkId] === 0);\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\treturn __webpack_require__.O(result);\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunkelement_web\"] = self[\"webpackChunkelement_web\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","__webpack_require__.nc = undefined;","// startup\n// Load entry module and return exports\n// This entry module depends on other loaded chunks and execution need to be delayed\nvar __webpack_exports__ = __webpack_require__.O(undefined, [1040], () => (__webpack_require__(\"./src/vector/index.ts\")))\n__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n"],"names":["deferred","leafPrototypes","getProto","inProgress","dataWebpackPrefix","chunkToChildrenMap","_defineProperty","e","r","t","Object","defineProperty","value","enumerable","configurable","writable","toPrimitive","Symbol","i","call","TypeError","String","Number","toPropertyKey","_typeof","o","iterator","constructor","prototype","exports","Intl","Segmenter","noop","undefinedType","isIE","window","navigator","test","userAgent","logMethods","_loggersByName","defaultLogger","bindMethod","obj","methodName","method","bind","Function","apply","arguments","traceForIE","console","log","trace","realMethod","undefined","replaceLoggingMethods","level","this","getLevel","length","methodFactory","name","debug","levels","SILENT","enableLoggingWhenConsoleArrives","defaultMethodFactory","_level","_loggerName","Logger","factory","inheritedLevel","defaultLevel","userLevel","self","storageKey","persistLevelIfPossible","levelNum","levelName","toUpperCase","localStorage","ignore","document","cookie","encodeURIComponent","getPersistedLevel","storedLevel","cookieName","location","indexOf","exec","slice","clearPersistedLevel","removeItem","normalizeLevel","input","setLevel","persist","setDefaultLevel","resetLevel","enableAll","TRACE","disableAll","rebuild","childName","initialLevel","getLogger","logger","_log","noConflict","getLoggers","LocationAssetType","M_ASSET","UnstableValue","M_TIMESTAMP","M_LOCATION","ReceiptType","MAIN_ROOM_TIMELINE","NamespacedValue","stable","unstable","Error","altName","names","push","matches","val","findIn","includedIn","arr","included","includes","ServerControlledNamespacedValue","args","setPreferUnstable","preferUnstable","super","loglevel","logLevel","loggerName","prefix","unshift","getPrefixedLogger","prefixLogger","getChild","childPrefix","DEBUG","LogSpan","parent","msg","info","warn","error","interns","Map","internaliseString","str","toString","has","set","get","encodeParams","params","urlSearchParams","searchParams","URLSearchParams","key","entries","Array","isArray","forEach","v","append","replaceParam","dict","result","_objectSpread","decodeParams","query","keys","getAll","encodeUri","pathTemplate","variables","hasOwnProperty","replace","removeElement","array","fn","reverse","splice","checkObjectHasKeys","deepCopy","JSON","parse","stringify","deepCompare","x","y","isNaN","RegExp","Date","p","deepSortedObjectEntries","pairs","k","sort","a","b","lexicographicCompare","isNumber","isFinite","removeHiddenChars","unhomoglyph","normalize","removeHiddenCharsRegex","removeDirectionOverrideChars","toLowerCase","escapeRegExp","string","globToRegexp","glob","ensureNoTrailingSlash","url","endsWith","sleep","ms","Promise","resolve","setTimeout","async","logDuration","block","start","now","end","isNullOrUndefined","defer","reject","promise","_resolve","_reject","promiseMapSeries","promises","promiseTry","simpleRetryOperation","promiseFn","promiseRetry","attempt","forever","factor","minTimeout","maxTimeout","DEFAULT_ALPHABET","c","fromCharCode","alphabetPad","s","n","alphabet","padEnd","baseToString","len","BigInt","_alphabet","d","Math","abs","stringToBase","j","charIndex","charCodeAt","averageBetweenStrings","padN","max","baseA","baseB","avg","nextString","prevString","recursivelyAssign","target","source","ignoreNullish","sourceKey","sourceValue","safeSet","getContentTimestampWithFallback","event","_M_TIMESTAMP$findIn","getContent","sortEventsByLatestContentTimestamp","left","right","isSupportedReceiptType","receiptType","Read","ReadPrivate","mapsEqual","eq","v1","v2","size","processMapToObjectValue","recursiveMapToObject","map","targetMap","fromEntries","unsafeProp","prop","noUnsafeEventProps","room_id","sender","event_id","MapWithDefault","createDefault","getOrCreate","retry","networkErrorMsgs","AbortError","message","originalError","stack","pRetry","options","onFailedAttempt","retries","operation","attemptNumber","stop","errorMessage","retriesLeft","decorateErrorWithCounts","mainError","module","RetryOperation","timeouts","Infinity","unref","maxRetryTime","concat","opts","randomize","createTimeout","random","timeout","round","pow","min","wrap","methods","original","op","callback","pop","err","_originalTimeouts","_timeouts","_options","_maxRetryTime","_fn","_errors","_attempts","_operationTimeout","_operationTimeoutCb","_timeout","_operationStart","_timer","_cachedTimeouts","reset","clearTimeout","currentTime","getTime","shift","timeoutOps","cb","try","errors","attempts","counts","mainErrorCount","count","data","REPLACE_RE","join","replace_fn","match","settled","prom","require","supportedBrowser","Modernizr","addTest","_window$Promise","finally","_window$Promise2","allSettled","_window$RegExp","_Object$getOwnPropert","getOwnPropertyDescriptor","_window$Object","_window$Intl","WebAssembly","Module","isSecureContext","featureList","featureComplete","feature","checkBrowserFeatures","shouldPolyFillIntlSegmenter","rageshakePromise","setupLogStorage","preparePlatform","loadConfig","loadLanguage","loadTheme","loadApp","loadModules","loadPlugins","showError","showIncompatibleBrowser","_t","extractErrorMessageFromError","fragparts","parseQsFromFragment","client_secret","isIos","MSStream","isAndroid","href","loadConfigPromise","persistLogsPromise","loadModulesPromise","loadPluginsPromise","loadLanguagePromise","loadThemePromise","acceptBrowser","Boolean","getItem","setItem","catch","SyntaxError","_document$getElementB","body","style","removeProperty","iframe","createElement","src","width","height","position","top","bottom","border","getElementById","appendChild","startsWith","scriptGlobalObject","tests","ModernizrProto","_version","_config","_q","on","addAsyncTest","classes","is","type","omPrefixes","cssomPrefixes","usePrefixes","split","_cssomPrefixes","docElement","documentElement","isSVG","nodeName","createElementNS","modElem","elem","mStyle","injectElementWithStyles","rule","nodes","testnames","ret","node","docOverflow","mod","div","fake","getBody","parseInt","id","styleSheet","cssText","createTextNode","background","overflow","parentNode","removeChild","offsetHeight","domToCSS","m1","nativeTestProps","props","CSS","supports","conditionText","pseudo","getComputedStyle","getPropertyValue","currentStyle","computedStyle","cssToDOM","m2","domPrefixes","fnBind","that","testPropsAll","prefixed","skipValueTest","ucProp","charAt","afterInit","propsLength","before","elems","cleanElems","testProps","item","testDOMProps","testAllProps","_domPrefixes","testStyles","child","childNodes","offsetLeft","aliases","prefixes","_prefixes","newSyntax","oldSyntax","el","documentMode","atRule","cssrule","CSSRule","hasOwnProp","_hasOwnProperty","featureNameSplit","last","className","classPrefix","baseVal","enableJSClass","reJS","enableClasses","setClasses","_trigger","canParseISODate","toISOString","toJSON","create","getPrototypeOf","getOwnPropertyNames","isSealed","isFrozen","isExtensible","defineProperties","seal","freeze","preventExtensions","originalUndefined","copyWithin","fill","find","findIndex","values","from","of","Set","WeakMap","WeakSet","fromCodePoint","raw","codePointAt","repeat","createSVGRect","object","property","_l","res","cbs","implementation","hasFeature","SVGFEColorMatrixElement","SVG_FECOLORMATRIX_TYPE_SATURATE","URL","XMLHttpRequest","crypto","unprefixed","featureNames","aliasIdx","nameIdx","featureIdx","testRunner","hashparts","hash","substring","decodeURIComponent","parseQs","search","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","loaded","__webpack_modules__","m","amdD","amdO","O","chunkIds","priority","notFulfilled","fulfilled","every","H","G","chunkId","getter","__esModule","mode","then","ns","def","current","definition","f","all","reduce","u","h","miniCssF","g","globalThis","l","done","script","needAttach","scripts","getElementsByTagName","getAttribute","charset","nc","setAttribute","onScriptComplete","prev","onerror","onload","doneFns","head","toStringTag","nmd","paths","children","wasmModuleId","wasmModuleHash","importsObj","req","fetch","fallback","arrayBuffer","bytes","instantiate","assign","instance","instantiateStreaming","headers","scriptUrl","importScripts","currentScript","tagName","oldGetScript","oldLoadScript","queryMap","countMap","realSrc","request","cacheBust","loadStylesheet","fullhref","existingLinkTags","dataHref","tag","rel","existingStyleTags","findStylesheet","oldTag","linkTag","nonce","errorType","realHref","code","insertBefore","nextSibling","createStylesheet","installedCssChunks","miniCss","link","as","baseURI","installedChunks","installedChunkData","webpackJsonpCallback","parentChunkLoadingFunction","moreModules","runtime","some","chunkLoadingGlobal","preload","chunks","__webpack_exports__"],"sourceRoot":""}