{"version":3,"file":"ruffle.js","mappings":"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","sources":["webpack://ruffle-selfhosted/webpack/runtime/load script","webpack://ruffle-selfhosted/webpack/bootstrap","webpack://ruffle-selfhosted/webpack/runtime/define property getters","webpack://ruffle-selfhosted/webpack/runtime/ensure chunk","webpack://ruffle-selfhosted/webpack/runtime/get javascript chunk filename","webpack://ruffle-selfhosted/webpack/runtime/global","webpack://ruffle-selfhosted/webpack/runtime/hasOwnProperty shorthand","webpack://ruffle-selfhosted/webpack/runtime/make namespace object","webpack://ruffle-selfhosted/webpack/runtime/publicPath","webpack://ruffle-selfhosted/webpack/runtime/jsonp chunk loading","webpack://ruffle-selfhosted/../../node_modules/wasm-feature-detect/dist/esm/index.js","webpack://ruffle-selfhosted/../core/pkg/js-polyfills.js","webpack://ruffle-selfhosted/../core/pkg/public-path.js","webpack://ruffle-selfhosted/../core/pkg/load-ruffle.js","webpack://ruffle-selfhosted/../core/pkg/plugin-polyfill.js","webpack://ruffle-selfhosted/../core/pkg/shadow-template.js","webpack://ruffle-selfhosted/../core/pkg/register-element.js","webpack://ruffle-selfhosted/../core/pkg/ruffle-player.js","webpack://ruffle-selfhosted/../core/pkg/swf-file-name.js","webpack://ruffle-selfhosted/../core/pkg/ruffle-embed.js","webpack://ruffle-selfhosted/../core/pkg/ruffle-object.js","webpack://ruffle-selfhosted/../core/pkg/polyfills.js","webpack://ruffle-selfhosted/../core/pkg/version.js","webpack://ruffle-selfhosted/../core/pkg/version-range.js","webpack://ruffle-selfhosted/../core/pkg/public-api.js","webpack://ruffle-selfhosted/./js/ruffle.js","webpack://ruffle-selfhosted/../core/pkg/source-api.js"],"sourcesContent":["var inProgress = {};\nvar dataWebpackPrefix = \"ruffle-selfhosted:\";\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\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\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};","// 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\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\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","// 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 \"core.ruffle.\" + {\"662\":\"c03ed0fdc692d589502d\",\"966\":\"ece9e8fa5a7d72d73689\"}[chunkId] + \".js\";\n};","__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__.p = \"\";","__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\t179: 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} else installedChunks[chunkId] = 0;\n\t\t\t}\n\t\t}\n};\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\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\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunkruffle_selfhosted\"] = self[\"webpackChunkruffle_selfhosted\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","export const bigInt=()=>(async e=>{try{return(await WebAssembly.instantiate(e)).instance.exports.b(BigInt(0))===BigInt(0)}catch(e){return!1}})(new Uint8Array([0,97,115,109,1,0,0,0,1,6,1,96,1,126,1,126,3,2,1,0,7,5,1,1,98,0,0,10,6,1,4,0,32,0,11])),bulkMemory=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,4,1,96,0,0,3,2,1,0,5,3,1,0,1,10,14,1,12,0,65,0,65,0,65,0,252,10,0,0,11])),exceptions=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,4,1,96,0,0,3,2,1,0,10,8,1,6,0,6,64,25,11,11])),multiValue=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,6,1,96,0,2,127,127,3,2,1,0,10,8,1,6,0,65,0,65,0,11])),mutableGlobals=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,2,8,1,1,97,1,98,3,127,1,6,6,1,127,1,65,0,11,7,5,1,1,97,3,1])),referenceTypes=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,4,1,96,0,0,3,2,1,0,10,7,1,5,0,208,112,26,11])),saturatedFloatToInt=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,4,1,96,0,0,3,2,1,0,10,12,1,10,0,67,0,0,0,0,252,0,26,11])),signExtensions=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,4,1,96,0,0,3,2,1,0,10,8,1,6,0,65,0,192,26,11])),simd=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,5,1,96,0,1,123,3,2,1,0,10,10,1,8,0,65,0,253,15,253,98,11])),tailCall=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,4,1,96,0,0,3,2,1,0,10,6,1,4,0,18,0,11])),threads=()=>(async e=>{try{return\"undefined\"!=typeof MessageChannel&&(new MessageChannel).port1.postMessage(new SharedArrayBuffer(1)),WebAssembly.validate(e)}catch(e){return!1}})(new Uint8Array([0,97,115,109,1,0,0,0,1,4,1,96,0,0,3,2,1,0,5,4,1,3,1,1,10,11,1,9,0,65,0,254,16,2,0,26,11]));\n","/**\n * Polyfills the `Array.prototype.reduce` method.\n *\n * Production steps of ECMA-262, Edition 5, 15.4.4.21\n * Reference: https://es5.github.io/#x15.4.4.21\n * https://tc39.github.io/ecma262/#sec-array.prototype.reduce\n *\n */\nfunction polyfillArrayPrototypeReduce() {\n    Object.defineProperty(Array.prototype, \"reduce\", {\n        value(...args) {\n            if (args.length === 0 &&\n                window.Prototype &&\n                window.Prototype.Version &&\n                window.Prototype.Version < \"1.6.1\") {\n                // Off-spec: compatibility with prototype.js\n                return this.length > 1 ? this : this[0];\n            }\n            const callback = args[0];\n            if (this === null) {\n                throw new TypeError(\"Array.prototype.reduce called on null or undefined\");\n            }\n            if (typeof callback !== \"function\") {\n                throw new TypeError(`${callback} is not a function`);\n            }\n            const o = Object(this);\n            const len = o.length >>> 0;\n            let k = 0;\n            let value;\n            if (args.length >= 2) {\n                value = args[1];\n            }\n            else {\n                while (k < len && !(k in o)) {\n                    k++;\n                }\n                if (k >= len) {\n                    throw new TypeError(\"Reduce of empty array with no initial value\");\n                }\n                value = o[k++];\n            }\n            while (k < len) {\n                if (k in o) {\n                    value = callback(value, o[k], k, o);\n                }\n                k++;\n            }\n            return value;\n        },\n    });\n}\n/**\n * Polyfills the `Window` function.\n *\n */\nfunction polyfillWindow() {\n    if (typeof window.constructor !== \"function\" ||\n        !isNativeFunction(window.constructor)) {\n        // Don't polyfill `Window` if `window.constructor` has been overridden.\n        return;\n    }\n    // @ts-expect-error: `Function not assignable to { new (): Window; prototype: Window; }`\n    window.Window = window.constructor;\n}\n/**\n * Polyfills the `Reflect` object and members.\n *\n * Currently it's a minimal implementation with only `get` and `set`\n * just enough for wasm-bindgen's stdlib to not crash on pages I've found.\n *\n */\nfunction tryPolyfillReflect() {\n    if (window.Reflect == undefined) {\n        // @ts-expect-error: {} indeed doesn't implement Reflect's interface.\n        window.Reflect = {};\n    }\n    if (typeof Reflect.get !== \"function\") {\n        Object.defineProperty(Reflect, \"get\", {\n            value(target, key) {\n                return target[key];\n            },\n        });\n    }\n    if (typeof Reflect.set !== \"function\") {\n        Object.defineProperty(Reflect, \"set\", {\n            value(target, key, value) {\n                target[key] = value;\n            },\n        });\n    }\n}\n/**\n * Determines whether a function is native or not.\n *\n * @param func The function to test.\n * @returns True if the function hasn't been overridden.\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction isNativeFunction(func) {\n    const val = typeof Function.prototype.toString === \"function\"\n        ? Function.prototype.toString()\n        : null;\n    if (typeof val === \"string\" && val.indexOf(\"[native code]\") >= 0) {\n        return (Function.prototype.toString.call(func).indexOf(\"[native code]\") >= 0);\n    }\n    return false;\n}\n/**\n * Checks and applies the polyfills to the current window, if needed.\n *\n */\nexport function setPolyfillsOnLoad() {\n    if (typeof Array.prototype.reduce !== \"function\" ||\n        !isNativeFunction(Array.prototype.reduce)) {\n        // Some external libraries override the `Array.prototype.reduce` method in a way\n        // that causes Webpack to crash (#1507, #1865), so we need to override it again.\n        polyfillArrayPrototypeReduce();\n    }\n    if (typeof Window !== \"function\" || !isNativeFunction(Window)) {\n        // Overriding the native `Window` function causes issues in wasm-bindgen, as a\n        // code like `window instanceof Window` will no longer work.\n        polyfillWindow();\n    }\n    // Some pages override native `Reflect` with a new object without some properties,\n    // which causes issues for wasm-bindgen's stdlib implementation.\n    tryPolyfillReflect();\n}\n","// This must be in global scope because `document.currentScript`\n// works only while the script is initially being processed.\nlet currentScriptURL = \"\";\ntry {\n    if (document.currentScript !== undefined &&\n        document.currentScript !== null &&\n        \"src\" in document.currentScript &&\n        document.currentScript.src !== \"\") {\n        let src = document.currentScript.src;\n        // CDNs allow omitting the filename. If it's omitted, append a slash to\n        // prevent the last component from being dropped.\n        if (!src.endsWith(\".js\") && !src.endsWith(\"/\")) {\n            src += \"/\";\n        }\n        currentScriptURL = new URL(\".\", src).href;\n    }\n}\ncatch (e) {\n    console.warn(\"Unable to get currentScript URL\");\n}\n/**\n * Attempt to discover the public path of the current Ruffle source. This can\n * be used to configure Webpack.\n *\n * A global public path can be specified for all sources using the RufflePlayer\n * config:\n *\n * ```js\n * window.RufflePlayer.config.publicPath = \"/dist/\";\n * ```\n *\n * If no such config is specified, then the parent path of where this script is\n * hosted is assumed, which should be the correct default in most cases.\n *\n * @param config The `window.RufflePlayer.config` object.\n * @returns The public path for the given source.\n */\nexport function publicPath(config) {\n    // Default to the directory where this script resides.\n    let path = currentScriptURL;\n    if (config !== undefined && config.publicPath !== undefined) {\n        path = config.publicPath;\n    }\n    // Webpack expects the paths to end with a slash.\n    if (path !== \"\" && !path.endsWith(\"/\")) {\n        path += \"/\";\n    }\n    return path;\n}\n","/**\n * Conditional ruffle loader\n */\nimport { bulkMemory, simd, saturatedFloatToInt, signExtensions, } from \"wasm-feature-detect\";\nimport { setPolyfillsOnLoad } from \"./js-polyfills\";\nimport { publicPath } from \"./public-path\";\n/**\n * Load ruffle from an automatically-detected location.\n *\n * This function returns a new instance of Ruffle and downloads it every time.\n * You should not use it directly; this module will memoize the resource\n * download.\n *\n * @param config The `window.RufflePlayer.config` object.\n * @returns A ruffle constructor that may be used to create new Ruffle\n * instances.\n */\nasync function fetchRuffle(config) {\n    // Apply some pure JavaScript polyfills to prevent conflicts with external\n    // libraries, if needed.\n    setPolyfillsOnLoad();\n    // NOTE: Keep this list in sync with $RUSTFLAGS in the CI build config!\n    const extensionsSupported = (await Promise.all([\n        bulkMemory(),\n        simd(),\n        saturatedFloatToInt(),\n        signExtensions(),\n    ])).every(Boolean);\n    if (!extensionsSupported) {\n        console.log(\"Some WebAssembly extensions are NOT available, falling back to the vanilla WebAssembly module\");\n    }\n    __webpack_public_path__ = publicPath(config);\n    // Note: The argument passed to import() has to be a simple string literal,\n    // otherwise some bundler will get confused and won't include the module?\n    const { default: init, Ruffle } = await (extensionsSupported\n        ? import(\"../pkg/ruffle_web-wasm_extensions\")\n        : import(\"../pkg/ruffle_web\"));\n    await init();\n    return Ruffle;\n}\nlet lastLoaded = null;\n/**\n * Obtain an instance of `Ruffle`.\n *\n * This function returns a promise which yields `Ruffle` asynchronously.\n *\n * @param config The `window.RufflePlayer.config` object.\n * @returns A ruffle constructor that may be used to create new Ruffle\n * instances.\n */\nexport function loadRuffle(config) {\n    if (lastLoaded == null) {\n        lastLoaded = fetchRuffle(config);\n    }\n    return lastLoaded;\n}\n","/**\n * Replacement object for `MimeTypeArray` that lets us install new fake mime\n * types.\n *\n * Unlike plugins we can at least enumerate mime types in Firefox, so we don't\n * lose data.\n *\n * We also expose a method called `install` which adds a new plugin. This is\n * used to falsify Flash detection. If the existing `navigator.mimeTypes` has an\n * `install` method, you should not use `RuffleMimeTypeArray` as some other\n * plugin emulator is already present.\n */\nclass RuffleMimeTypeArray {\n    constructor(native_mimetype_array) {\n        this.__mimetypes = [];\n        this.__named_mimetypes = {};\n        if (native_mimetype_array) {\n            for (let i = 0; i < native_mimetype_array.length; i++) {\n                this.install(native_mimetype_array[i]);\n            }\n        }\n    }\n    /**\n     * Install a MIME Type into the array.\n     *\n     * @param mimetype The mimetype to install\n     */\n    install(mimetype) {\n        const id = this.__mimetypes.length;\n        this.__mimetypes.push(mimetype);\n        this.__named_mimetypes[mimetype.type] = mimetype;\n        this[mimetype.type] = mimetype;\n        this[id] = mimetype;\n    }\n    item(index) {\n        return this.__mimetypes[index];\n    }\n    namedItem(name) {\n        return this.__named_mimetypes[name];\n    }\n    get length() {\n        return this.__mimetypes.length;\n    }\n    [Symbol.iterator]() {\n        return this.__mimetypes[Symbol.iterator]();\n    }\n}\n/**\n * Equivalent object to `Plugin` that allows us to falsify plugins.\n */\nclass RufflePlugin extends RuffleMimeTypeArray {\n    constructor(name, description, filename, mimetypes) {\n        super(mimetypes);\n        this.name = name;\n        this.description = description;\n        this.filename = filename;\n    }\n    install(mimetype) {\n        super.install(mimetype);\n    }\n    [Symbol.iterator]() {\n        return super[Symbol.iterator]();\n    }\n}\n/**\n * Replacement object for `PluginArray` that lets us install new fake plugins.\n *\n * This object needs to wrap the native plugin array, since the user might have\n * actual plugins installed. Firefox doesn't let us enumerate the array, though,\n * which has some consequences. Namely, we can't actually perfectly wrap the\n * native plugin array, at least unless there's some secret \"unresolved object\n * property name handler\" that I've never known before in JS...\n *\n * We can still wrap `namedItem` perfectly at least.\n *\n * We also expose a method called `install` which adds a new plugin. This is\n * used to falsify Flash detection. If the existing `navigator.plugins` has an\n * `install` method, you should not use `RufflePluginArray` as some other plugin\n * emulator is already present.\n */\nclass RufflePluginArray {\n    constructor(native_plugin_array) {\n        this.__plugins = [];\n        this.__named_plugins = {};\n        for (let i = 0; i < native_plugin_array.length; i++) {\n            this.install(native_plugin_array[i]);\n        }\n    }\n    install(plugin) {\n        const id = this.__plugins.length;\n        this.__plugins.push(plugin);\n        this.__named_plugins[plugin.name] = plugin;\n        this[plugin.name] = plugin;\n        this[id] = plugin;\n    }\n    item(index) {\n        return this.__plugins[index];\n    }\n    namedItem(name) {\n        return this.__named_plugins[name];\n    }\n    refresh() {\n        // Nothing to do, we just need to define the method.\n    }\n    get length() {\n        return this.__plugins.length;\n    }\n}\n/**\n * A fake plugin designed to trigger Flash detection scripts.\n */\nexport const FLASH_PLUGIN = new RufflePlugin(\"Shockwave Flash\", \"Shockwave Flash 32.0 r0\", \"ruffle.js\", null);\nFLASH_PLUGIN.install({\n    type: \"application/futuresplash\",\n    description: \"Shockwave Flash\",\n    suffixes: \"spl\",\n    enabledPlugin: FLASH_PLUGIN,\n});\nFLASH_PLUGIN.install({\n    type: \"application/x-shockwave-flash\",\n    description: \"Shockwave Flash\",\n    suffixes: \"swf\",\n    enabledPlugin: FLASH_PLUGIN,\n});\nFLASH_PLUGIN.install({\n    type: \"application/x-shockwave-flash2-preview\",\n    description: \"Shockwave Flash\",\n    suffixes: \"swf\",\n    enabledPlugin: FLASH_PLUGIN,\n});\nFLASH_PLUGIN.install({\n    type: \"application/vnd.adobe.flash-movie\",\n    description: \"Shockwave Flash\",\n    suffixes: \"swf\",\n    enabledPlugin: FLASH_PLUGIN,\n});\n/**\n * Install a fake plugin such that detectors will see it in `navigator.plugins`.\n *\n * This function takes care to check if the existing implementation of\n * `navigator.plugins` already accepts fake plugin entries. If so, it will use\n * that version of the plugin array. This allows the plugin polyfill to compose\n * across multiple plugin emulators with the first emulator's polyfill winning.\n *\n * @param plugin The plugin to install\n */\nexport function installPlugin(plugin) {\n    if (!(\"install\" in navigator.plugins) || !navigator.plugins[\"install\"]) {\n        Object.defineProperty(navigator, \"plugins\", {\n            value: new RufflePluginArray(navigator.plugins),\n            writable: false,\n        });\n    }\n    const plugins = navigator.plugins;\n    plugins.install(plugin);\n    if (plugin.length > 0 &&\n        (!(\"install\" in navigator.mimeTypes) || !navigator.mimeTypes[\"install\"])) {\n        Object.defineProperty(navigator, \"mimeTypes\", {\n            value: new RuffleMimeTypeArray(navigator.mimeTypes),\n            writable: false,\n        });\n    }\n    const mimeTypes = navigator.mimeTypes;\n    for (let i = 0; i < plugin.length; i += 1) {\n        mimeTypes.install(plugin[i]);\n    }\n}\n","/**\n * The shadow template which is used to fill the actual Ruffle player element\n * on the page.\n */\nexport const ruffleShadowTemplate = document.createElement(\"template\");\nruffleShadowTemplate.innerHTML = `\n    <style>\n        :host {\n            --ruffle-blue: #37528c;\n            --ruffle-orange: #ffad33;\n\n            display: inline-block;\n            position: relative;\n            /* Default width/height; this will get overridden by user styles/attributes. */\n            width: 550px;\n            height: 400px;\n            font-family: Arial, sans-serif;\n            letter-spacing: 0.4px;\n            touch-action: none;\n            user-select: none;\n            -webkit-user-select: none;\n            -webkit-tap-highlight-color: transparent;\n        }\n\n        /* Ruffle's width/height CSS interferes Safari fullscreen CSS. */\n        /* Ensure that Safari's fullscreen mode actually fills the screen. */\n        :host(:-webkit-full-screen) {\n            display: block;\n            width: 100% !important;\n            height: 100% !important;\n        }\n\n        /* All of these use the dimensions specified by the embed. */\n        #container,\n        #play_button,\n        #unmute_overlay,\n        #unmute_overlay .background,\n        #panic,\n        #message_overlay {\n            position: absolute;\n            top: 0;\n            bottom: 0;\n            left: 0;\n            right: 0;\n        }\n\n        #container {\n            overflow: hidden;\n        }\n\n        #container canvas {\n            width: 100%;\n            height: 100%;\n        }\n\n        #play_button,\n        #unmute_overlay {\n            cursor: pointer;\n            display: none;\n        }\n\n        #unmute_overlay .background {\n            background: black;\n            opacity: 0.7;\n        }\n\n        #play_button .icon,\n        #unmute_overlay .icon {\n            position: absolute;\n            top: 50%;\n            left: 50%;\n            width: 50%;\n            height: 50%;\n            max-width: 384px;\n            max-height: 384px;\n            transform: translate(-50%, -50%);\n            opacity: 0.8;\n        }\n\n        #play_button:hover .icon,\n        #unmute_overlay:hover .icon {\n            opacity: 1;\n        }\n\n        #panic {\n            font-size: 20px;\n            text-align: center;\n            /* Inverted colors from play button! */\n            background: linear-gradient(180deg, #fd3a40 0%, #fda138 100%);\n            color: white;\n            display: flex;\n            flex-flow: column;\n            justify-content: space-around;\n        }\n\n        #panic a {\n            color: var(--ruffle-blue);\n            font-weight: bold;\n        }\n\n        #panic-title {\n            font-size: xxx-large;\n            font-weight: bold;\n        }\n\n        #panic-body.details {\n            flex: 0.9;\n            margin: 0 10px;\n        }\n\n        #panic-body textarea {\n            width: 100%;\n            height: 100%;\n            resize: none;\n        }\n\n        #panic ul {\n            padding: 0;\n            display: flex;\n            list-style-type: none;\n            justify-content: space-evenly;\n        }\n\n        #message_overlay {\n            position: absolute;\n            background: var(--ruffle-blue);\n            color: var(--ruffle-orange);\n            opacity: 1;\n            z-index: 2;\n            display: flex;\n            align-items: center;\n            justify-content: center;\n            overflow: auto;\n        }\n\n        #message_overlay .message {\n            text-align: center;\n            max-height: 100%;\n            max-width: 100%;\n            padding: 5%;\n        }\n\n        #message_overlay p {\n            margin: 0.5em 0;\n        }\n\n        #message_overlay .message div {\n            display: flex;\n            justify-content: center;\n            flex-wrap: wrap;\n            column-gap: 1em;\n        }\n\n        #message_overlay a, #message_overlay button {\n            cursor: pointer;\n            background: var(--ruffle-blue);\n            color: var(--ruffle-orange);\n            border: 2px solid var(--ruffle-orange);\n            font-weight: bold;\n            font-size: 1.25em;\n            border-radius: 0.6em;\n            padding: 10px;\n            text-decoration: none;\n            margin: 2% 0;\n        }\n\n        #message_overlay a:hover, #message_overlay button:hover {\n            background: #ffffff4c;\n        }\n\n        #continue-btn {\n             cursor: pointer;\n             background: var(--ruffle-blue);\n             color: var(--ruffle-orange);\n             border: 2px solid var(--ruffle-orange);\n             font-weight: bold;\n             font-size: 20px;\n             border-radius: 20px;\n             padding: 10px;\n        }\n\n        #continue-btn:hover {\n            background: #ffffff4c;\n        }\n\n        #context-menu {\n            display: none;\n            color: black;\n            background: #fafafa;\n            border: 1px solid gray;\n            box-shadow: 0px 5px 10px -5px black;\n            position: absolute;\n            font-size: 14px;\n            text-align: left;\n            list-style: none;\n            padding: 0;\n            margin: 0;\n        }\n\n        #context-menu .menu_item {\n            padding: 5px 10px;\n            cursor: pointer;\n            color: black;\n        }\n\n        #context-menu .menu_item.disabled {\n            cursor: default;\n            color: gray;\n        }\n\n        #context-menu .menu_item:not(.disabled):hover {\n            background: lightgray;\n        }\n\n        #context-menu .menu_separator hr {\n            border: none;\n            border-bottom: 1px solid lightgray;\n            margin: 2px;\n        }\n    </style>\n    <style id=\"dynamic_styles\"></style>\n\n    <div id=\"container\">\n        <div id=\"play_button\"><div class=\"icon\"><svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" preserveAspectRatio=\"xMidYMid\" viewBox=\"0 0 250 250\" style=\"width:100%;height:100%;\"><defs><linearGradient id=\"a\" gradientUnits=\"userSpaceOnUse\" x1=\"125\" y1=\"0\" x2=\"125\" y2=\"250\" spreadMethod=\"pad\"><stop offset=\"0%\" stop-color=\"#FDA138\"/><stop offset=\"100%\" stop-color=\"#FD3A40\"/></linearGradient><g id=\"b\"><path fill=\"url(#a)\" d=\"M250 125q0-52-37-88-36-37-88-37T37 37Q0 73 0 125t37 88q36 37 88 37t88-37q37-36 37-88M87 195V55l100 70-100 70z\"/><path fill=\"#FFF\" d=\"M87 55v140l100-70L87 55z\"/></g></defs><use xlink:href=\"#b\"/></svg></div></div>\n        <div id=\"unmute_overlay\"><div class=\"background\"></div><div class=\"icon\"><svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" preserveAspectRatio=\"xMidYMid\" viewBox=\"0 0 512 584\" style=\"width:100%;height:100%;scale:0.8;\"><path fill=\"#FFF\" stroke=\"#FFF\" d=\"m457.941 256 47.029-47.029c9.372-9.373 9.372-24.568 0-33.941-9.373-9.373-24.568-9.373-33.941 0l-47.029 47.029-47.029-47.029c-9.373-9.373-24.568-9.373-33.941 0-9.372 9.373-9.372 24.568 0 33.941l47.029 47.029-47.029 47.029c-9.372 9.373-9.372 24.568 0 33.941 4.686 4.687 10.827 7.03 16.97 7.03s12.284-2.343 16.971-7.029l47.029-47.03 47.029 47.029c4.687 4.687 10.828 7.03 16.971 7.03s12.284-2.343 16.971-7.029c9.372-9.373 9.372-24.568 0-33.941z\"/><path fill=\"#FFF\" stroke=\"#FFF\" d=\"m99 160h-55c-24.301 0-44 19.699-44 44v104c0 24.301 19.699 44 44 44h55c2.761 0 5-2.239 5-5v-182c0-2.761-2.239-5-5-5z\"/><path fill=\"#FFF\" stroke=\"#FFF\" d=\"m280 56h-24c-5.269 0-10.392 1.734-14.578 4.935l-103.459 79.116c-1.237.946-1.963 2.414-1.963 3.972v223.955c0 1.557.726 3.026 1.963 3.972l103.459 79.115c4.186 3.201 9.309 4.936 14.579 4.936h23.999c13.255 0 24-10.745 24-24v-352.001c0-13.255-10.745-24-24-24z\"/><text x=\"256\" y=\"560\" text-anchor=\"middle\" style=\"font-size:60px;fill:#FFF;stroke:#FFF;\">Click to unmute</text></svg></div></div>\n    </div>\n\n    <ul id=\"context-menu\"></ul>\n`;\n","/**\n * Number of times to try defining a custom element.\n */\nconst MAX_TRIES = 999;\n/**\n * A mapping between internal element IDs and DOM element IDs.\n */\nconst privateRegistry = {};\n/**\n * Lookup a previously registered custom element.\n *\n * The returned object will have `name`, `class`, and `internal_name`\n * properties listing the external name, implementing class, and internal name\n * respectively.\n *\n * @param elementName The internal element name, previously used to\n * register the element with the private registry.\n * @returns The element data in the registry, or null if there is\n * no such element name registered.\n */\nexport function lookupElement(elementName) {\n    const data = privateRegistry[elementName];\n    if (data !== undefined) {\n        return {\n            internalName: elementName,\n            name: data.name,\n            class: data.class,\n        };\n    }\n    else {\n        return null;\n    }\n}\n/**\n * Register a custom element.\n *\n * This function is designed to be tolerant of naming conflicts. If\n * registration fails, we modify the name, and try again. As a result, this\n * function returns the real element name to use.\n *\n * Calling this function multiple times will *not* register multiple elements.\n * We store a private registry mapping internal element names to DOM names.\n * Thus, the proper way to use this function is to call it every time you are\n * about to work with custom element names.\n *\n * @param elementName The internal name of the element.\n * @param elementClass The class of the element.\n *\n * You must call this function with the same class every time.\n * @returns The actual element name.\n * @throws Throws an error if two different elements were registered with the\n * same internal name.\n */\nexport function registerElement(elementName, elementClass) {\n    if (privateRegistry[elementName] !== undefined) {\n        if (privateRegistry[elementName].class !== elementClass) {\n            throw new Error(\"Internal naming conflict on \" + elementName);\n        }\n        else {\n            return privateRegistry[elementName].name;\n        }\n    }\n    let tries = 0;\n    if (window.customElements !== undefined) {\n        while (tries < MAX_TRIES) {\n            let externalName = elementName;\n            if (tries > 0) {\n                externalName = externalName + \"-\" + tries;\n            }\n            if (window.customElements.get(externalName) !== undefined) {\n                tries += 1;\n                continue;\n            }\n            else {\n                window.customElements.define(externalName, elementClass);\n            }\n            privateRegistry[elementName] = {\n                class: elementClass,\n                name: externalName,\n                internalName: elementName,\n            };\n            return externalName;\n        }\n    }\n    throw new Error(\"Failed to assign custom element \" + elementName);\n}\n","import { loadRuffle } from \"./load-ruffle\";\nimport { ruffleShadowTemplate } from \"./shadow-template\";\nimport { lookupElement } from \"./register-element\";\nimport { swfFileName } from \"./swf-file-name\";\nexport const FLASH_MIMETYPE = \"application/x-shockwave-flash\";\nexport const FUTURESPLASH_MIMETYPE = \"application/futuresplash\";\nexport const FLASH7_AND_8_MIMETYPE = \"application/x-shockwave-flash2-preview\";\nexport const FLASH_MOVIE_MIMETYPE = \"application/vnd.adobe.flash-movie\";\nexport const FLASH_ACTIVEX_CLASSID = \"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000\";\nconst RUFFLE_ORIGIN = \"https://ruffle.rs\";\nconst DIMENSION_REGEX = /^\\s*(\\d+(\\.\\d+)?(%)?)/;\nlet isAudioContextUnmuted = false;\n/**\n * Converts arbitrary input to an easy to use record object.\n *\n * @param parameters Parameters to sanitize\n * @returns A sanitized map of param name to param value\n */\nfunction sanitizeParameters(parameters) {\n    if (parameters === null || parameters === undefined) {\n        return {};\n    }\n    if (!(parameters instanceof URLSearchParams)) {\n        parameters = new URLSearchParams(parameters);\n    }\n    const output = {};\n    for (const [key, value] of parameters) {\n        // Every value must be type of string\n        output[key] = value.toString();\n    }\n    return output;\n}\n/**\n * The ruffle player element that should be inserted onto the page.\n *\n * This element will represent the rendered and intractable flash movie.\n */\nexport class RufflePlayer extends HTMLElement {\n    /**\n     * Constructs a new Ruffle flash player for insertion onto the page.\n     */\n    constructor() {\n        super();\n        this.hasContextMenu = false;\n        // Allows the user to permanently disable the context menu.\n        this.contextMenuForceDisabled = false;\n        // Whether this device is a touch device.\n        // Set to true when a touch event is encountered.\n        this.isTouch = false;\n        this.showSwfDownload = false;\n        this.panicked = false;\n        this.isExtension = false;\n        /**\n         * Any configuration that should apply to this specific player.\n         * This will be defaulted with any global configuration.\n         */\n        this.config = {};\n        this.shadow = this.attachShadow({ mode: \"open\" });\n        this.shadow.appendChild(ruffleShadowTemplate.content.cloneNode(true));\n        this.dynamicStyles = (this.shadow.getElementById(\"dynamic_styles\"));\n        this.container = this.shadow.getElementById(\"container\");\n        this.playButton = this.shadow.getElementById(\"play_button\");\n        if (this.playButton) {\n            this.playButton.addEventListener(\"click\", () => this.play());\n        }\n        this.unmuteOverlay = this.shadow.getElementById(\"unmute_overlay\");\n        this.contextMenuElement = this.shadow.getElementById(\"context-menu\");\n        this.addEventListener(\"contextmenu\", this.showContextMenu.bind(this));\n        this.addEventListener(\"pointerdown\", this.pointerDown.bind(this));\n        this.addEventListener(\"fullscreenchange\", this.fullScreenChange.bind(this));\n        this.addEventListener(\"webkitfullscreenchange\", this.fullScreenChange.bind(this));\n        window.addEventListener(\"click\", this.hideContextMenu.bind(this));\n        this.instance = null;\n        this.options = null;\n        this.onFSCommand = null;\n        this._readyState = 0 /* HaveNothing */;\n        this._metadata = null;\n        this.lastActivePlayingState = false;\n        this.setupPauseOnTabHidden();\n        return this;\n    }\n    /**\n     * Indicates the readiness of the playing movie.\n     *\n     * @returns The `ReadyState` of the player.\n     */\n    get readyState() {\n        return this._readyState;\n    }\n    /**\n     * The metadata of the playing movie (such as movie width and height).\n     * These are inherent properties stored in the SWF file and are not affected by runtime changes.\n     * For example, `metadata.width` is the width of the SWF file, and not the width of the Ruffle player.\n     *\n     * @returns The metadata of the movie, or `null` if the movie metadata has not yet loaded.\n     */\n    get metadata() {\n        return this._metadata;\n    }\n    /**\n     * Setup event listener to detect when tab is not active to pause instance playback.\n     * this.instance.play() is called when the tab becomes visible only if the\n     * the instance was not paused before tab became hidden.\n     *\n     * See:\n     *      https://developer.mozilla.org/en-US/docs/Web/API/Page_Visibility_API\n     * @ignore\n     * @internal\n     */\n    setupPauseOnTabHidden() {\n        document.addEventListener(\"visibilitychange\", () => {\n            if (!this.instance)\n                return;\n            // Tab just changed to be inactive. Record whether instance was playing.\n            if (document.hidden) {\n                this.lastActivePlayingState = this.instance.is_playing();\n                this.instance.pause();\n            }\n            // Play only if instance was playing originally.\n            if (!document.hidden && this.lastActivePlayingState === true) {\n                this.instance.play();\n            }\n        }, false);\n    }\n    /**\n     * @ignore\n     * @internal\n     */\n    connectedCallback() {\n        this.updateStyles();\n    }\n    /**\n     * @ignore\n     * @internal\n     */\n    static get observedAttributes() {\n        return [\"width\", \"height\"];\n    }\n    /**\n     * @ignore\n     * @internal\n     */\n    attributeChangedCallback(name, _oldValue, _newValue) {\n        if (name === \"width\" || name === \"height\") {\n            this.updateStyles();\n        }\n    }\n    /**\n     * @ignore\n     * @internal\n     */\n    disconnectedCallback() {\n        this.destroy();\n    }\n    /**\n     * Updates the internal shadow DOM to reflect any set attributes from\n     * this element.\n     *\n     * @protected\n     */\n    updateStyles() {\n        if (this.dynamicStyles.sheet) {\n            if (this.dynamicStyles.sheet.rules) {\n                for (let i = 0; i < this.dynamicStyles.sheet.rules.length; i++) {\n                    this.dynamicStyles.sheet.deleteRule(i);\n                }\n            }\n            const widthAttr = this.attributes.getNamedItem(\"width\");\n            if (widthAttr !== undefined && widthAttr !== null) {\n                const width = RufflePlayer.htmlDimensionToCssDimension(widthAttr.value);\n                if (width !== null) {\n                    this.dynamicStyles.sheet.insertRule(`:host { width: ${width}; }`);\n                }\n            }\n            const heightAttr = this.attributes.getNamedItem(\"height\");\n            if (heightAttr !== undefined && heightAttr !== null) {\n                const height = RufflePlayer.htmlDimensionToCssDimension(heightAttr.value);\n                if (height !== null) {\n                    this.dynamicStyles.sheet.insertRule(`:host { height: ${height}; }`);\n                }\n            }\n        }\n    }\n    /**\n     * Determine if this element is the fallback content of another Ruffle\n     * player.\n     *\n     * This heuristic assumes Ruffle objects will never use their fallback\n     * content. If this changes, then this code also needs to change.\n     *\n     * @private\n     */\n    isUnusedFallbackObject() {\n        let parent = this.parentNode;\n        const element = lookupElement(\"ruffle-object\");\n        if (element !== null) {\n            while (parent != document && parent != null) {\n                if (parent.nodeName === element.name) {\n                    return true;\n                }\n                parent = parent.parentNode;\n            }\n        }\n        return false;\n    }\n    /**\n     * Ensure a fresh Ruffle instance is ready on this player before continuing.\n     *\n     * @throws Any exceptions generated by loading Ruffle Core will be logged\n     * and passed on.\n     *\n     * @private\n     */\n    async ensureFreshInstance(config) {\n        var _a;\n        this.destroy();\n        const ruffleConstructor = await loadRuffle(config).catch((e) => {\n            console.error(`Serious error loading Ruffle: ${e}`);\n            // Serious duck typing. In error conditions, let's not make assumptions.\n            if (window.location.protocol === \"file:\") {\n                e.ruffleIndexError = 2 /* FileProtocol */;\n            }\n            else {\n                e.ruffleIndexError = 9 /* WasmNotFound */;\n                const message = String(e.message).toLowerCase();\n                if (message.includes(\"mime\")) {\n                    e.ruffleIndexError = 8 /* WasmMimeType */;\n                }\n                else if (message.includes(\"networkerror\") ||\n                    message.includes(\"failed to fetch\")) {\n                    e.ruffleIndexError = 6 /* WasmCors */;\n                }\n                else if (message.includes(\"disallowed by embedder\")) {\n                    e.ruffleIndexError = 1 /* CSPConflict */;\n                }\n                else if (e.name === \"CompileError\") {\n                    e.ruffleIndexError = 3 /* InvalidWasm */;\n                }\n                else if (message.includes(\"could not download wasm module\") &&\n                    e.name === \"TypeError\") {\n                    e.ruffleIndexError = 7 /* WasmDownload */;\n                }\n                else if (e.name === \"TypeError\") {\n                    e.ruffleIndexError = 5 /* JavascriptConflict */;\n                }\n                else if (navigator.userAgent.includes(\"Edg\") &&\n                    message.includes(\"webassembly is not defined\")) {\n                    // Microsoft Edge detection.\n                    e.ruffleIndexError = 10 /* WasmDisabledMicrosoftEdge */;\n                }\n            }\n            this.panic(e);\n            throw e;\n        });\n        this.instance = await new ruffleConstructor(this.container, this, config);\n        console.log(\"New Ruffle instance created (WebAssembly extensions: \" +\n            (ruffleConstructor.is_wasm_simd_used() ? \"ON\" : \"OFF\") +\n            \")\");\n        // In Firefox, AudioContext.state is always \"suspended\" when the object has just been created.\n        // It may change by itself to \"running\" some milliseconds later. So we need to wait a little\n        // bit before checking if autoplay is supported and applying the instance config.\n        if (this.audioState() !== \"running\") {\n            this.container.style.visibility = \"hidden\";\n            await new Promise((resolve) => {\n                window.setTimeout(() => {\n                    resolve();\n                }, 200);\n            });\n            this.container.style.visibility = \"\";\n        }\n        this.unmuteAudioContext();\n        // Treat unspecified and invalid values as `AutoPlay.Auto`.\n        if (config.autoplay === \"on\" /* On */ ||\n            (config.autoplay !== \"off\" /* Off */ &&\n                this.audioState() === \"running\")) {\n            this.play();\n            if (this.audioState() !== \"running\") {\n                // Treat unspecified and invalid values as `UnmuteOverlay.Visible`.\n                if (config.unmuteOverlay !== \"hidden\" /* Hidden */) {\n                    this.unmuteOverlay.style.display = \"block\";\n                }\n                this.container.addEventListener(\"click\", this.unmuteOverlayClicked.bind(this), {\n                    once: true,\n                });\n                const audioContext = (_a = this.instance) === null || _a === void 0 ? void 0 : _a.audio_context();\n                if (audioContext) {\n                    audioContext.onstatechange = () => {\n                        if (audioContext.state === \"running\") {\n                            this.unmuteOverlayClicked();\n                        }\n                        audioContext.onstatechange = null;\n                    };\n                }\n            }\n        }\n        else {\n            this.playButton.style.display = \"block\";\n        }\n    }\n    /**\n     * Destroys the currently running instance of Ruffle.\n     */\n    destroy() {\n        if (this.instance) {\n            this.instance.destroy();\n            this.instance = null;\n            this._metadata = null;\n            this._readyState = 0 /* HaveNothing */;\n            console.log(\"Ruffle instance destroyed.\");\n        }\n    }\n    /**\n     * Loads a specified movie into this player.\n     *\n     * This will replace any existing movie that may be playing.\n     *\n     * @param options One of the following:\n     * - A URL, passed as a string, which will load a URL with default options.\n     * - A [[URLLoadOptions]] object, to load a URL with options.\n     * - A [[DataLoadOptions]] object, to load data with options.\n     *\n     * The options will be defaulted by the [[config]] field, which itself\n     * is defaulted by a global `window.RufflePlayer.config`.\n     */\n    async load(options) {\n        var _a, _b;\n        let optionsError = \"\";\n        switch (typeof options) {\n            case \"string\":\n                options = { url: options };\n                break;\n            case \"object\":\n                if (options === null) {\n                    optionsError = \"Argument 0 must be a string or object\";\n                }\n                else if (!(\"url\" in options) && !(\"data\" in options)) {\n                    optionsError =\n                        \"Argument 0 must contain a `url` or `data` key\";\n                }\n                else if (\"url\" in options &&\n                    typeof options.url !== \"string\") {\n                    optionsError = \"`url` must be a string\";\n                }\n                break;\n            default:\n                optionsError = \"Argument 0 must be a string or object\";\n                break;\n        }\n        if (optionsError.length > 0) {\n            const error = new TypeError(optionsError);\n            error.ruffleIndexError = 4 /* JavascriptConfiguration */;\n            this.panic(error);\n            throw error;\n        }\n        if (!this.isConnected || this.isUnusedFallbackObject()) {\n            console.warn(\"Ignoring attempt to play a disconnected or suspended Ruffle element\");\n            return;\n        }\n        if (isFallbackElement(this)) {\n            // Silently fail on attempt to play a Ruffle element inside a specific node.\n            return;\n        }\n        try {\n            const config = Object.assign(Object.assign(Object.assign({}, ((_b = (_a = window.RufflePlayer) === null || _a === void 0 ? void 0 : _a.config) !== null && _b !== void 0 ? _b : {})), this.config), options);\n            // `allowScriptAccess` can only be set in `options`.\n            config.allowScriptAccess = options.allowScriptAccess;\n            this.showSwfDownload = config.showSwfDownload === true;\n            this.options = options;\n            this.hasContextMenu = config.contextMenu !== false;\n            // Pre-emptively set background color of container while Ruffle/SWF loads.\n            if (config.backgroundColor) {\n                this.container.style.backgroundColor = config.backgroundColor;\n            }\n            await this.ensureFreshInstance(config);\n            if (\"url\" in options) {\n                console.log(`Loading SWF file ${options.url}`);\n                this.swfUrl = new URL(options.url, document.location.href);\n                const parameters = Object.assign(Object.assign({}, sanitizeParameters(options.url.substring(options.url.indexOf(\"?\")))), sanitizeParameters(options.parameters));\n                this.instance.stream_from(this.swfUrl.href, parameters);\n            }\n            else if (\"data\" in options) {\n                console.log(\"Loading SWF data\");\n                this.instance.load_data(new Uint8Array(options.data), sanitizeParameters(options.parameters));\n            }\n        }\n        catch (err) {\n            console.error(`Serious error occurred loading SWF file: ${err}`);\n            throw err;\n        }\n    }\n    /**\n     * Plays or resumes the movie.\n     */\n    play() {\n        if (this.instance) {\n            this.instance.play();\n            if (this.playButton) {\n                this.playButton.style.display = \"none\";\n            }\n        }\n    }\n    /**\n     * Whether this player is currently playing.\n     *\n     * @returns True if this player is playing, false if it's paused or hasn't started yet.\n     */\n    get isPlaying() {\n        if (this.instance) {\n            return this.instance.is_playing();\n        }\n        return false;\n    }\n    /**\n     * Checks if this player is allowed to be fullscreen by the browser.\n     *\n     * @returns True if you may call [[enterFullscreen]].\n     */\n    get fullscreenEnabled() {\n        return !!(document.fullscreenEnabled || document.webkitFullscreenEnabled);\n    }\n    /**\n     * Checks if this player is currently fullscreen inside the browser.\n     *\n     * @returns True if it is fullscreen.\n     */\n    get isFullscreen() {\n        return ((document.fullscreenElement || document.webkitFullscreenElement) ===\n            this);\n    }\n    /**\n     * Exported function that requests the browser to change the fullscreen state if\n     * it is allowed.\n     *\n     * @param isFull Whether to set to fullscreen or return to normal.\n     */\n    setFullscreen(isFull) {\n        if (this.fullscreenEnabled) {\n            if (isFull) {\n                this.enterFullscreen();\n            }\n            else {\n                this.exitFullscreen();\n            }\n        }\n    }\n    /**\n     * Requests the browser to make this player fullscreen.\n     *\n     * This is not guaranteed to succeed, please check [[fullscreenEnabled]] first.\n     */\n    enterFullscreen() {\n        const options = {\n            navigationUI: \"hide\",\n        };\n        if (this.requestFullscreen) {\n            this.requestFullscreen(options);\n        }\n        else if (this.webkitRequestFullscreen) {\n            this.webkitRequestFullscreen(options);\n        }\n        else if (this.webkitRequestFullScreen) {\n            this.webkitRequestFullScreen(options);\n        }\n    }\n    /**\n     * Requests the browser to no longer make this player fullscreen.\n     */\n    exitFullscreen() {\n        if (document.exitFullscreen) {\n            document.exitFullscreen();\n        }\n        else if (document.webkitExitFullscreen) {\n            document.webkitExitFullscreen();\n        }\n        else if (document.webkitCancelFullScreen) {\n            document.webkitCancelFullScreen();\n        }\n    }\n    /**\n     * Called when entering / leaving fullscreen\n     */\n    fullScreenChange() {\n        var _a;\n        (_a = this.instance) === null || _a === void 0 ? void 0 : _a.set_fullscreen(this.isFullscreen);\n    }\n    pointerDown(event) {\n        // Give option to disable context menu when touch support is being used\n        // to avoid a long press triggering the context menu. (#1972)\n        if (event.pointerType === \"touch\" || event.pointerType === \"pen\") {\n            this.isTouch = true;\n        }\n    }\n    /**\n     * Fetches the loaded SWF and downloads it.\n     */\n    async downloadSwf() {\n        try {\n            if (this.swfUrl) {\n                console.log(\"Downloading SWF: \" + this.swfUrl);\n                const response = await fetch(this.swfUrl.href);\n                if (!response.ok) {\n                    console.error(\"SWF download failed\");\n                    return;\n                }\n                const blob = await response.blob();\n                const blobUrl = URL.createObjectURL(blob);\n                const swfDownloadA = document.createElement(\"a\");\n                swfDownloadA.style.display = \"none\";\n                swfDownloadA.href = blobUrl;\n                swfDownloadA.download = swfFileName(this.swfUrl);\n                document.body.appendChild(swfDownloadA);\n                swfDownloadA.click();\n                document.body.removeChild(swfDownloadA);\n                URL.revokeObjectURL(blobUrl);\n            }\n            else {\n                console.error(\"SWF download failed\");\n            }\n        }\n        catch (err) {\n            console.error(\"SWF download failed\");\n        }\n    }\n    contextMenuItems() {\n        const CHECKMARK = String.fromCharCode(0x2713);\n        const items = [];\n        if (this.instance) {\n            const customItems = this.instance.prepare_context_menu();\n            customItems.forEach((item, index) => {\n                if (item.separatorBefore)\n                    items.push(null);\n                items.push({\n                    // TODO: better checkboxes\n                    text: item.caption + (item.checked ? ` (${CHECKMARK})` : ``),\n                    onClick: () => { var _a; return (_a = this.instance) === null || _a === void 0 ? void 0 : _a.run_context_menu_callback(index); },\n                    enabled: item.enabled,\n                });\n            });\n        }\n        items.push(null);\n        if (this.fullscreenEnabled) {\n            if (this.isFullscreen) {\n                items.push({\n                    text: \"Exit fullscreen\",\n                    onClick: () => { var _a; return (_a = this.instance) === null || _a === void 0 ? void 0 : _a.set_fullscreen(false); },\n                });\n            }\n            else {\n                items.push({\n                    text: \"Enter fullscreen\",\n                    onClick: () => { var _a; return (_a = this.instance) === null || _a === void 0 ? void 0 : _a.set_fullscreen(true); },\n                });\n            }\n        }\n        if (this.instance && this.swfUrl && this.showSwfDownload) {\n            items.push(null);\n            items.push({\n                text: `Download .swf`,\n                onClick: this.downloadSwf.bind(this),\n            });\n        }\n        items.push(null);\n        const extensionString = this.isExtension ? \"extension\" : \"\";\n        items.push({\n            text: `About Ruffle ${extensionString} (nightly 2022-03-10)`,\n            onClick() {\n                window.open(RUFFLE_ORIGIN, \"_blank\");\n            },\n        });\n        if (this.isTouch) {\n            items.push(null);\n            items.push({\n                text: \"Hide this menu\",\n                onClick: () => (this.contextMenuForceDisabled = true),\n            });\n        }\n        return items;\n    }\n    showContextMenu(e) {\n        e.preventDefault();\n        if (!this.hasContextMenu || this.contextMenuForceDisabled) {\n            return;\n        }\n        // Clear all context menu items.\n        while (this.contextMenuElement.firstChild) {\n            this.contextMenuElement.removeChild(this.contextMenuElement.firstChild);\n        }\n        // Populate context menu items.\n        for (const item of this.contextMenuItems()) {\n            if (item === null) {\n                if (!this.contextMenuElement.lastElementChild)\n                    continue; // don't start with separators\n                if (this.contextMenuElement.lastElementChild.classList.contains(\"menu_separator\"))\n                    continue; // don't repeat separators\n                const menuSeparator = document.createElement(\"li\");\n                menuSeparator.className = \"menu_separator\";\n                const hr = document.createElement(\"hr\");\n                menuSeparator.appendChild(hr);\n                this.contextMenuElement.appendChild(menuSeparator);\n            }\n            else {\n                const { text, onClick, enabled } = item;\n                const menuItem = document.createElement(\"li\");\n                menuItem.className = \"menu_item\";\n                menuItem.textContent = text;\n                this.contextMenuElement.appendChild(menuItem);\n                if (enabled !== false) {\n                    menuItem.addEventListener(\"click\", onClick);\n                }\n                else {\n                    menuItem.classList.add(\"disabled\");\n                }\n            }\n        }\n        // Place a context menu in the top-left corner, so\n        // its `clientWidth` and `clientHeight` are not clamped.\n        this.contextMenuElement.style.left = \"0\";\n        this.contextMenuElement.style.top = \"0\";\n        this.contextMenuElement.style.display = \"block\";\n        const rect = this.getBoundingClientRect();\n        const x = e.clientX - rect.x;\n        const y = e.clientY - rect.y;\n        const maxX = rect.width - this.contextMenuElement.clientWidth - 1;\n        const maxY = rect.height - this.contextMenuElement.clientHeight - 1;\n        this.contextMenuElement.style.left =\n            Math.floor(Math.min(x, maxX)) + \"px\";\n        this.contextMenuElement.style.top =\n            Math.floor(Math.min(y, maxY)) + \"px\";\n    }\n    hideContextMenu() {\n        var _a;\n        (_a = this.instance) === null || _a === void 0 ? void 0 : _a.clear_custom_menu_items();\n        this.contextMenuElement.style.display = \"none\";\n    }\n    /**\n     * Pauses this player.\n     *\n     * No more frames, scripts or sounds will be executed.\n     * This movie will be considered inactive and will not wake up until resumed.\n     */\n    pause() {\n        if (this.instance) {\n            this.instance.pause();\n            if (this.playButton) {\n                this.playButton.style.display = \"block\";\n            }\n        }\n    }\n    audioState() {\n        if (this.instance) {\n            const audioContext = this.instance.audio_context();\n            return (audioContext && audioContext.state) || \"running\";\n        }\n        return \"suspended\";\n    }\n    unmuteOverlayClicked() {\n        if (this.instance) {\n            if (this.audioState() !== \"running\") {\n                const audioContext = this.instance.audio_context();\n                if (audioContext) {\n                    audioContext.resume();\n                }\n            }\n            if (this.unmuteOverlay) {\n                this.unmuteOverlay.style.display = \"none\";\n            }\n        }\n    }\n    /**\n     * Plays a silent sound based on the AudioContext's sample rate.\n     *\n     * This is used to unmute audio on iOS and iPadOS when silent mode is enabled on the device (issue 1552).\n     */\n    unmuteAudioContext() {\n        // No need to play the dummy sound again once audio is unmuted.\n        if (isAudioContextUnmuted)\n            return;\n        // TODO: Use `navigator.userAgentData` to detect the platform when support improves?\n        if (navigator.maxTouchPoints < 1) {\n            isAudioContextUnmuted = true;\n            return;\n        }\n        this.container.addEventListener(\"click\", () => {\n            var _a;\n            if (isAudioContextUnmuted)\n                return;\n            const audioContext = (_a = this.instance) === null || _a === void 0 ? void 0 : _a.audio_context();\n            if (!audioContext)\n                return;\n            const audio = new Audio();\n            audio.src = (() => {\n                // Returns a seven samples long 8 bit mono WAVE file.\n                // This is required to prevent the AudioContext from desyncing and crashing.\n                const arrayBuffer = new ArrayBuffer(10);\n                const dataView = new DataView(arrayBuffer);\n                const sampleRate = audioContext.sampleRate;\n                dataView.setUint32(0, sampleRate, true);\n                dataView.setUint32(4, sampleRate, true);\n                dataView.setUint16(8, 1, true);\n                const missingCharacters = window\n                    .btoa(String.fromCharCode(...new Uint8Array(arrayBuffer)))\n                    .slice(0, 13);\n                return `data:audio/wav;base64,UklGRisAAABXQVZFZm10IBAAAAABAAEA${missingCharacters}AgAZGF0YQcAAACAgICAgICAAAA=`;\n            })();\n            audio.load();\n            audio\n                .play()\n                .then(() => {\n                isAudioContextUnmuted = true;\n            })\n                .catch((err) => {\n                console.warn(`Failed to play dummy sound: ${err}`);\n            });\n        }, { once: true });\n    }\n    /**\n     * Copies attributes and children from another element to this player element.\n     * Used by the polyfill elements, RuffleObject and RuffleEmbed.\n     *\n     * @param elem The element to copy all attributes from.\n     * @protected\n     */\n    copyElement(elem) {\n        if (elem) {\n            for (let i = 0; i < elem.attributes.length; i++) {\n                const attrib = elem.attributes[i];\n                if (attrib.specified) {\n                    // Issue 468: Chrome \"Click to Active Flash\" box stomps on title attribute\n                    if (attrib.name === \"title\" &&\n                        attrib.value === \"Adobe Flash Player\") {\n                        continue;\n                    }\n                    try {\n                        this.setAttribute(attrib.name, attrib.value);\n                    }\n                    catch (err) {\n                        // The embed may have invalid attributes, so handle these gracefully.\n                        console.warn(`Unable to set attribute ${attrib.name} on Ruffle instance`);\n                    }\n                }\n            }\n            for (const node of Array.from(elem.children)) {\n                this.appendChild(node);\n            }\n        }\n    }\n    /**\n     * Converts a dimension attribute on an HTML embed/object element to a valid CSS dimension.\n     * HTML element dimensions are unitless, but can also be percentages.\n     * Add a 'px' unit unless the value is a percentage.\n     * Returns null if this is not a valid dimension.\n     *\n     * @param attribute The attribute to convert\n     *\n     * @private\n     */\n    static htmlDimensionToCssDimension(attribute) {\n        if (attribute) {\n            const match = attribute.match(DIMENSION_REGEX);\n            if (match) {\n                let out = match[1];\n                if (!match[3]) {\n                    // Unitless -- add px for CSS.\n                    out += \"px\";\n                }\n                return out;\n            }\n        }\n        return null;\n    }\n    /**\n     * When a movie presents a new callback through `ExternalInterface.addCallback`,\n     * we are informed so that we can expose the method on any relevant DOM element.\n     *\n     * This should only be called by Ruffle itself and not by users.\n     *\n     * @param name The name of the callback that is now available.\n     *\n     * @internal\n     * @ignore\n     */\n    onCallbackAvailable(name) {\n        const instance = this.instance;\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        this[name] = (...args) => {\n            return instance === null || instance === void 0 ? void 0 : instance.call_exposed_callback(name, args);\n        };\n    }\n    /**\n     * Sets a trace observer on this flash player.\n     *\n     * The observer will be called, as a function, for each message that the playing movie will \"trace\" (output).\n     *\n     * @param observer The observer that will be called for each trace.\n     */\n    set traceObserver(observer) {\n        var _a;\n        (_a = this.instance) === null || _a === void 0 ? void 0 : _a.set_trace_observer(observer);\n    }\n    /**\n     * Panics this specific player, forcefully destroying all resources and displays an error message to the user.\n     *\n     * This should be called when something went absolutely, incredibly and disastrously wrong and there is no chance\n     * of recovery.\n     *\n     * Ruffle will attempt to isolate all damage to this specific player instance, but no guarantees can be made if there\n     * was a core issue which triggered the panic. If Ruffle is unable to isolate the cause to a specific player, then\n     * all players will panic and Ruffle will become \"poisoned\" - no more players will run on this page until it is\n     * reloaded fresh.\n     *\n     * @param error The error, if any, that triggered this panic.\n     */\n    panic(error) {\n        var _a;\n        if (this.panicked) {\n            // Only show the first major error, not any repeats - they aren't as important\n            return;\n        }\n        this.panicked = true;\n        if (error instanceof Error &&\n            (error.name === \"AbortError\" ||\n                error.message.includes(\"AbortError\"))) {\n            // Firefox: Don't display the panic screen if the user leaves the page while something is still loading\n            return;\n        }\n        const errorIndex = (_a = error === null || error === void 0 ? void 0 : error.ruffleIndexError) !== null && _a !== void 0 ? _a : 0 /* Unknown */;\n        const errorArray = Object.assign([], {\n            stackIndex: -1,\n        });\n        errorArray.push(\"# Error Info\\n\");\n        if (error instanceof Error) {\n            errorArray.push(`Error name: ${error.name}\\n`);\n            errorArray.push(`Error message: ${error.message}\\n`);\n            if (error.stack) {\n                const stackIndex = errorArray.push(`Error stack:\\n\\`\\`\\`\\n${error.stack}\\n\\`\\`\\`\\n`) - 1;\n                errorArray.stackIndex = stackIndex;\n            }\n        }\n        else {\n            errorArray.push(`Error: ${error}\\n`);\n        }\n        errorArray.push(\"\\n# Player Info\\n\");\n        errorArray.push(this.debugPlayerInfo());\n        errorArray.push(\"\\n# Page Info\\n\");\n        errorArray.push(`Page URL: ${document.location.href}\\n`);\n        if (this.swfUrl)\n            errorArray.push(`SWF URL: ${this.swfUrl}\\n`);\n        errorArray.push(\"\\n# Browser Info\\n\");\n        errorArray.push(`Useragent: ${window.navigator.userAgent}\\n`);\n        errorArray.push(`OS: ${window.navigator.platform}\\n`);\n        errorArray.push(\"\\n# Ruffle Info\\n\");\n        errorArray.push(`Version: 0.1.0\\n`);\n        errorArray.push(`Name: nightly 2022-03-10\\n`);\n        errorArray.push(`Channel: nightly\\n`);\n        errorArray.push(`Built: 2022-03-10T00:17:15.298Z\\n`);\n        errorArray.push(`Commit: 5a1e41752672f4d0f81a5790e465c20c798a29c9\\n`);\n        errorArray.push(`Is extension: ${this.isExtension}\\n`);\n        const errorText = errorArray.join(\"\");\n        // Remove query params for the issue title.\n        const pageUrl = document.location.href.split(/[?#]/)[0];\n        const issueTitle = `Error on ${pageUrl}`;\n        let issueLink = `https://github.com/ruffle-rs/ruffle/issues/new?title=${encodeURIComponent(issueTitle)}&template=error_report.md&labels=error-report&body=`;\n        let issueBody = encodeURIComponent(errorText);\n        if (errorArray.stackIndex > -1 &&\n            String(issueLink + issueBody).length > 8195) {\n            // Strip the stack error from the array when the produced URL is way too long.\n            // This should prevent \"414 Request-URI Too Large\" errors on Github.\n            errorArray[errorArray.stackIndex] = null;\n            issueBody = encodeURIComponent(errorArray.join(\"\"));\n        }\n        issueLink += issueBody;\n        // Clears out any existing content (ie play button or canvas) and replaces it with the error screen\n        let errorBody, errorFooter;\n        switch (errorIndex) {\n            case 2 /* FileProtocol */:\n                // General error: Running on the `file:` protocol\n                errorBody = `\n                    <p>It appears you are running Ruffle on the \"file:\" protocol.</p>\n                    <p>This doesn't work as browsers block many features from working for security reasons.</p>\n                    <p>Instead, we invite you to setup a local server or either use the web demo or the desktop application.</p>\n                `;\n                errorFooter = `\n                    <li><a target=\"_top\" href=\"${RUFFLE_ORIGIN}/demo\">Web Demo</a></li>\n                    <li><a target=\"_top\" href=\"https://github.com/ruffle-rs/ruffle/tags\">Desktop Application</a></li>\n                `;\n                break;\n            case 4 /* JavascriptConfiguration */:\n                // General error: Incorrect JavaScript configuration\n                errorBody = `\n                    <p>Ruffle has encountered a major issue due to an incorrect JavaScript configuration.</p>\n                    <p>If you are the server administrator, we invite you to check the error details to find out which parameter is at fault.</p>\n                    <p>You can also consult the Ruffle wiki for help.</p>\n                `;\n                errorFooter = `\n                    <li><a target=\"_top\" href=\"https://github.com/ruffle-rs/ruffle/wiki/Using-Ruffle#javascript-api\">View Ruffle Wiki</a></li>\n                    <li><a href=\"#\" id=\"panic-view-details\">View Error Details</a></li>\n                `;\n                break;\n            case 9 /* WasmNotFound */:\n                // Self hosted: Cannot load `.wasm` file - file not found\n                errorBody = `\n                    <p>Ruffle failed to load the required \".wasm\" file component.</p>\n                    <p>If you are the server administrator, please ensure the file has correctly been uploaded.</p>\n                    <p>If the issue persists, you may need to use the \"publicPath\" setting: please consult the Ruffle wiki for help.</p>\n                `;\n                errorFooter = `\n                    <li><a target=\"_top\" href=\"https://github.com/ruffle-rs/ruffle/wiki/Using-Ruffle#configuration-options\">View Ruffle Wiki</a></li>\n                    <li><a href=\"#\" id=\"panic-view-details\">View Error Details</a></li>\n                `;\n                break;\n            case 8 /* WasmMimeType */:\n                // Self hosted: Cannot load `.wasm` file - incorrect MIME type\n                errorBody = `\n                    <p>Ruffle has encountered a major issue whilst trying to initialize.</p>\n                    <p>This web server is not serving \".wasm\" files with the correct MIME type.</p>\n                    <p>If you are the server administrator, please consult the Ruffle wiki for help.</p>\n                `;\n                errorFooter = `\n                    <li><a target=\"_top\" href=\"https://github.com/ruffle-rs/ruffle/wiki/Using-Ruffle#configure-webassembly-mime-type\">View Ruffle Wiki</a></li>\n                    <li><a href=\"#\" id=\"panic-view-details\">View Error Details</a></li>\n                `;\n                break;\n            case 11 /* SwfFetchError */:\n                errorBody = `\n                    <p>Ruffle failed to load the Flash SWF file.</p>\n                    <p>The most likely reason is that the file no longer exists, so there is nothing for Ruffle to load.</p>\n                    <p>Try contacting the website administrator for help.</p>\n                `;\n                errorFooter = `\n                    <li><a href=\"#\" id=\"panic-view-details\">View Error Details</a></li>\n                `;\n                break;\n            case 6 /* WasmCors */:\n                // Self hosted: Cannot load `.wasm` file - CORS issues\n                errorBody = `\n                    <p>Ruffle failed to load the required \".wasm\" file component.</p>\n                    <p>Access to fetch has likely been blocked by CORS policy.</p>\n                    <p>If you are the server administrator, please consult the Ruffle wiki for help.</p>\n                `;\n                errorFooter = `\n                    <li><a target=\"_top\" href=\"https://github.com/ruffle-rs/ruffle/wiki/Using-Ruffle#web\">View Ruffle Wiki</a></li>\n                    <li><a href=\"#\" id=\"panic-view-details\">View Error Details</a></li>\n                `;\n                break;\n            case 3 /* InvalidWasm */:\n                // Self hosted: Cannot load `.wasm` file - incorrect configuration or missing files\n                errorBody = `\n                    <p>Ruffle has encountered a major issue whilst trying to initialize.</p>\n                    <p>It seems like this page has missing or invalid files for running Ruffle.</p>\n                    <p>If you are the server administrator, please consult the Ruffle wiki for help.</p>\n                `;\n                errorFooter = `\n                    <li><a target=\"_top\" href=\"https://github.com/ruffle-rs/ruffle/wiki/Using-Ruffle#addressing-a-compileerror\">View Ruffle Wiki</a></li>\n                    <li><a href=\"#\" id=\"panic-view-details\">View Error Details</a></li>\n                `;\n                break;\n            case 7 /* WasmDownload */:\n                // Usually a transient network error or botched deployment\n                errorBody = `\n                    <p>Ruffle has encountered a major issue whilst trying to initialize.</p>\n                    <p>This can often resolve itself, so you can try reloading the page.</p>\n                    <p>Otherwise, please contact the website administrator.</p>\n                `;\n                errorFooter = `\n                    <li><a href=\"#\" id=\"panic-view-details\">View Error Details</a></li>\n                `;\n                break;\n            case 10 /* WasmDisabledMicrosoftEdge */:\n                // Self hosted: User has disabled WebAssembly in Microsoft Edge through the\n                // \"Enhance your Security on the web\" setting.\n                errorBody = `\n                    <p>Ruffle failed to load the required \".wasm\" file component.</p>\n                    <p>To fix this, try opening your browser's settings, clicking \"Privacy, search, and services\", scrolling down, and turning off \"Enhance your security on the web\".</p>\n                    <p>This will allow your browser to load the required \".wasm\" files.</p>\n                    <p>If the issue persists, you might have to use a different browser.</p>\n                `;\n                errorFooter = `\n                    <li><a target=\"_top\" href=\"https://github.com/ruffle-rs/ruffle/wiki/Frequently-Asked-Questions-For-Users#edge-webassembly-error\">More Information</a></li>\n                    <li><a href=\"#\" id=\"panic-view-details\">View Error Details</a></li>\n                `;\n                break;\n            case 5 /* JavascriptConflict */:\n                // Self hosted: Cannot load `.wasm` file - a native object / function is overriden\n                errorBody = `\n                    <p>Ruffle has encountered a major issue whilst trying to initialize.</p>\n                    <p>It seems like this page uses JavaScript code that conflicts with Ruffle.</p>\n                    <p>If you are the server administrator, we invite you to try loading the file on a blank page.</p>\n                `;\n                errorFooter = `\n                    <li><a target=\"_top\" href=\"${issueLink}\">Report Bug</a></li>\n                    <li><a href=\"#\" id=\"panic-view-details\">View Error Details</a></li>\n                `;\n                break;\n            case 1 /* CSPConflict */:\n                // General error: Cannot load `.wasm` file - a native object / function is overriden\n                errorBody = `\n                    <p>Ruffle has encountered a major issue whilst trying to initialize.</p>\n                    <p>This web server's Content Security Policy does not allow the required \".wasm\" component to run.</p>\n                    <p>If you are the server administrator, please consult the Ruffle wiki for help.</p>\n                `;\n                errorFooter = `\n                    <li><a target=\"_top\" href=\"https://github.com/ruffle-rs/ruffle/wiki/Using-Ruffle#configure-wasm-csp\">View Ruffle Wiki</a></li>\n                    <li><a href=\"#\" id=\"panic-view-details\">View Error Details</a></li>\n                `;\n                break;\n            default:\n                // Unknown error\n                errorBody = `\n                    <p>Ruffle has encountered a major issue whilst trying to display this Flash content.</p>\n                    <p>This isn't supposed to happen, so we'd really appreciate if you could file a bug!</p>\n                `;\n                errorFooter = `\n                    <li><a target=\"_top\" href=\"${issueLink}\">Report Bug</a></li>\n                    <li><a href=\"#\" id=\"panic-view-details\">View Error Details</a></li>\n                `;\n                break;\n        }\n        this.container.innerHTML = `\n            <div id=\"panic\">\n                <div id=\"panic-title\">Something went wrong :(</div>\n                <div id=\"panic-body\">${errorBody}</div>\n                <div id=\"panic-footer\">\n                    <ul>${errorFooter}</ul>\n                </div>\n            </div>\n        `;\n        const viewDetails = (this.container.querySelector(\"#panic-view-details\"));\n        if (viewDetails) {\n            viewDetails.onclick = () => {\n                const panicBody = (this.container.querySelector(\"#panic-body\"));\n                panicBody.classList.add(\"details\");\n                panicBody.innerHTML = `<textarea>${errorText}</textarea>`;\n                return false;\n            };\n        }\n        // Do this last, just in case it causes any cascading issues.\n        this.destroy();\n    }\n    displayRootMovieDownloadFailedMessage() {\n        if (window.location.origin == this.swfUrl.origin ||\n            !this.isExtension ||\n            !window.location.protocol.includes(\"http\")) {\n            const error = new Error(\"Failed to fetch: \" + this.swfUrl);\n            error.ruffleIndexError = 11 /* SwfFetchError */;\n            this.panic(error);\n            return;\n        }\n        const div = document.createElement(\"div\");\n        div.id = \"message_overlay\";\n        div.innerHTML = `<div class=\"message\">\n            <p>Ruffle wasn't able to run the Flash embedded in this page.</p>\n            <p>You can try to open the file in a separate tab, to sidestep this issue.</p>\n            <div>\n                <a target=\"_blank\" href=\"${this.swfUrl}\">Open in a new tab</a>\n            </div>\n        </div>`;\n        this.container.prepend(div);\n    }\n    displayUnsupportedMessage() {\n        const div = document.createElement(\"div\");\n        div.id = \"message_overlay\";\n        // TODO: Change link to https://ruffle.rs/faq or similar\n        // TODO: Pause content until message is dismissed\n        div.innerHTML = `<div class=\"message\">\n            <p>Flash Player has been removed from browsers in 2021.</p>\n            <p>This content is not yet supported by the Ruffle emulator and will likely not run as intended.</p>\n            <div>\n                <a target=\"_blank\" class=\"more-info-link\" href=\"https://github.com/ruffle-rs/ruffle/wiki/Frequently-Asked-Questions-For-Users\">More info</a>\n                <button id=\"run-anyway-btn\">Run anyway</button>\n            </div>\n        </div>`;\n        this.container.prepend(div);\n        const button = div.querySelector(\"#run-anyway-btn\");\n        button.onclick = () => {\n            div.parentNode.removeChild(div);\n        };\n    }\n    displayMessage(message) {\n        // Show a dismissible message in front of the player\n        const div = document.createElement(\"div\");\n        div.id = \"message_overlay\";\n        div.innerHTML = `<div class=\"message\">\n            <p>${message}</p>\n            <div>\n                <button id=\"continue-btn\">continue</button>\n            </div>\n        </div>`;\n        this.container.prepend(div);\n        (this.container.querySelector(\"#continue-btn\")).onclick = () => {\n            div.parentNode.removeChild(div);\n        };\n    }\n    debugPlayerInfo() {\n        var _a, _b;\n        return `Allows script access: ${(_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.allowScriptAccess) !== null && _b !== void 0 ? _b : false}\\n`;\n    }\n    setMetadata(metadata) {\n        this._metadata = metadata;\n        // TODO: Switch this to ReadyState.Loading when we have streaming support.\n        this._readyState = 2 /* Loaded */;\n        this.dispatchEvent(new Event(RufflePlayer.LOADED_METADATA));\n        // TODO: Move this to whatever function changes the ReadyState to Loaded when we have streaming support.\n        this.dispatchEvent(new Event(RufflePlayer.LOADED_DATA));\n    }\n    setIsExtension(isExtension) {\n        this.isExtension = isExtension;\n    }\n}\n/**\n * Triggered when a movie metadata has been loaded (such as movie width and height).\n *\n * @event RufflePlayer#loadedmetadata\n */\nRufflePlayer.LOADED_METADATA = \"loadedmetadata\";\n/**\n * Triggered when a movie is fully loaded.\n *\n * @event RufflePlayer#loadeddata\n */\nRufflePlayer.LOADED_DATA = \"loadeddata\";\n/**\n * Returns whether a SWF file can call JavaScript code in the surrounding HTML file.\n *\n * @param access The value of the `allowScriptAccess` attribute.\n * @param url The URL of the SWF file.\n * @returns True if script access is allowed.\n */\nexport function isScriptAccessAllowed(access, url) {\n    if (!access) {\n        access = \"sameDomain\";\n    }\n    switch (access.toLowerCase()) {\n        case \"always\":\n            return true;\n        case \"never\":\n            return false;\n        case \"samedomain\":\n        default:\n            try {\n                return (new URL(window.location.href).origin ===\n                    new URL(url, window.location.href).origin);\n            }\n            catch (_a) {\n                return false;\n            }\n    }\n}\n/**\n * Returns whether a SWF file should show the built-in context menu items.\n *\n * @param menu The value of the `menu` attribute.\n * @returns True if the built-in context items should be shown.\n */\nexport function isBuiltInContextMenuVisible(menu) {\n    if (menu === null || menu.toLowerCase() === \"true\") {\n        return true;\n    }\n    return false;\n}\n/**\n * Returns whether the given filename ends in a known flash extension.\n *\n * @param filename The filename to test.\n * @returns True if the filename is a flash movie (swf or spl).\n */\nexport function isSwfFilename(filename) {\n    if (filename) {\n        let pathname = \"\";\n        try {\n            // A base URL is required if `filename` is a relative URL, but we don't need to detect the real URL origin.\n            pathname = new URL(filename, RUFFLE_ORIGIN).pathname;\n        }\n        catch (err) {\n            // Some invalid filenames, like `///`, could raise a TypeError. Let's fail silently in this situation.\n        }\n        if (pathname && pathname.length >= 4) {\n            const extension = pathname.slice(-4).toLowerCase();\n            if (extension === \".swf\" || extension === \".spl\") {\n                return true;\n            }\n        }\n    }\n    return false;\n}\n/**\n * Determine if an element is a child of a node that was not supported\n * in non-HTML5 compliant browsers. If so, the element was meant to be\n * used as a fallback content.\n *\n * @param elem The element to test.\n * @returns True if the element is inside an <audio> or <video> node.\n */\nexport function isFallbackElement(elem) {\n    let parent = elem.parentElement;\n    while (parent !== null) {\n        switch (parent.tagName) {\n            case \"AUDIO\":\n            case \"VIDEO\":\n                return true;\n        }\n        parent = parent.parentElement;\n    }\n    return false;\n}\n","/**\n * Create a filename to save a downloaded SWF into.\n *\n * @param swfUrl The URL of the SWF file.\n * @returns The filename the SWF file can be saved at.\n */\nexport function swfFileName(swfUrl) {\n    const pathName = swfUrl.pathname;\n    const name = pathName.substring(pathName.lastIndexOf(\"/\") + 1);\n    return name;\n}\n","import { FLASH_MIMETYPE, FUTURESPLASH_MIMETYPE, FLASH7_AND_8_MIMETYPE, FLASH_MOVIE_MIMETYPE, isBuiltInContextMenuVisible, isFallbackElement, isScriptAccessAllowed, isSwfFilename, RufflePlayer, } from \"./ruffle-player\";\nimport { registerElement } from \"./register-element\";\n/**\n * A polyfill html element.\n *\n * This specific class tries to polyfill existing `<embed>` tags,\n * and should not be used. Prefer [[RufflePlayer]] instead.\n *\n * @internal\n */\nexport class RuffleEmbed extends RufflePlayer {\n    /**\n     * Constructs a new Ruffle flash player for insertion onto the page.\n     *\n     * This specific class tries to polyfill existing `<embed>` tags,\n     * and should not be used. Prefer [[RufflePlayer]] instead.\n     */\n    constructor() {\n        super();\n    }\n    /**\n     * @ignore\n     * @internal\n     */\n    connectedCallback() {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;\n        super.connectedCallback();\n        const src = this.attributes.getNamedItem(\"src\");\n        if (src) {\n            const allowScriptAccess = (_b = (_a = this.attributes.getNamedItem(\"allowScriptAccess\")) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : null;\n            const menu = (_d = (_c = this.attributes.getNamedItem(\"menu\")) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : null;\n            // Kick off the SWF download.\n            this.load({\n                url: src.value,\n                allowScriptAccess: isScriptAccessAllowed(allowScriptAccess, src.value),\n                parameters: (_e = this.attributes.getNamedItem(\"flashvars\")) === null || _e === void 0 ? void 0 : _e.value,\n                backgroundColor: (_f = this.attributes.getNamedItem(\"bgcolor\")) === null || _f === void 0 ? void 0 : _f.value,\n                base: (_g = this.attributes.getNamedItem(\"base\")) === null || _g === void 0 ? void 0 : _g.value,\n                menu: isBuiltInContextMenuVisible(menu),\n                salign: (_j = (_h = this.attributes.getNamedItem(\"salign\")) === null || _h === void 0 ? void 0 : _h.value) !== null && _j !== void 0 ? _j : \"\",\n                quality: (_l = (_k = this.attributes.getNamedItem(\"quality\")) === null || _k === void 0 ? void 0 : _k.value) !== null && _l !== void 0 ? _l : \"high\",\n                scale: (_o = (_m = this.attributes.getNamedItem(\"scale\")) === null || _m === void 0 ? void 0 : _m.value) !== null && _o !== void 0 ? _o : \"showAll\",\n            });\n        }\n    }\n    /**\n     * Polyfill of HTMLObjectElement.\n     *\n     * @ignore\n     * @internal\n     */\n    get src() {\n        var _a;\n        return (_a = this.attributes.getNamedItem(\"src\")) === null || _a === void 0 ? void 0 : _a.value;\n    }\n    /**\n     * Polyfill of HTMLObjectElement.\n     *\n     * @ignore\n     * @internal\n     */\n    set src(srcval) {\n        if (srcval != undefined) {\n            const attr = document.createAttribute(\"src\");\n            attr.value = srcval;\n            this.attributes.setNamedItem(attr);\n        }\n        else {\n            this.attributes.removeNamedItem(\"src\");\n        }\n    }\n    /**\n     * @ignore\n     * @internal\n     */\n    static get observedAttributes() {\n        return [\"src\", \"width\", \"height\"];\n    }\n    /**\n     * @ignore\n     * @internal\n     */\n    attributeChangedCallback(name, oldValue, newValue) {\n        var _a;\n        super.attributeChangedCallback(name, oldValue, newValue);\n        if (this.isConnected && name === \"src\") {\n            let parameters;\n            const flashvars = this.attributes.getNamedItem(\"flashvars\");\n            if (flashvars) {\n                parameters = flashvars.value;\n            }\n            const src = this.attributes.getNamedItem(\"src\");\n            if (src) {\n                this.load({\n                    url: src.value,\n                    parameters,\n                    base: (_a = this.attributes.getNamedItem(\"base\")) === null || _a === void 0 ? void 0 : _a.value,\n                });\n            }\n        }\n    }\n    /**\n     * Checks if the given element may be polyfilled with this one.\n     *\n     * @param elem Element to check.\n     * @returns True if the element looks like a flash embed.\n     */\n    static isInterdictable(elem) {\n        var _a;\n        // Don't polyfill if the element is inside a specific node.\n        if (isFallbackElement(elem)) {\n            return false;\n        }\n        // Don't polyfill when no file is specified.\n        if (!elem.getAttribute(\"src\")) {\n            return false;\n        }\n        // Check for MIME type.\n        const type = (_a = elem.getAttribute(\"type\")) === null || _a === void 0 ? void 0 : _a.toLowerCase();\n        if (type === FLASH_MIMETYPE.toLowerCase() ||\n            type === FUTURESPLASH_MIMETYPE.toLowerCase() ||\n            type === FLASH7_AND_8_MIMETYPE.toLowerCase() ||\n            type === FLASH_MOVIE_MIMETYPE.toLowerCase()) {\n            return true;\n        }\n        else if (type == null || type === \"\") {\n            return isSwfFilename(elem.getAttribute(\"src\"));\n        }\n        return false;\n    }\n    /**\n     * Creates a RuffleEmbed that will polyfill and replace the given element.\n     *\n     * @param elem Element to replace.\n     * @returns Created RuffleEmbed.\n     */\n    static fromNativeEmbedElement(elem) {\n        const externalName = registerElement(\"ruffle-embed\", RuffleEmbed);\n        const ruffleObj = document.createElement(externalName);\n        ruffleObj.copyElement(elem);\n        return ruffleObj;\n    }\n}\n","import { FLASH_MIMETYPE, FUTURESPLASH_MIMETYPE, FLASH7_AND_8_MIMETYPE, FLASH_MOVIE_MIMETYPE, FLASH_ACTIVEX_CLASSID, isBuiltInContextMenuVisible, isFallbackElement, isScriptAccessAllowed, isSwfFilename, RufflePlayer, } from \"./ruffle-player\";\nimport { registerElement } from \"./register-element\";\nimport { RuffleEmbed } from \"./ruffle-embed\";\n/**\n * Find and return the first value in obj with the given key.\n * Many Flash params were case insensitive, so we use this when checking for them.\n *\n * @param obj Object to check\n * @param key Key to find\n * @param defaultValue Value if not found\n * @returns Value if found, else [[defaultValue]]\n */\nfunction findCaseInsensitive(obj, key, defaultValue) {\n    key = key.toLowerCase();\n    for (const k in obj) {\n        if (Object.hasOwnProperty.call(obj, k) && key === k.toLowerCase()) {\n            return obj[k];\n        }\n    }\n    return defaultValue;\n}\n/**\n * Returns all flash params ([[HTMLParamElement]]) that are for the given object.\n *\n * @param elem Element to check.\n * @returns A record of every parameter.\n */\nfunction paramsOf(elem) {\n    var _a, _b;\n    const params = {};\n    for (const param of elem.children) {\n        if (param instanceof HTMLParamElement) {\n            const key = (_a = param.attributes.getNamedItem(\"name\")) === null || _a === void 0 ? void 0 : _a.value;\n            const value = (_b = param.attributes.getNamedItem(\"value\")) === null || _b === void 0 ? void 0 : _b.value;\n            if (key && value) {\n                params[key] = value;\n            }\n        }\n    }\n    return params;\n}\n/**\n * A polyfill html element.\n *\n * This specific class tries to polyfill existing `<object>` tags,\n * and should not be used. Prefer [[RufflePlayer]] instead.\n *\n * @internal\n */\nexport class RuffleObject extends RufflePlayer {\n    /**\n     * Constructs a new Ruffle flash player for insertion onto the page.\n     *\n     * This specific class tries to polyfill existing `<object>` tags,\n     * and should not be used. Prefer [[RufflePlayer]] instead.\n     */\n    constructor() {\n        super();\n        this.params = {};\n    }\n    /**\n     * @ignore\n     * @internal\n     */\n    connectedCallback() {\n        var _a;\n        super.connectedCallback();\n        this.params = paramsOf(this);\n        let url = null;\n        if (this.attributes.getNamedItem(\"data\")) {\n            url = (_a = this.attributes.getNamedItem(\"data\")) === null || _a === void 0 ? void 0 : _a.value;\n        }\n        else if (this.params.movie) {\n            url = this.params.movie;\n        }\n        const allowScriptAccess = findCaseInsensitive(this.params, \"allowScriptAccess\", null);\n        const parameters = findCaseInsensitive(this.params, \"flashvars\", this.getAttribute(\"flashvars\"));\n        const backgroundColor = findCaseInsensitive(this.params, \"bgcolor\", this.getAttribute(\"bgcolor\"));\n        const base = findCaseInsensitive(this.params, \"base\", this.getAttribute(\"base\"));\n        const menu = findCaseInsensitive(this.params, \"menu\", null);\n        const salign = findCaseInsensitive(this.params, \"salign\", \"\");\n        const quality = findCaseInsensitive(this.params, \"quality\", \"high\");\n        const scale = findCaseInsensitive(this.params, \"scale\", \"showAll\");\n        if (url) {\n            const options = { url };\n            options.allowScriptAccess = isScriptAccessAllowed(allowScriptAccess, url);\n            if (parameters) {\n                options.parameters = parameters;\n            }\n            if (backgroundColor) {\n                options.backgroundColor = backgroundColor;\n            }\n            if (base) {\n                options.base = base;\n            }\n            options.menu = isBuiltInContextMenuVisible(menu);\n            if (salign) {\n                options.salign = salign;\n            }\n            if (quality) {\n                options.quality = quality;\n            }\n            if (scale) {\n                options.scale = scale;\n            }\n            // Kick off the SWF download.\n            this.load(options);\n        }\n    }\n    debugPlayerInfo() {\n        var _a;\n        let errorText = super.debugPlayerInfo();\n        errorText += \"Player type: Object\\n\";\n        let url = null;\n        if (this.attributes.getNamedItem(\"data\")) {\n            url = (_a = this.attributes.getNamedItem(\"data\")) === null || _a === void 0 ? void 0 : _a.value;\n        }\n        else if (this.params.movie) {\n            url = this.params.movie;\n        }\n        errorText += `SWF URL: ${url}\\n`;\n        Object.keys(this.params).forEach((key) => {\n            errorText += `Param ${key}: ${this.params[key]}\\n`;\n        });\n        Object.keys(this.attributes).forEach((key) => {\n            var _a;\n            errorText += `Attribute ${key}: ${(_a = this.attributes.getNamedItem(key)) === null || _a === void 0 ? void 0 : _a.value}\\n`;\n        });\n        return errorText;\n    }\n    /**\n     * Polyfill of HTMLObjectElement.\n     *\n     * @ignore\n     * @internal\n     */\n    get data() {\n        return this.getAttribute(\"data\");\n    }\n    /**\n     * Polyfill of HTMLObjectElement.\n     *\n     * @ignore\n     * @internal\n     */\n    set data(href) {\n        if (href != undefined) {\n            const attr = document.createAttribute(\"data\");\n            attr.value = href;\n            this.attributes.setNamedItem(attr);\n        }\n        else {\n            this.attributes.removeNamedItem(\"data\");\n        }\n    }\n    /**\n     * Checks if the given element may be polyfilled with this one.\n     *\n     * @param elem Element to check.\n     * @returns True if the element looks like a flash object.\n     */\n    static isInterdictable(elem) {\n        var _a, _b, _c;\n        // Don't polyfill if the element is inside a specific node.\n        if (isFallbackElement(elem)) {\n            return false;\n        }\n        // Don't polyfill if there's already a <ruffle-embed> inside the <object>.\n        if (elem.getElementsByTagName(\"ruffle-embed\").length > 0) {\n            return false;\n        }\n        // Don't polyfill if no movie specified.\n        const data = (_a = elem.attributes.getNamedItem(\"data\")) === null || _a === void 0 ? void 0 : _a.value.toLowerCase();\n        const params = paramsOf(elem);\n        let isSwf;\n        // Check for SWF file.\n        if (data) {\n            isSwf = isSwfFilename(data);\n        }\n        else if (params && params.movie) {\n            isSwf = isSwfFilename(params.movie);\n        }\n        else {\n            // Don't polyfill when no file is specified.\n            return false;\n        }\n        // Check ActiveX class ID.\n        const classid = (_b = elem.attributes\n            .getNamedItem(\"classid\")) === null || _b === void 0 ? void 0 : _b.value.toLowerCase();\n        if (classid === FLASH_ACTIVEX_CLASSID.toLowerCase()) {\n            // classid is an old-IE style embed that would not work on modern browsers.\n            // Often there will be an <embed> inside the <object> that would take precedence.\n            // Only polyfill this <object> if it doesn't contain a polyfillable <embed>.\n            return !Array.from(elem.getElementsByTagName(\"embed\")).some(RuffleEmbed.isInterdictable);\n        }\n        else if (classid != null && classid !== \"\") {\n            // Non-Flash classid.\n            return false;\n        }\n        // Check for MIME type.\n        const type = (_c = elem.attributes.getNamedItem(\"type\")) === null || _c === void 0 ? void 0 : _c.value.toLowerCase();\n        if (type === FLASH_MIMETYPE.toLowerCase() ||\n            type === FUTURESPLASH_MIMETYPE.toLowerCase() ||\n            type === FLASH7_AND_8_MIMETYPE.toLowerCase() ||\n            type === FLASH_MOVIE_MIMETYPE.toLowerCase()) {\n            return true;\n        }\n        else if (type != null && type !== \"\") {\n            return false;\n        }\n        // If no MIME/class type is specified, polyfill if movie is an SWF file.\n        return isSwf;\n    }\n    /**\n     * Creates a RuffleObject that will polyfill and replace the given element.\n     *\n     * @param elem Element to replace.\n     * @returns Created RuffleObject.\n     */\n    static fromNativeObjectElement(elem) {\n        const externalName = registerElement(\"ruffle-object\", RuffleObject);\n        const ruffleObj = (document.createElement(externalName));\n        // Avoid copying embeds-inside-objects to avoid double polyfilling.\n        for (const embedElem of Array.from(elem.getElementsByTagName(\"embed\"))) {\n            if (RuffleEmbed.isInterdictable(embedElem)) {\n                embedElem.remove();\n            }\n        }\n        // Avoid copying objects-inside-objects to avoid double polyfilling.\n        // This may happen when Internet Explorer's conditional comments are used.\n        for (const objectElem of Array.from(elem.getElementsByTagName(\"object\"))) {\n            if (RuffleObject.isInterdictable(objectElem)) {\n                objectElem.remove();\n            }\n        }\n        ruffleObj.copyElement(elem);\n        return ruffleObj;\n    }\n}\n","var _a, _b;\nimport { RuffleObject } from \"./ruffle-object\";\nimport { RuffleEmbed } from \"./ruffle-embed\";\nimport { installPlugin, FLASH_PLUGIN } from \"./plugin-polyfill\";\nimport { publicPath } from \"./public-path\";\nlet isExtension;\nconst globalConfig = (_b = (_a = window.RufflePlayer) === null || _a === void 0 ? void 0 : _a.config) !== null && _b !== void 0 ? _b : {};\nconst jsScriptUrl = publicPath(globalConfig) + \"ruffle.js\";\n/**\n * Polyfill native Flash elements with Ruffle equivalents.\n *\n * This polyfill isn't fool-proof: If there's a chance site JavaScript has\n * access to a pre-polyfill element, then this will break horribly. We can\n * keep native objects out of the DOM, and thus out of JavaScript's grubby\n * little hands, but only if we load first.\n */\nlet objects;\nlet embeds;\n/**\n *\n */\nfunction polyfillFlashInstances() {\n    try {\n        // Create live collections to track embed tags.\n        objects = objects !== null && objects !== void 0 ? objects : document.getElementsByTagName(\"object\");\n        embeds = embeds !== null && embeds !== void 0 ? embeds : document.getElementsByTagName(\"embed\");\n        // Replace <object> first, because <object> often wraps <embed>.\n        for (const elem of Array.from(objects)) {\n            if (RuffleObject.isInterdictable(elem)) {\n                const ruffleObject = RuffleObject.fromNativeObjectElement(elem);\n                ruffleObject.setIsExtension(isExtension);\n                elem.replaceWith(ruffleObject);\n            }\n        }\n        for (const elem of Array.from(embeds)) {\n            if (RuffleEmbed.isInterdictable(elem)) {\n                const ruffleEmbed = RuffleEmbed.fromNativeEmbedElement(elem);\n                ruffleEmbed.setIsExtension(isExtension);\n                elem.replaceWith(ruffleEmbed);\n            }\n        }\n    }\n    catch (err) {\n        console.error(`Serious error encountered when polyfilling native Flash elements: ${err}`);\n    }\n}\n/**\n * Inject Ruffle into <iframe> and <frame> elements.\n *\n * This polyfill isn't fool-proof either: On self-hosted builds, it may\n * not work due to browsers CORS policy or be loaded too late for some\n * libraries like SWFObject. These should be less of a problem on the\n * web extension. This polyfill should, however, do the trick in most\n * cases, but users should be aware of its natural limits.\n */\nlet iframes;\nlet frames;\n/**\n *\n */\nfunction polyfillFrames() {\n    // Create live collections to track embed tags.\n    iframes = iframes !== null && iframes !== void 0 ? iframes : document.getElementsByTagName(\"iframe\");\n    frames = frames !== null && frames !== void 0 ? frames : document.getElementsByTagName(\"frame\");\n    [iframes, frames].forEach((elementsList) => {\n        for (let i = 0; i < elementsList.length; i++) {\n            const element = elementsList[i];\n            if (element.dataset.rufflePolyfilled !== undefined) {\n                // Don't re-polyfill elements with the \"data-ruffle-polyfilled\" attribute.\n                continue;\n            }\n            element.dataset.rufflePolyfilled = \"\";\n            const elementWindow = element.contentWindow;\n            // Cross origin requests may reach an exception, so let's prepare for this eventuality.\n            const errorMessage = `Couldn't load Ruffle into ${element.tagName}[${element.src}]: `;\n            try {\n                if (elementWindow.document.readyState === \"complete\") {\n                    injectRuffle(elementWindow, errorMessage);\n                }\n            }\n            catch (err) {\n                if (!isExtension) {\n                    // The web extension should be able to load Ruffle into cross origin frames\n                    // because it has \"all_frames\" set to true in its manifest.json: RufflePlayer\n                    // config won't be injected but it's not worth showing an error.\n                    console.warn(errorMessage + err);\n                }\n            }\n            // Attach listener to the element to handle frame navigation.\n            element.addEventListener(\"load\", () => {\n                injectRuffle(elementWindow, errorMessage);\n            }, false);\n        }\n    });\n}\n/**\n * @param elementWindow The (i)frame's window object.\n * @param errorMessage The message to log when Ruffle cannot access the (i)frame's document.\n */\nasync function injectRuffle(elementWindow, errorMessage) {\n    var _a;\n    // The document is supposed to be completely loaded when this function is run.\n    // As Chrome may be unable to access the document properties, we have to delay the execution a little bit.\n    await new Promise((resolve) => {\n        window.setTimeout(() => {\n            resolve();\n        }, 100);\n    });\n    let elementDocument;\n    try {\n        elementDocument = elementWindow.document;\n        if (!elementDocument) {\n            // Don't polyfill if the window has no document: the element may have been removed from the parent window.\n            return;\n        }\n    }\n    catch (err) {\n        if (!isExtension) {\n            console.warn(errorMessage + err);\n        }\n        return;\n    }\n    if (!isExtension &&\n        elementDocument.documentElement.dataset.ruffleOptout !== undefined) {\n        // Don't polyfill elements with the \"data-ruffle-optout\" attribute.\n        return;\n    }\n    if (!isExtension) {\n        if (!elementWindow.RufflePlayer) {\n            const script = elementDocument.createElement(\"script\");\n            script.setAttribute(\"src\", jsScriptUrl);\n            script.onload = () => {\n                // Inject parent configuration once the script is loaded, preventing it from being ignored.\n                elementWindow.RufflePlayer = {};\n                elementWindow.RufflePlayer.config = globalConfig;\n            };\n            elementDocument.head.appendChild(script);\n        }\n    }\n    else {\n        if (!elementWindow.RufflePlayer) {\n            elementWindow.RufflePlayer = {};\n        }\n        // Merge parent window and frame configurations, will likely be applied too late though.\n        elementWindow.RufflePlayer.config = Object.assign(Object.assign({}, globalConfig), ((_a = elementWindow.RufflePlayer.config) !== null && _a !== void 0 ? _a : {}));\n    }\n}\n/**\n * Listen for changes to the DOM.\n *\n */\nfunction initMutationObserver() {\n    const observer = new MutationObserver(function (mutationsList) {\n        // If any nodes were added, re-run the polyfill to detect any new instances.\n        const nodesAdded = mutationsList.some((mutation) => mutation.addedNodes.length > 0);\n        if (nodesAdded) {\n            polyfillFlashInstances();\n            polyfillFrames();\n        }\n    });\n    observer.observe(document, { childList: true, subtree: true });\n}\n/**\n * Polyfills the detection of Flash plugins in the browser.\n */\nexport function pluginPolyfill() {\n    installPlugin(FLASH_PLUGIN);\n}\n/**\n * Polyfills legacy Flash content on the page.\n *\n * @param isExt Whether or not Ruffle is running as a browser's extension.\n */\nexport function polyfill(isExt) {\n    isExtension = isExt;\n    polyfillFlashInstances();\n    polyfillFrames();\n    initMutationObserver();\n}\n","/**\n * A representation of a semver 2 compliant version string\n */\nexport class Version {\n    /**\n     * Construct a Version from specific components.\n     *\n     * If you wish to parse a string into a Version then please use [[fromSemver]].\n     *\n     * @param major The major version component.\n     * @param minor The minor version component.\n     * @param patch The patch version component.\n     * @param prIdent A list of pre-release identifiers, if any\n     * @param buildIdent A list of build identifiers, if any\n     */\n    constructor(major, minor, patch, prIdent, buildIdent) {\n        this.major = major;\n        this.minor = minor;\n        this.patch = patch;\n        this.prIdent = prIdent;\n        this.buildIdent = buildIdent;\n    }\n    /**\n     * Construct a version from a semver 2 compliant string.\n     *\n     * This function is intended for use with semver 2 compliant strings.\n     * Malformed strings may still parse correctly, but this result is not\n     * guaranteed.\n     *\n     * @param versionString A semver 2.0.0 compliant version string\n     * @returns A version object\n     */\n    static fromSemver(versionString) {\n        const buildSplit = versionString.split(\"+\"), prSplit = buildSplit[0].split(\"-\"), versionSplit = prSplit[0].split(\".\");\n        const major = parseInt(versionSplit[0], 10);\n        let minor = 0;\n        let patch = 0;\n        let prIdent = null;\n        let buildIdent = null;\n        if (versionSplit[1] != undefined) {\n            minor = parseInt(versionSplit[1], 10);\n        }\n        if (versionSplit[2] != undefined) {\n            patch = parseInt(versionSplit[2], 10);\n        }\n        if (prSplit[1] != undefined) {\n            prIdent = prSplit[1].split(\".\");\n        }\n        if (buildSplit[1] != undefined) {\n            buildIdent = buildSplit[1].split(\".\");\n        }\n        return new Version(major, minor, patch, prIdent, buildIdent);\n    }\n    /**\n     * Returns true if a given version is compatible with this one.\n     *\n     * Compatibility is defined as having the same nonzero major version\n     * number, or if both major versions are zero, the same nonzero minor\n     * version number, or if both minor versions are zero, the same nonzero\n     * patch version number.\n     *\n     * This implements the ^ operator in npm's semver package, with the\n     * exception of the prerelease exclusion rule.\n     *\n     * @param other The other version to test against\n     * @returns True if compatible\n     */\n    isCompatibleWith(other) {\n        return ((this.major !== 0 && this.major === other.major) ||\n            (this.major === 0 &&\n                other.major === 0 &&\n                this.minor !== 0 &&\n                this.minor === other.minor) ||\n            (this.major === 0 &&\n                other.major === 0 &&\n                this.minor === 0 &&\n                other.minor === 0 &&\n                this.patch !== 0 &&\n                this.patch === other.patch));\n    }\n    /**\n     * Returns true if this version has precedence over (is newer than) another\n     * version.\n     *\n     * Precedence is defined as in the Semver 2 spec. This implements the >\n     * operator in npm's semver package, with the exception of the prerelease\n     * exclusion rule.\n     *\n     * @param other The other version to test against\n     * @returns True if this version has precedence over the other one\n     */\n    hasPrecedenceOver(other) {\n        if (this.major > other.major) {\n            return true;\n        }\n        else if (this.major < other.major) {\n            return false;\n        }\n        if (this.minor > other.minor) {\n            return true;\n        }\n        else if (this.minor < other.minor) {\n            return false;\n        }\n        if (this.patch > other.patch) {\n            return true;\n        }\n        else if (this.patch < other.patch) {\n            return false;\n        }\n        if (this.prIdent == null && other.prIdent != null) {\n            return true;\n        }\n        else if (this.prIdent != null && other.prIdent != null) {\n            const isNumeric = /^[0-9]*$/;\n            for (let i = 0; i < this.prIdent.length && i < other.prIdent.length; i += 1) {\n                if (!isNumeric.test(this.prIdent[i]) &&\n                    isNumeric.test(other.prIdent[i])) {\n                    return true;\n                }\n                else if (isNumeric.test(this.prIdent[i]) &&\n                    isNumeric.test(other.prIdent[i])) {\n                    if (parseInt(this.prIdent[i], 10) >\n                        parseInt(other.prIdent[i], 10)) {\n                        return true;\n                    }\n                    else if (parseInt(this.prIdent[i], 10) <\n                        parseInt(other.prIdent[i], 10)) {\n                        return false;\n                    }\n                }\n                else if (isNumeric.test(this.prIdent[i]) &&\n                    !isNumeric.test(other.prIdent[i])) {\n                    return false;\n                }\n                else if (!isNumeric.test(this.prIdent[i]) &&\n                    !isNumeric.test(other.prIdent[i])) {\n                    if (this.prIdent[i] > other.prIdent[i]) {\n                        return true;\n                    }\n                    else if (this.prIdent[i] < other.prIdent[i]) {\n                        return false;\n                    }\n                }\n            }\n            return this.prIdent.length > other.prIdent.length;\n        }\n        return false;\n    }\n    /**\n     * Tests if a given version is equivalent to this one.\n     *\n     * Build and prerelease tags are ignored.\n     *\n     * @param other The other version to test against\n     * @returns True if the given version is equivalent\n     */\n    isEqual(other) {\n        return (this.major === other.major &&\n            this.minor === other.minor &&\n            this.patch === other.patch);\n    }\n    /**\n     * Tests if a given version is stable or a compatible prerelease for this\n     * version.\n     *\n     * This implements the prerelease exclusion rule of NPM semver: a\n     * prerelease version can only pass this check if the major/minor/patch\n     * components of both versions are the same. Otherwise, the prerelease\n     * version always fails.\n     *\n     * @param other The other version to test against\n     * @returns True if the given version is either stable, or a\n     * prerelease in the same series as this one.\n     */\n    isStableOrCompatiblePrerelease(other) {\n        if (other.prIdent == null) {\n            return true;\n        }\n        else {\n            return (this.major === other.major &&\n                this.minor === other.minor &&\n                this.patch === other.patch);\n        }\n    }\n}\n","import { Version } from \"./version\";\n/**\n * Represents a set of version requirements.\n */\nexport class VersionRange {\n    /**\n     * Constructs a range of versions as specified by the given requirements.\n     *\n     * If you wish to construct this object from a string representation,\n     * then use [[fromRequirementString]].\n     *\n     * @param requirements Requirements to set this range by\n     */\n    constructor(requirements) {\n        this.requirements = requirements;\n    }\n    /**\n     * Determine if a given version satisfies this range.\n     *\n     * @param fver A version object to test against.\n     * @returns Whether or not the given version matches this range\n     */\n    satisfiedBy(fver) {\n        for (let i = 0; i < this.requirements.length; i += 1) {\n            let matches = true;\n            for (let j = 0; j < this.requirements[i].length; j += 1) {\n                const comparator = this.requirements[i][j].comparator;\n                const version = this.requirements[i][j].version;\n                matches =\n                    matches && version.isStableOrCompatiblePrerelease(fver);\n                if (comparator === \"\" || comparator === \"=\") {\n                    matches = matches && version.isEqual(fver);\n                }\n                else if (comparator === \">\") {\n                    matches = matches && fver.hasPrecedenceOver(version);\n                }\n                else if (comparator === \">=\") {\n                    matches =\n                        matches &&\n                            (fver.hasPrecedenceOver(version) ||\n                                version.isEqual(fver));\n                }\n                else if (comparator === \"<\") {\n                    matches = matches && version.hasPrecedenceOver(fver);\n                }\n                else if (comparator === \"<=\") {\n                    matches =\n                        matches &&\n                            (version.hasPrecedenceOver(fver) ||\n                                version.isEqual(fver));\n                }\n                else if (comparator === \"^\") {\n                    matches = matches && version.isCompatibleWith(fver);\n                }\n            }\n            if (matches) {\n                return true;\n            }\n        }\n        return false;\n    }\n    /**\n     * Parse a requirement string into a version range.\n     *\n     * @param requirement The version requirements, consisting of a\n     * series of space-separated strings, each one being a semver version\n     * optionally prefixed by a comparator or a separator.\n     *\n     * Valid comparators are:\n     * - `\"\"` or `\"=\"`: Precisely this version\n     * - `\">`\": A version newer than this one\n     * - `\">`=\": A version newer or equal to this one\n     * - `\"<\"`: A version older than this one\n     * - `\"<=\"`: A version older or equal to this one\n     * - `\"^\"`: A version that is compatible with this one\n     *\n     * A separator is `\"||`\" which splits the requirement string into\n     * left OR right.\n     * @returns A version range object.\n     */\n    static fromRequirementString(requirement) {\n        const components = requirement.split(\" \");\n        let set = [];\n        const requirements = [];\n        for (let i = 0; i < components.length; i += 1) {\n            if (components[i] === \"||\") {\n                if (set.length > 0) {\n                    requirements.push(set);\n                    set = [];\n                }\n            }\n            else if (components[i].length > 0) {\n                const match = /[0-9]/.exec(components[i]);\n                if (match) {\n                    const comparator = components[i]\n                        .slice(0, match.index)\n                        .trim();\n                    const version = Version.fromSemver(components[i].slice(match.index).trim());\n                    set.push({ comparator, version });\n                }\n            }\n        }\n        if (set.length > 0) {\n            requirements.push(set);\n        }\n        return new VersionRange(requirements);\n    }\n}\n","import { Version } from \"./version\";\nimport { VersionRange } from \"./version-range\";\n/**\n * Represents the Ruffle public API.\n *\n * The public API exists primarily to allow multiple installs of Ruffle on a\n * page (e.g. an extension install and a local one) to cooperate. In an ideal\n * situation, all Ruffle sources on the page install themselves into a single\n * public API, and then the public API picks the newest version by default.\n *\n * This API *is* versioned, in case we need to upgrade it. However, it must be\n * backwards- and forwards-compatible with all known sources.\n */\nexport class PublicAPI {\n    /**\n     * Construct the Ruffle public API.\n     *\n     * Do not use this function to negotiate a public API. Instead, use\n     * `public_api` to register your Ruffle source with an existing public API\n     * if it exists.\n     *\n     * Constructing a Public API will also trigger it to initialize Ruffle once\n     * the page loads, if the API has not already been superseded.\n     *\n     * @param prev What used to be in the public API slot.\n     *\n     * This is used to upgrade from a prior version of the public API, or from\n     * a user-defined configuration object placed in the public API slot.\n     * @protected\n     */\n    constructor(prev) {\n        this.sources = {};\n        this.config = {};\n        this.invoked = false;\n        this.newestName = null;\n        this.conflict = null;\n        if (prev !== undefined && prev !== null) {\n            if (prev instanceof PublicAPI) {\n                /// We're upgrading from a previous API to a new one.\n                this.sources = prev.sources;\n                this.config = prev.config;\n                this.invoked = prev.invoked;\n                this.conflict = prev.conflict;\n                this.newestName = prev.newestName;\n                prev.superseded();\n            }\n            else if (prev.constructor === Object &&\n                prev.config instanceof Object) {\n                /// We're the first, install user configuration\n                this.config = prev.config;\n            }\n            else {\n                /// We're the first, but conflicting with someone else.\n                this.conflict = prev;\n            }\n        }\n        if (document.readyState === \"loading\") {\n            window.addEventListener(\"DOMContentLoaded\", this.init.bind(this));\n        }\n        else {\n            window.setTimeout(this.init.bind(this), 0);\n        }\n    }\n    /**\n     * The version of the public API.\n     *\n     * This is *not* the version of Ruffle itself.\n     *\n     * This allows a page with an old version of the Public API to be upgraded\n     * to a new version of the API. The public API is intended to be changed\n     * very infrequently, if at all, but this provides an escape mechanism for\n     * newer Ruffle sources to upgrade older installations.\n     *\n     * @returns The version of this public API.\n     */\n    get version() {\n        return \"0.1.0\";\n    }\n    /**\n     * Register a given source with the Ruffle Public API.\n     *\n     * @param name The name of the source.\n     * @param api The public API object. This must conform to the shape\n     * of `SourceAPI`.\n     */\n    registerSource(name, api) {\n        this.sources[name] = api;\n    }\n    /**\n     * Determine the name of the newest registered source in the Public API.\n     *\n     * @returns The name of the source, or `null` if no source\n     * has yet to be registered.\n     */\n    newestSourceName() {\n        let newestName = null, newestVersion = Version.fromSemver(\"0.0.0\");\n        for (const k in this.sources) {\n            if (Object.prototype.hasOwnProperty.call(this.sources, k)) {\n                const kVersion = Version.fromSemver(this.sources[k].version);\n                if (kVersion.hasPrecedenceOver(newestVersion)) {\n                    newestName = k;\n                    newestVersion = kVersion;\n                }\n            }\n        }\n        return newestName;\n    }\n    /**\n     * Negotiate and start Ruffle.\n     *\n     * This function reads the config parameter to determine which polyfills\n     * should be enabled. If the configuration parameter is missing, then we\n     * use a built-in set of defaults sufficient to fool sites with static\n     * content and weak plugin detection.\n     */\n    init() {\n        if (!this.invoked) {\n            this.invoked = true;\n            this.newestName = this.newestSourceName();\n            if (this.newestName === null) {\n                throw new Error(\"No registered Ruffle source!\");\n            }\n            const polyfills = this.config.polyfills;\n            if (polyfills !== false) {\n                this.sources[this.newestName].polyfill(this.newestName === \"extension\");\n            }\n        }\n    }\n    /**\n     * Look up the newest Ruffle source and return it's API.\n     *\n     * @returns An instance of the Source API.\n     */\n    newest() {\n        const name = this.newestSourceName();\n        return name != null ? this.sources[name] : null;\n    }\n    /**\n     * Look up a specific Ruffle version (or any version satisfying a given set\n     * of requirements) and return it's API.\n     *\n     * @param ver_requirement A set of semantic version requirement\n     * strings that the player version must satisfy.\n     * @returns An instance of the Source API, if one or more\n     * sources satisfied the requirement.\n     */\n    satisfying(ver_requirement) {\n        const requirement = VersionRange.fromRequirementString(ver_requirement);\n        let valid = null;\n        for (const k in this.sources) {\n            if (Object.prototype.hasOwnProperty.call(this.sources, k)) {\n                const version = Version.fromSemver(this.sources[k].version);\n                if (requirement.satisfiedBy(version)) {\n                    valid = this.sources[k];\n                }\n            }\n        }\n        return valid;\n    }\n    /**\n     * Look up the newest Ruffle version compatible with the `local` source, if\n     * it's installed. Otherwise, use the latest version.\n     *\n     * @returns An instance of the Source API\n     */\n    localCompatible() {\n        if (this.sources.local !== undefined) {\n            return this.satisfying(\"^\" + this.sources.local.version);\n        }\n        else {\n            return this.newest();\n        }\n    }\n    /**\n     * Look up the newest Ruffle version with the exact same version as the\n     * `local` source, if it's installed. Otherwise, use the latest version.\n     *\n     * @returns An instance of the Source API\n     */\n    local() {\n        if (this.sources.local !== undefined) {\n            return this.satisfying(\"=\" + this.sources.local.version);\n        }\n        else {\n            return this.newest();\n        }\n    }\n    /**\n     * Indicates that this version of the public API has been superseded by a\n     * newer version.\n     *\n     * This should only be called by a newer version of the Public API.\n     * Identical versions of the Public API should not supersede older versions\n     * of that same API.\n     *\n     * Unfortunately, we can't disable polyfills after-the-fact, so this\n     * only lets you disable the init event...\n     *\n     * @protected\n     */\n    superseded() {\n        this.invoked = true;\n    }\n    /**\n     * Join a source into the public API, if it doesn't already exist.\n     *\n     * @param prevRuffle The previous iteration of the Ruffle API.\n     *\n     * The `prevRuffle` param lists the previous object in the RufflePlayer\n     * slot. We perform some checks to see if this is a Ruffle public API or a\n     * conflicting object. If this is conflicting, then a new public API will\n     * be constructed (see the constructor information for what happens to\n     * `prevRuffle`).\n     *\n     * Note that Public API upgrades are deliberately not enabled in this\n     * version of Ruffle, since there is no Public API to upgrade from.\n     * @param sourceName The name of this particular\n     * Ruffle source.\n     * @param sourceAPI The Ruffle source to add.\n     *\n     * If both parameters are provided they will be used to define a new Ruffle\n     * source to register with the public API.\n     * @returns The Ruffle Public API.\n     */\n    static negotiate(prevRuffle, sourceName, sourceAPI) {\n        let publicAPI;\n        if (prevRuffle instanceof PublicAPI) {\n            publicAPI = prevRuffle;\n        }\n        else {\n            publicAPI = new PublicAPI(prevRuffle);\n        }\n        if (sourceName !== undefined && sourceAPI !== undefined) {\n            publicAPI.registerSource(sourceName, sourceAPI);\n            // Install the faux plugin detection immediately.\n            // This is necessary because scripts such as SWFObject check for the\n            // Flash Player immediately when they load.\n            // TODO: Maybe there's a better place for this.\n            const polyfills = publicAPI.config.polyfills;\n            if (polyfills !== false) {\n                sourceAPI.pluginPolyfill();\n            }\n        }\n        return publicAPI;\n    }\n}\n","import { PublicAPI, SourceAPI } from \"ruffle-core\";\n\nwindow.RufflePlayer = PublicAPI.negotiate(\n    window.RufflePlayer,\n    \"local\",\n    new SourceAPI(\"local\")\n);\n","import { pluginPolyfill, polyfill } from \"./polyfills\";\nimport { registerElement } from \"./register-element\";\nimport { RufflePlayer } from \"./ruffle-player\";\n/**\n * Represents this particular version of Ruffle.\n *\n * Multiple APIs can be instantiated from different sources; e.g. an \"extension\"\n * version, versus a \"local\" version. This expresses to the Public API\n * negotiator (see [[PublicAPI]]) what this particular version of Ruffle is and\n * how to control it.\n */\nexport class SourceAPI {\n    /**\n     * Construct a Source API.\n     *\n     * @param name The name of this particular source.\n     */\n    constructor(name) {\n        this.name = name;\n    }\n    /**\n     * The version of this particular API.\n     *\n     * This is returned as a string in a semver compatible format.\n     *\n     * @returns The version of this Ruffle source\n     */\n    get version() {\n        return \"0.1.0\";\n    }\n    /**\n     * Start up the polyfills.\n     *\n     * Do not run polyfills for more than one Ruffle source at a time.\n     *\n     * @param isExt Whether or not Ruffle is running as a browser's extension.\n     */\n    polyfill(isExt) {\n        polyfill(isExt);\n    }\n    /**\n     * Polyfill the plugin detection.\n     *\n     * This needs to run before any plugin detection script does.\n     */\n    pluginPolyfill() {\n        pluginPolyfill();\n    }\n    /**\n     * Create a Ruffle player element using this particular version of Ruffle.\n     *\n     * @returns The player element. This is a DOM element that may be inserted\n     * into the current page as you wish.\n     */\n    createPlayer() {\n        const name = registerElement(\"ruffle-player\", RufflePlayer);\n        return document.createElement(name);\n    }\n}\n"],"names":["inProgress","dataWebpackPrefix","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","exports","module","__webpack_modules__","m","d","definition","key","o","Object","defineProperty","enumerable","get","f","e","chunkId","Promise","all","keys","reduce","promises","u","g","globalThis","this","Function","window","obj","prop","prototype","hasOwnProperty","call","l","url","done","push","script","needAttach","scripts","document","getElementsByTagName","i","length","s","getAttribute","createElement","charset","timeout","nc","setAttribute","src","onScriptComplete","prev","event","onerror","onload","clearTimeout","doneFns","parentNode","removeChild","forEach","fn","setTimeout","bind","type","target","head","appendChild","r","Symbol","toStringTag","value","p","b","baseURI","self","location","href","installedChunks","j","installedChunkData","promise","resolve","reject","error","Error","errorType","realSrc","message","name","request","webpackJsonpCallback","parentChunkLoadingFunction","data","chunkIds","moreModules","runtime","some","id","chunkLoadingGlobal","bulkMemory","async","WebAssembly","validate","Uint8Array","saturatedFloatToInt","signExtensions","simd","isNativeFunction","func","val","toString","indexOf","currentScriptURL","currentScript","endsWith","URL","console","warn","publicPath","config","path","lastLoaded","loadRuffle","Array","args","Prototype","Version","callback","TypeError","len","k","Window","constructor","Reflect","set","extensionsSupported","every","Boolean","log","default","init","Ruffle","fetchRuffle","RuffleMimeTypeArray","native_mimetype_array","__mimetypes","__named_mimetypes","install","mimetype","item","index","namedItem","iterator","RufflePlugin","description","filename","mimetypes","super","RufflePluginArray","native_plugin_array","__plugins","__named_plugins","plugin","refresh","FLASH_PLUGIN","suffixes","enabledPlugin","ruffleShadowTemplate","innerHTML","privateRegistry","registerElement","elementName","elementClass","class","tries","customElements","externalName","define","internalName","FLASH_MIMETYPE","FUTURESPLASH_MIMETYPE","FLASH7_AND_8_MIMETYPE","FLASH_MOVIE_MIMETYPE","RUFFLE_ORIGIN","DIMENSION_REGEX","isAudioContextUnmuted","sanitizeParameters","parameters","URLSearchParams","output","RufflePlayer","HTMLElement","hasContextMenu","contextMenuForceDisabled","isTouch","showSwfDownload","panicked","isExtension","shadow","attachShadow","mode","content","cloneNode","dynamicStyles","getElementById","container","playButton","addEventListener","play","unmuteOverlay","contextMenuElement","showContextMenu","pointerDown","fullScreenChange","hideContextMenu","instance","options","onFSCommand","_readyState","_metadata","lastActivePlayingState","setupPauseOnTabHidden","readyState","metadata","hidden","is_playing","pause","connectedCallback","updateStyles","observedAttributes","attributeChangedCallback","_oldValue","_newValue","disconnectedCallback","destroy","sheet","rules","deleteRule","widthAttr","attributes","getNamedItem","width","htmlDimensionToCssDimension","insertRule","heightAttr","height","isUnusedFallbackObject","parent","element","lookupElement","nodeName","_a","ruffleConstructor","catch","protocol","ruffleIndexError","String","toLowerCase","includes","navigator","userAgent","panic","is_wasm_simd_used","audioState","style","visibility","unmuteAudioContext","autoplay","display","unmuteOverlayClicked","once","audioContext","audio_context","onstatechange","state","_b","optionsError","isConnected","isFallbackElement","assign","allowScriptAccess","contextMenu","backgroundColor","ensureFreshInstance","swfUrl","substring","stream_from","load_data","err","isPlaying","fullscreenEnabled","webkitFullscreenEnabled","isFullscreen","fullscreenElement","webkitFullscreenElement","setFullscreen","isFull","enterFullscreen","exitFullscreen","navigationUI","requestFullscreen","webkitRequestFullscreen","webkitRequestFullScreen","webkitExitFullscreen","webkitCancelFullScreen","set_fullscreen","pointerType","response","fetch","ok","blob","blobUrl","createObjectURL","swfDownloadA","download","pathName","pathname","lastIndexOf","swfFileName","body","click","revokeObjectURL","contextMenuItems","CHECKMARK","fromCharCode","items","prepare_context_menu","separatorBefore","text","caption","checked","onClick","run_context_menu_callback","enabled","downloadSwf","extensionString","open","preventDefault","firstChild","lastElementChild","classList","contains","menuSeparator","className","hr","menuItem","textContent","add","left","top","rect","getBoundingClientRect","x","clientX","y","clientY","maxX","clientWidth","maxY","clientHeight","Math","floor","min","clear_custom_menu_items","resume","maxTouchPoints","audio","Audio","arrayBuffer","ArrayBuffer","dataView","DataView","sampleRate","setUint32","setUint16","btoa","slice","load","then","copyElement","elem","attrib","specified","node","from","children","static","attribute","match","out","onCallbackAvailable","call_exposed_callback","traceObserver","observer","set_trace_observer","errorIndex","errorArray","stackIndex","stack","debugPlayerInfo","platform","errorText","join","pageUrl","split","errorBody","errorFooter","issueLink","encodeURIComponent","issueBody","viewDetails","querySelector","onclick","panicBody","displayRootMovieDownloadFailedMessage","origin","div","prepend","displayUnsupportedMessage","displayMessage","setMetadata","dispatchEvent","Event","LOADED_METADATA","LOADED_DATA","setIsExtension","isScriptAccessAllowed","access","isBuiltInContextMenuVisible","menu","isSwfFilename","extension","parentElement","tagName","RuffleEmbed","_c","_d","_e","_f","_g","_h","_j","_k","_l","_m","_o","base","salign","quality","scale","srcval","attr","createAttribute","setNamedItem","removeNamedItem","oldValue","newValue","flashvars","ruffleObj","findCaseInsensitive","defaultValue","paramsOf","params","param","HTMLParamElement","RuffleObject","movie","isSwf","classid","isInterdictable","embedElem","remove","objectElem","globalConfig","jsScriptUrl","objects","iframes","polyfillFlashInstances","ruffleObject","fromNativeObjectElement","replaceWith","ruffleEmbed","fromNativeEmbedElement","polyfillFrames","elementsList","dataset","rufflePolyfilled","elementWindow","contentWindow","errorMessage","injectRuffle","elementDocument","documentElement","ruffleOptout","major","minor","patch","prIdent","buildIdent","versionString","buildSplit","prSplit","versionSplit","parseInt","isCompatibleWith","other","hasPrecedenceOver","isNumeric","test","isEqual","isStableOrCompatiblePrerelease","VersionRange","requirements","satisfiedBy","fver","matches","comparator","version","requirement","components","exec","trim","fromSemver","PublicAPI","sources","invoked","newestName","conflict","superseded","registerSource","api","newestSourceName","newestVersion","kVersion","polyfills","polyfill","newest","satisfying","ver_requirement","fromRequirementString","valid","localCompatible","local","prevRuffle","sourceName","sourceAPI","publicAPI","pluginPolyfill","negotiate","isExt","MutationObserver","mutationsList","mutation","addedNodes","observe","childList","subtree","plugins","writable","mimeTypes","installPlugin","createPlayer"],"sourceRoot":""}