npm - @rivmux/runtime-worker - Versions diffs - 0.1.0 - Mend

@rivmux/runtime-worker 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/LICENSE +201 -0
package/README.md +3 -0
package/dist/index.d.ts +44 -0
package/dist/index.d.ts.map +1 -0
package/dist/index.js +174 -0
package/dist/index.js.map +1 -0
package/dist/rivmux-runtime-worker.d.ts +327 -0
package/dist/rivmux-runtime-worker.d.ts.map +1 -0
package/dist/rivmux-runtime-worker.js +1894 -0
package/dist/rivmux-runtime-worker.js.map +1 -0
package/dist/rivmux-transmux-core.wasm +0 -0
package/package.json +42 -0

package/dist/rivmux-runtime-worker.js ADDED Viewed

@@ -0,0 +1,1894 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/fixtures/m1-static-fmp4.ts
+const M1_VIDEO_MIME = "video/mp4; codecs=\"avc1.42C01E\"";
+const INIT_SEGMENT_BASE64 = [
+	"AAAAHGZ0eXBpc281AAACAGlzbzVpc282bXA0MQAAAuVtb292AAAAbG12aGQAAAAAAAAAAAAAAAAAAAPoAAAAAAABAAABAAAAAAAAAAAAAAAAAQAAAAAAAAAA",
+	"AAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAB6HRyYWsAAABcdGtoZAAAAAMAAAAAAAAAAAAAAAEAAAAA",
+	"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAEAAAAABQAAAAPAAAAAAAYRtZGlhAAAAIG1kaGQAAAAAAAAAAAAA",
+	"AAAAADwAAAAAAFXEAAAAAAAtaGRscgAAAAAAAAAAdmlkZQAAAAAAAAAAAAAAAFZpZGVvSGFuZGxlcgAAAAEvbWluZgAAABR2bWhkAAAAAQAAAAAAAAAAAAAA",
+	"JGRpbmYAAAAcZHJlZgAAAAAAAAABAAAADHVybCAAAAABAAAA73N0YmwAAACjc3RzZAAAAAAAAAABAAAAk2F2YzEAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAB",
+	"QADwAEgAAABIAAAAAAAAAAEVTGF2YzYxLjE5LjEwMSBsaWJ4MjY0AAAAAAAAAAAAAAAY//8AAAAtYXZjQwFCwB7/4QAWZ0LAHtoFB+wEQAAAAwBAAAAPI8WL",
+	"qAEABGjOD8gAAAAQcGFzcAAAAAEAAAABAAAAEHN0dHMAAAAAAAAAAAAAABBzdHNjAAAAAAAAAAAAAAAUc3RzegAAAAAAAAAAAAAAAAAAABBzdGNvAAAAAAAA",
+	"AAAAAAAobXZleAAAACB0cmV4AAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAAAAAYXVkdGEAAABZbWV0YQAAAAAAAAAhaGRscgAAAAAAAAAAbWRpcmFwcGwAAAAA",
+	"AAAAAAAAAAAsaWxzdAAAACSpdG9vAAAAHGRhdGEAAAABAAAAAExhdmY2MS43LjEwMg=="
+].join("");
+const MEDIA_SEGMENT_BASE64 = [
+	"AAAAmG1vb2YAAAAQbWZoZAAAAAAAAAABAAAAgHRyYWYAAAAcdGZoZAACADgAAAABAAACAAAAGjwBAQAAAAAAFHRmZHQBAAAAAAAAAAAAAAAAAABIdHJ1bgAA",
+	"AgUAAAAMAAAAoAIAAAAAABo8AAAGqAAAB4QAAAdsAAAHkAAAB+kAAAkfAAAHHwAAB6IAAAdPAAAHrQAABx4AAG1PbWRhdAAAAmYGBf//YtxF6b3m2Ui3lizY",
+	"INkj7u94MjY0IC0gY29yZSAxNjQgcjMxMDggMzFlMTlmOSAtIEguMjY0L01QRUctNCBBVkMgY29kZWMgLSBDb3B5bGVmdCAyMDAzLTIwMjMgLSBodHRwOi8v",
+	"d3d3LnZpZGVvbGFuLm9yZy94MjY0Lmh0bWwgLSBvcHRpb25zOiBjYWJhYz0wIHJlZj0xIGRlYmxvY2s9MTowOjAgYW5hbHlzZT0weDE6MHgxMTEgbWU9aGV4",
+	"IHN1Ym1lPTIgcHN5PTEgcHN5X3JkPTEuMDA6MC4wMCBtaXhlZF9yZWY9MCBtZV9yYW5nZT0xNiBjaHJvbWFfbWU9MSB0cmVsbGlzPTAgOHg4ZGN0PTAgY3Ft",
+	"PTAgZGVhZHpvbmU9MjEsMTEgZmFzdF9wc2tpcD0xIGNocm9tYV9xcF9vZmZzZXQ9MCB0aHJlYWRzPTMgbG9va2FoZWFkX3RocmVhZHM9MyBzbGljZWRfdGhy",
+	"ZWFkcz0xIHNsaWNlcz0zIG5yPTAgZGVjaW1hdGU9MSBpbnRlcmxhY2VkPTAgYmx1cmF5X2NvbXBhdD0wIGNvbnN0cmFpbmVkX2ludHJhPTAgYmZyYW1lcz0w",
+	"IHdlaWdodHA9MCBrZXlpbnQ9MTIga2V5aW50X21pbj03IHNjZW5lY3V0PTAgaW50cmFfcmVmcmVzaD0wIHJjPWNyZiBtYnRyZWU9MCBjcmY9MjMuMCBxY29t",
+	"cD0wLjYwIHFwbWluPTAgcXBtYXg9NjkgcXBzdGVwPTQgaXBfcmF0aW89MS40MCBhcT0xOjEuMDAAgAAACw9liIQj8QiKuDAhfgIUxMAC1qDDAAeLwzoQ0Kgd",
+	"JX/4mfOoxIpuVfDf/cReGVGNCoH9n/4n2SyzILWepD/7BY0+K1gTTP77uGoYRC/PQer10nDCoR53nq9IANIRkhQOl/f+0BwpHSlA3J/vgQABQAQYqEACVQAB",
+	"AEAB3MxIhcEdeLPDg1zo1P5A5v/9pgK5iSjamAHXlFRCo8AQ0qc71gIwj/78UFZjo0VRFREeDRan/NUNkU3LeuIHwAHi8M6ENCoHSV/+uGoYRCfP49XgatYl",
+	"YrHCHq9YNZiJIPZM/3zhGZSOVkHUDdPCQhsZT1e2iyzQKpj4I3/OCM6EcyIOqg0ufQS2R/bCGR0Mo2h3g9P9sdgPUVpqQUX/9+UdNvQcT/9+CQyjOjYJDYM6",
+	"dgZhn46n/78vdKxWL/+5EVURUSahAwr/NUNmU3Lf83EXhnQhoVA6Sv/3xqhsym5V+b/4O4agwyFpE4PV7SxZZkFzEqQ/+oHWZkjg/x/fLBoqWLPQQ////lw1",
+	"BhkLSJwerwNWsJSHIch6vWDWYzSBdNn++cIZlIU7oOoOJ2GDJSew2SMraQ6DzAerGyjanpWmhzGkdX/1qcmmbjAojNobUwZ+K1bZt/ojYRUHghD+ANFDYV1a",
+	"oExMMuY2dB0s7/BwI1GRGF3/yf/cReMqMSPh/d/+BPZiRo5ZXmxFlmQ+RyEv+cEM+IUzIOqQBS4rQayn99dxqGNyfNQer11OGPyPM09XpAGszJHAvv7/2gcd",
+	"nSuBOT/fBACFhAAEgKcHxeePoLNvgNRtTs6beg5W//cYD4xJRtTAWOJimOwrlY5nB/cCjanZPUWwnm//3GABbnHuBtTiKgI/2NF/uoyIwu965A+AA8XjKjEj",
+	"4f3f/rjUMbk+bx6vfIA1mZI4F9/f+g2nDViOVj1e2inkHQpsEb3AdpNon5VSAKfOkGtz++sSkIAuhx5I8PHbTRwecrnDiNrO/Ot46j6TsMR4xtgenA8Q24Pc",
+	"Y50pq4uxfK4h3JDRxNm+XEViKybIdf7qMiMLveuTiLxlzEj4f3f/v3UZEYXe9cnEXjLmJHw/u//XGoY3J83j1exJHJA9nMS/6QBrMyRwL7+/9oHHZ0rgTk/3",
+	"y41DG5Pm8er11OGPyPM89XpAGszJHAvv7/2gcdnSuBOT/fBAlQgABEybfmNqcPzG1NgPViI42piA9WIjjamzzTIbUyuaZDamwALGOP6htTEACxjj+obU41D/",
+	"+NwA4syAQz3Btq91GRGF3vXIGCigACAZ7jUMbk+ag9XvkAazMkcC+/v/fDIAAgBAB4QAtgDhjTSGVUXvhEExStdIC+//3haCYBnLHEcqjuvhACAKxZmjTzYA",
+	"6An/+0WAQBWP//wRApFPjQACaECKicn4f/4IooAApI+OAAOJUcAAR2f//4LgTRQABAy4QABEIQSEJEfBwBAIxwdBMf8P8FUIAAgAByQKCIBqEwcAgFY4PBsf",
+	"//wV4HCDiEHBwACgB4gAAgQgACBlA8bXMPG1zA4AIILuYcAEEF3MRBPHBjQACSJ/8P+CwFEUAAQDOIATxAABAoAAEA3B0ExB0ExBwAC4AAgEMQcAAuAAIBDH",
+	"//4IgUinxwACscAAQA5OTwAOAhD7DQJF/P+aQOAIAJBwIFiEDgWAGxHIHAsAJCwwLBsTwwLBLmMMOOCBgc/6MZScSEjw1DhigfT8eE41hp+PBMnWPx9Q9DfJ",
+	"/8lwGR8CIf0VsjQEyAwlEA/isueAx7r4fmeYoy54SPUM8PhMxcIxD4aHYCN2Q3MkAkQcz/iASO+J0EAEUobGAb+L/5qPG/Z/ZKcPFa1lmkUwe7y55w/UB4Cg",
+	"7CLV2+m/EJEDOghBIKGGTRbDDAItM4XS45Y//2oggI/4ADxeGdGNCoF8r/9r5RZZoOhjyHv9QQNPipYEsif74JhKEWDbzN3qGzYI1P5DSk//2eMI8SbB52gh",
+	"GySMCdcP/93X5f2Gyf7kyIxV/4n/wdx0YExVD8er3yANZk0cH1/f++FSQQmY4zriA75XXSEj//f87ObTDB77M0aeYGLM//7Xpgrrrp7XD8PwBAsBRigACBVi",
+	"AACAAAWIAT4OAgMZg4EBzMHQRmDwZkz2pgprp6euvDDAP+CsE2AmROxK1akEDgBgFCIAAgGnAAEAwBgd7TAImUsPAAktD+YyGHcQAjFyw86nJFSF1AKt3d13",
+	"/EgTP/p1hI2zfwkbZesQwCGPYaIBNuRW/wExIZzVq3VkHIDGZBICMBQgABADEAzYCfWdDsVNhmk8ImVzwAMBNsgSOLi1V0o4JSPu0QAASAcOufwDAFjCAr8u",
+	"ZcOQQA48/3NdX94OhEQkowgILqvhIvTmc7HGtYSlgAZ15N7YjeJFSYCqHKAcA4/XlxzZrjcvcBPSfWr98VQxIOY1saYaWUVLZ1GqAhM+0Q3+8wRFlHt8eMIM",
+	"PxDgAiRERjtbqDiARHAw5BACnDgVsvRowmC0EwGBErc+ffZbIeVjBYEArAKASRkOFYi7tf8cMcOlAFraCMdDc/9cHEAIjEJoDAAE+EwjrXSwD/e8MQssaOm7",
+	"WAsSyEqfr0AE2nMiDwi2J3aTBPXT10vDAfwcJIKICaRmVavPIECZkhua/AQpkR1q9+BO2kN1+FDMDhAECkA0AEP3CFuIYAVGVmLMQUAqN2g9ahu++5jK4AB2",
+	"bJobQqMI/8BDSNAmcoZBRyQIaRpidREb885smDdqhQ5+f/hjh0vwE0Tu1avwIEbshufgazCCJ7fgVeSdMM2AKTTXrTA/PRiURCa5Z4zHKZDTFJ3M5Cpglp6e",
+	"uubjgAFY0a65mCpNk8FcaAATQGEASRDHD/QLA4B0CrJv4BIQLO2nBgP+BMEogCqOo/wf/+DARh33A4QKKZcISE4QABAOS6vuARCzRAu1OVCEFwAd2JzGEW8J",
+	"3a/DGAY1r1XAdpMGcwFG5//Bwg5GEBODg4IAAqAIcCT2ewMVIetvVldPScIeUt0g/AXH4pQb6rMIX1LQ2Nxwzmt2qjhAf9BqAC6nyNt4/v9dQcQBEQwACgAu",
+	"MIAAuACGhAAGApBokzCkxIqAj9TAHQ3SFvfeABXbMwTv1KGO+QvAZswoI23SD/j8AxwjyYE8TOhuf+uDoER1CgGUwHAtwGwp5HIeVAwGAF1gZ+xwB0N0gITR",
+	"pGTMSooYYAWuAiZTAGS3S/+YewW8AFszCRSxpEH/21hBZ3CAkKXAj0mlbgwlh4EXSNK2gYJoagprimCjTeQ1jbAIZ2IPiG3/hr8CGZGhuf/AnHkhv7wcTYQg",
+	"YWQKTPkLMUhvf2x+Up/8po0DdjBkFHnc9MmxOcOnPPDDTBTT09dddddPT1xTBMZdf/u50CeOGOAAV1DwH/QaBMAGczJSj6//ByAZEIAAmAQsICAAKADmB4AG",
+	"cWxL73EdsnwZJigMtukH4AFJIkGzZCBTekVAR+pgBVN0g/4/hjhBhwIEbshufg8BkeBwJqHDdgQmjSMmYlQoDDACxcAjYogI63SAjpk2J8hUdgwwAusBn7HA",
+	"HU3S+A+Qexvoo04geBwCAeWWPADpIaApR4B4bat8CAFQAECQgAXAAEAIGg4AwlxkQ/tAQvZN6TCDwDgyADAKOGjF3aAWL2TepggfAfhxD4cdAVJEYDHdIbav",
+	"eHiH4HCD2y4xD8IHooQD0cGCu/gF+/mwU0+877A6pNfwAl7+bBJk+877/6h4DDpQAX+VmkRY/srLbx8QDwYA9kDgCZA4ACIvgBmf9Exqoej4AM6v/IjPTEXs",
+	"Dmb/67v2wU109PXXgAAABbhlAyiIQEr///wRRQABEt8cAAR9Y4AAsIScn8P/4KwVQOQDDIOIABA8QAAQPAABBhgeZXMPMrmBwACQDh1zDgAEgHDrn//+CIFY",
+	"p9HBk/+H/BYCaKAAICXEACLEAAEAsANg6BMQdAmIOAEAdiDgBAHYEQTxwY4AAgBScn4f/4aBEKAAIQ/wOAAgAgOZbCtAACM4FaAAEC2AGcssSum7X4AT5GKk",
+	"c7btf4cQ8A4aIAoJmgEM1QbahT/nDzng4IMRwoeKEQaHz67qwHO/n2dp98//j/adWAOd/Rs5o7tf//AA4DlOB5wPzgecD8ARTQZCmrVqQf8SBIhAjXAQCDXw",
+	"O4Aw6mcbrQMuAxWADBdVGcepx2P/hj+NnDyweBwEDBDIsAA5f3fCjlhFiQIAAiGCRBwBIvmB5DlfIrAC1wCNlMAM1ulZ76jhjgPBgTADR0239rSigdBRlw0g",
+	"HDAhwdnT2hyeB+ELc4zpGlbQME0MBgBgFHDRi7tf9YBjh04F2SaG6+fingdCjLCQsKEAEB2jsJ2xxHlSbmB1ImvaABP38MVxMn9r//8FgiKAAIBnEAIsQAAQ",
+	"KAABANwdBMYOgmIOAAXAAEAhjwcAAuAAIBDH//4IgUinxgABNDgACAHJyddddMFTaYK66enrr4Yf/Yeij67XHjh/kDQKMDhBTEHHIAyPCUBA4QARQ8MAeYrg",
+	"JoK2AeYrngcAQxtwAvYb3FA6G6QcAQx9znqHhwHgwKZTACObZJJD+0yDwMjhKmEABVxAJdzEX+//Ala54AsXsm+TAgLADDADOWWJXTdr8MYBjhAuL4ECN2Q3",
+	"P/4PDIwLYIOGJ5mB4Q3l3eOez2B/s06TABzv4yqzR3fPEfj/w0Ydzi/BwQYiKWEBDjSigSuphdr5DgoAEZDMcKSISXFt2j33x+AY4R5MCeEQqG5/3wOIAqy9",
+	"xAugoM+6dVAjoxLyFzHYpAwwAspgDHtDwL83S/+oewWlwADqPiGvXr+2JAChAAGQKIYwrM/AUjLyjLXuI8cM1BqCeuuunp66enrrp666YKFPBTHBiHbXD//x",
+	"wKA09V+BwgpjLOEohhAAGQEBxuAi+l3ktBMH0AiMgzBNNJMdu1LAALgACAQxx+AY4QYcB9JhlMhufg4Qcjx2EgI3qb6L/gLEYishzK4iVLDDACwVwIRiyAFI",
+	"t0o8B9Q9AvuDggQjfABf5WySKH9yB4IChAACAAADACAC8HSCUZXzgxl5DAB+YzHCaYWeRu0ApnTEFCtUrmzaOxAACgAAgFmeHEPhx0AUW0CEaBRuf98DgIGl",
+	"l3wgARkDQgABAMHCQkAwHvgE7/eMRcRk/tH/ICmdcUdS8xHJAL1RGI5wmnlHkbtB+oKa66enrp6euunrrp6euZgoMzKeCmMFBnA/wH/0CwEkHAgORwCQgBMc",
+	"2AVptTz4YAPhEFYbwtZxXdr8cMfw4aMALpMGcyG5//BwgUjCAqUQIAAQBRBgqGdusD3eDKrNGL7X+AqCTsIlG7+8ArNGRhEHwp5j92g/UFdddPT109PXXT11",
+	"8Ph5CVhwFGAS7HSJ/w6QACGrdpD68H9Z1THHutr3c+256+QHorQgEgYsIAAuDAgvAM8MkqcDfXn/zMAZYXkHMv63B6FciyfP65wX0Ig+G+E3TpeCVF7A0w5y",
+	"3lsTXuCn9Mw/fhVDpUAVr2Dc0az//VhBU8CAAhT0ANroZEaf8fGokd2/gR7KCrxMOVIerdZopAiV+//XxSLDhcAOUm4GZF9oYzN+hD5BsDZpEQfxtoEdvRdQ",
+	"3d44Hy1ENbp4DPyhH//BACYENCAANgYHH4A4eDNd5GJ2np+7yAGKBe4FET3agbObxsWxW7+4B8R+w2TbOepoH73SsfFbMgZL+d8H3nb0uO/V+f1dH/7mfx3Y",
+	"H9w4IAIhZoQABoDAs6a4ZF63pxYynhswVkHKb639HS1bDnvl6YKa6XAAAAb/ZQGSIhASv///BFFAAES3xwABH1jgACwhJyfw//grBVA5AMMg4gAEDxAABA8A",
+	"AEGGB5lcw8yuYHAAJAOHXMOAASAcOuYyJAAfSbaSTbS//4QXdggCc5OAKCZEAgpJtq4AoJiYENNNtX/xD4Le8IECcJCAEAignHSRGAwpBtq/HSQnBTTDbV/+",
+	"H/BYSKAAICXEACPEAAEAsANg6BMQdAmIOAEAdiDgBAHYEQTxgoYAAIACJyfh//giigACkj44AA4lRwABHZk/+vkhJDgJsADaHzZLFHkr6ApmFP9R7d9ATHIk",
+	"TLxAmff/WPr4V+aoRv/YDSlLQkR8XUt79py7SGoSql/ggACYYIIhAAiGGwA1DLKcaAegwWbqPVQB+xkmyGu7eXFrm4rYA43A4QcQgBS0Avvx8jf2oepQpnf1",
+	"7gBtcu/4AK/WSJ/RaX3+rbfyn37uvMRd3erC0JSMLcdRvu1BzNJuvB3f7fGd2Xc/dFa1jzPmCQxM/9hAAGgA6NCAAEAwAKA8CkINzw42AZjJwhRv54FPJ7Bb",
+	"mqIMCiOUgYS1sPHAOYqQYWj+egvrFi1DpB7i/HyUcdjztuD5/uejUs2n63dSrvX66r9NMj3/IAAAvtPszhdxj+uR/mB3WWfxPv6qRaeq977gHlulnISf0itf",
+	"KQ4/3wQABsDZoQAAgNgAGY0yj+I5f74reYpbXg/K+mV/f21kw1kXhBPf/U2FrxSK3a8DxI2/2jmn396+PAeN5kefB/2AJeVrCkAOa4jAEHYanQs9EYj7mmWd",
+	"BSaneop9enwfJWOPprI69Lu990tJ8S8f/32fenTZv/OCAANAVOBAACA0AApZET6GS21XQGSSCyp5tdovbDquC8w5V7ta9bAPaJsAstZWZZcNrng+K8PS2O0d",
+	"+pPetrj3I87P/fSpz+5Ju0/2SMD/GAABigACAhM2mOV/61wY2RKJ7/01MRmStiUfD+NKBAAFwxR4QAAgEgEAGAjLa6wiv7/aFmI2TwEc9qy/37YY0lWZZAQ3",
+	"7/pzSGCo9ABW7XghmF+QsTwAT078KRX4bE4IXlvCIymq9I/hTWcBYfvAKPCAI5pgH2POGJY/fb/IX5+M7////BEHxR9HBk6666YKmxTOAAk2km3yT4IFkUIB",
+	"IQv4ArTMDGYbavwBUkZgGGKNtQpwAE2mm06adBBZXCAkKf44tkBDNNtX/HBMyAIMWbavFPX73TBLXXT1/s0fHwWAmAnJIiOkQCKn/9wA6NVXsZH0lvQEo4xl",
+	"vW+gk/f+WhkPVa1f+wQXCkBWBiQP28dllGf9//gGd31hF/9v/IK4hDJEL6RhJU1v+In/rQMssu/lWz/v6cTYfmgvxb/1ODO8Eq1y3fnwynpw0//8gtvVyq9/",
+	"15KAytDvg920PyAfW7MDSQg3/RGXXX3cIAAiBhREIAFAAb5lkeAhaWw/jJYyI2uDO+lT+5Zot4zQRpNxMAbApg2pkAAggu4CGzbjCrJv7uAMhCIkoBxvad8d",
+	"i0beg0NqYFJzt1RrtaXZWpR++7jWyfLx1gmYLVHJB//K/n96Wfv+aJUY7eH4dfOhOTTEd3sIAhS2BAAFgDg14BqZhmneOwG2Ms20FNLe3H6YYQhAklcFEU19",
+	"vWgB2WBGw/+0Jo7MsizvH/B/zDwkMdk1dy3r9XqqLzj/fcE0S2Bpaz3f9/rvmUlmPJ/1Dn7UB67QX9v558pRVk4yb/obh2OAa/fT4kX/PvPwgEYQmEAAVAMB",
+	"xetrm4I/u3jIH0Ga/a8Ysm3L//6xNsPO+DCYeuBzSBL2BRFd2vA1eZSE5S6//XABISFEMP+2QYCET0b+8LUi0Kof+jdFOG+Qa/+rqBHy9amZ/f3P3mu/f/3S",
+	"L1WiEOblGZ0xhvfkXafwoMFcEIwOoghmljA3oGT+YNTuqbf3wIgmBIBsDnTs3AHWpB200CH/rIwXdMlSPu/CAAFwABAOYtHDD/DQtNCmEZoXKaHtRfhUr0lU",
+	"nBD1//L/7b6h2uuuunm40xo2tPT1109dL+VS8ewWAoDxTUqA/nvzzqSTt/7ebXxMB/KThJ3rNtYIAnDmBAAGAKDzkhf3GIvO/Ssj3MEF7OVB4ILa/lkAAi9z",
+	"BT/w8FZaVUdyb79dE6kcj9a/kUzT59YT5Ys7v54tmosdnqC7/fh7DbCaTefbBe/34f7RHw8FkKKkKfKKfpDK7qb/6AjvpULH3v56aqhyNf4KYGIEATgKMtwv",
+	"EKf43+CPWOV+EHx/vv1Jn//YKyPrpefnRaUo78e7f4Kga/En0g9UEAJwxgQABkCgoxOBMWiFbt/kgOlyaIkM8CIph+7f6MgACTXKM0FMFauuuuunp66enrrp",
+	"666f+H/sEUUfGjWtMFDpgprrrrrp6eunp666euunp66enrrwAAACFUGaIGP8M6ScIAE5yhBREABJRpGHiirI/zpF4aOiwARz6LITDgw/i8V4hyfA8IUzy8qs",
+	"IIkQ0JvNG+AB1olNx+VtgvSmRr5z3XUNhgl2SQXvCmtf6BpMrT2Cw2fvrapp46E8//dM2VYNfihWKXDx2i6u6KLp+NVW7wikIFVgBrtfbeclHo5gj2v5/QMA",
+	"TRvRqtfQ1ULeXpZ4bgfU0ww8URb/8732ANKxDg/31xdbf/FxEvz/l4cwYJoJQTQIVtfwOASrcwjiOKLqsmdcEIIROT+zDEIgP+g0QHu+0I8GkbLxACRGyGlo",
+	"mha9eMSzUPYfNGHgGMAj8GCkAEC2kNz/1xCR3DAnGhQYw2lpg8OEXPCcGsMChy/j+H4cJAEJoaoyG1NBCR/MSC+zdkA///wHZPGmED+H9hs3wAYv1/VeCHHH",
+	"I0aNqbwIoCxGSbnOGPjD78/ZuF+I+I/iXNgDnaTz0bO23r0Ca9Z7AqWemh+EPsFfBxAEpiJ9GVWyR1XvnV7NnVe+lzbrubYkygPD8NBorJg/gxTIAkDM7e2C",
+	"jSeXwKHAowhDxMJ5EZ1q51UmF+h0JB2lPgAcKbI5DR0GdDCl60D+BBCIb4Dqa7RGX4E2v3/D78VBLd/8uRHTYRwQqn8EM8IznX8BF6r698U8Igh8EP/rXgh8",
+	"EOdglkXhkExvxewHQPXc/ECvWs/4311rwQl3vwQ+CGIgAAAAs0EDKaIDrxeCH+l+/////8b4X8L+PyhcFHGmoTiilkPe+UBScRXl/cjvlebzoCIFXwH7y64I",
+	"9Lz6A8n+Gq/z2FyYW60AC0AyPU8aegBnwijgl+B/FE5wdrKc+IBmSfo/H7KF+cdHg5ANzhyOjm2BDWhwmQVICISiOnCXvFIRKLpwDrKfE/+8vwtyH4DKg0YG",
+	"dB7fpa80UuOhFJwbcMQ3D/JHIDo1L1Xm85RKXhuw/bUvX/kgAAAD1EEBkmiA68sEHgQc5fxj2QLgmwFY4xvTAYzb6EOsAPOyVSotuPvvuj9lXyDm/fgNtONx",
+	"Uc3f7kd3WY38ywBxXPO/nwwapr//5R0XUgeO3TL42KTG0HeC3l6u/e0x43KhnvxOXQG8BXuxr09d9A81iD1H+7pHy6SEPjyoqYppdHX/0kvhVE2+2AFFLxFJ",
+	"eCmFv/Wk3t6opAd5zH0UJfTi4vmx4/Z2CO0QwOKj9QLgRL7601+DXngDgr3G6zSCJnxATwgF/9qub/fDPn3L583/QFw1CAAIhqsIAAQBwAyPCMfI0LtrpXs8",
+	"RL8djeCl7D9sGX7v2VoxeeeCKOmOW2v/k3HHdULxvAIfHpHKXcXBAJn8JDelh6LVwnKA/2N4NqNdmbxNoHkhb2gfcY+p7wMAAgD6wgABAGABVyRMpYGDxHJq",
+	"rQ2H5wNhxJUwdoDk+MLS3zis+QjaeHVxgehxt9kd0i374PTzcy4DXwn3K7Q5nyf2BOP1P5y8RtVnYePAcQhMzrWUb/GwgWl1mK56v/YPwB9e2f0v//KX//L/",
+	"/Obyx/0CyAJ2//e/5LLDTsPfhvua1+82YFKX+X7wRLqh32CAlIUILs9FCWhY8XLE78voKBq7Hh7pT9mw7lnfyvzwLcd447b2Y/f1q+PfCR/79vwMNyQAH/rN",
+	"zBCzpSN2A3f7AnuFX1n5I7DF9sGxZZ9fBeARf7Pe6UUyo+YNfw1z8Am0jM4797pfDsRHiFDvRw0IS+0Kalge8rOCy+bMNLGF5Lx/wpGOvQf/FmyMoD9Uon/1",
+	"pQYHhBZjakeXiVrO8ofFeZ/9jpu2lokv/mDmVx6D5MRx1p1QH//ir16u3fcqjAqb/ev7f9r22BvfMy76DseDmXGYQ+Hngf61AO1S87WStd9391BIQyQgEECF",
+	"TCPaGv/ciYpfgxuj4dsomPycg89+Ng04y9b8Aeg5Jb9Ev79TfI6GZB43zWQGCIZ4DSwR131L/dcvp/QH+2XqE67GigO6v2+HKM3XB9dT9a8D/0eBhBkBYAsP",
+	"MUsAxu/0yftFax2OAsLAGhlgpDp4Gz2ZzDeKA1/qTRzss/f/4IAAgARjzi1vJeT/+eHc/HGh2EfHsFgKEW5/edb8b4YnbQH8dduAiYMwQAEcStMftGj5voxD",
+	"i5kwhUfNyzvusMlqUHiGB0dv+vRFh8bbwVwHYJ13a/n/+wVFqtirq5vf+gmMw1gNEBsrO3CXQGIgNsCDO/5S//wASETI4CcX6sdvwStgde3kyl+XxY+vDJKL",
+	"a+nPAUSY4Q19earabnnf/KX9Gtog/xcFMWWfz8FMAAACsUGaQGP8N1rA68PUJK98JnlbFAMD/gj7QruScb4AKJn6WUZ7v3Bd440qV3YBdpa/SvI9gCDIQJxx",
+	"EYl+pXCI5S6VcCNb4l3//AYFOeTFaYF7fwpYa06AwGtzUAmbqNcgSPL+fK8s/wGTiW3/z6UXPJt1XeFuDG1L/n/nfdrhpbtztvk7mQE3BW+6echVvosWL+Zc",
+	"pO83l4cwOgLIIdAWQAIhW1wOAklzgcBETcwQ4jguKq1Vf+ggggEQWiwHtPgfGOW/h7zGgIHCpu6UG2glbQRCU18Doi3PNGH8NQQ/YMEkF4Hhxl69AwChEMEF",
+	"mhGHrUDkcMsjAktNJwvJMcGYpQbAxOCGjQoTMg3sVBmuK0dkB3qyWGnwy6CIQByEAuCT8ACzsT5NVc6CP/vwBEZ8K8ZxPoWN/kqmzAbW6j8s8ytT+1glOWon",
+	"k91NBftf7DZvgVBSZb+t/vB89/l4vq+zrlHoT+33oDbvH85lv5dweeRRGWbhfg0mgKJoCpNAUTQeaIAJsfBC1QIWA2JyhdMMRuQLpmgI+EB9hvyDQog+B4Po",
+	"BAAEeILgMIvRAS1XvGYrRga1XvI1em5C/TYh4KghoGAQFwRFe7pFNj8QEdQUmvuDgghHA8GdBhE/81pYQgCQFCAAQAhAN4AlXbDRNU4Wf4AFzh28iHL1DPAZ",
+	"6dXwxpdNH//jdoue6S+EwQ4ihDkZJYeMkv1Rk00CzN8cePQ/isGzZbxrOLjTCYgH67gLOVYJCFL5T6K4RBN+XJbe752CuZ4RhYFFI9Kk0FEPdAgr+AxLFrS8",
+	"eYmdMTxcCBCp5MyYL6RezFvsEIRCFWOEOwhCARRD2whCAR4EEGMJF8IQj/L/hD7CEIghDWA1SdLg4MACYAHOZGVrcbvwAO2jT5y078vggCIQCP7CEIBEvVZ2",
+	"CeIgAAABQUEDKaQDrxT4RDQJAEymjrUH8BYBMAB/Mfkir5kkOABJEvySbfDsEEI2RV5f8If7PAgEzNDL9BEI+X/BAEAjxsEcQjSES+EP+X4bwj8v46EPwgEQ",
+	"yCCA60u6+AMuu5//e/++EdYRCMJcM4D1vuvgBifuv/+3/6wj2EIQCKMS2EIQCOwhCARhJ4R7CEI9hCEaJKOxYX40yHbCNs11EOtWBAejhgtw0WBNwrlwlVeh",
+	"uaAKbsxO3wezspN189ZRGFi4bxVEywzN9z1UI+7gLeEJ+R+6M3v6kAq/yWY7ZP8HmEq2XLffb8v4lYUYX4DFXa9ReA6/4DzZh3Z/1Qgh/Mx550WwOETPqwlw",
+	"72wDijtNV/TS/edYW5tx96Irw0UyPAaNN1dARPRVylc2VyF/YAoVNmD+riuFgV/Z3lHymEsRLb7jyQAAA4ZBAZJpAOvLBB4EHOX8YsNDQuCbACSW91lhmL5T",
+	"HFVgFKpLZelirvqH8VdAn5/8N3mTFJNN/66ObkzZBD3giiY8AdbVTt8JmvfjYd4DnMm3kwvv//UzISyxf//2AIb/8B3jgy7UB27OtjR9RubdUKaby4tv/6gv",
+	"W9YX7UB6aFRfuz/70PFrV//7URTBJ9e2tZlSD3iTXZ588gqAOTMUubSeA83lzL3BzYrqvshFHSyABQGbdLqfNf+nbptge4QBxKZmBvd0FuRvUY3gb9oFtqqQ",
+	"fDGEaudvP0/sCm8CAARu8IAAQAwAjlt/IZ0pkTFL8hVG5xA72SCCv5pwg2yCkSLvBr9KFZt1L9jCMlh35iEBv6wNTaGoaFRcmqyg1cBc1TePXX5lnWBvvF20",
+	"Ba+Q7xn5oFMil0ZTtXNPfHY18OfL5HrcvY0tr3/iQZ5zm7/v4OX3FvsPUp8GzAlrdcZW9u644P+/kDdhBnwE+19tmdr9HrFfjP3/4ED+M+7D5e/ylv/B+AMI",
+	"Se277/6jcNixpJg4derQ3r///lL//l//nN7Lf/QLBHJ0qDtr33WF4qpLrKd7WnRx3hc//57BMppPzggCcxwguzwcr+YRb+p+IkjxZ+XxEcxM5AYEoHM9s/qq",
+	"992D7li2+eo5qa1fao71Qq+/dAkzH3GEbtwHd0EjnrH6Q9zxYvQTtmmhNfAlax+Ot4ntpSv/ZSl4A7qajIr//+83lEX0L/Albh7/WpuwNKYSquAX7R9jKVIu",
+	"fW8VH/wJ8TPbOohIZjllkEWv7+ERioCAIUJaBRKxtTaGfPXRzu7wKmwxBtTkn6NMId/vXMlHJde2Dl9kXKPD2u7xZ1uR3T8yeeH1YkYYHdVm7DsoYsxb9Yj7",
+	"Ox6wcNDWBG3n/Y829Otu693AjwB5dd9LfZ/71L76E4d4y2pUINQ9PqeAYWMT3vH8/zuCAn6L6G+GVEBLD/0sO6MHUtx3lBq7pyeD0QMjTvKEA6gOs/ef9+P/",
+	"/nh3PxyrDQKDp6wI5yfH7+qQ8aGBgopM/8QKz+NHr+Y1ccPiHBWcD+rr/3/95i+/H4NN5lG/1P8d9WDZBEWwKMJV7H+3KxzQZs78/94WFBqEbN52N2uR3XWv",
+	"5/b1Vn///Gvg0S7kNo+COUuql6/vy+f1hkxLAmks4/NwAMfSA1vRQALbpeb7p/6D31xF0t6/8ewU0n3vn8/BTAAAAs5BmmBT/BhVdt2RYDpTKbxwmn3pP4KO",
+	"O5U8uWsv4nhkIhzABfnWzIE5t2ABzo4jMW1edCyMhobUwCIB/4EdrfOl8RF0wiOG8ADGKegaGqRf/wzmAFmH2q7xuthz/WB/vqccAjUgImaMIABEyVFF9SWm",
+	"NpgJO/7Ll3RpMz391edlsBg6D1a+4N8Sdj5/WH5EhQdXp7/Sxpi8dqVRP7BMsI45gSp+d88D/JFSP0I5LQWx3zwHg6q9eXzuxULcGT+6rf+d+l/8Iw0ef373",
+	"yA7bThdObfPIQl1mWlXee/Bc1sNffjzzMIwjDeDBNBKCaBCEyLFS4HACdbmIL+O5gciS5PleX8ChhlQSnHXhYA/uXIxl8ChCHBhDGDAErLhqSHSKk0F3QM5e",
+	"hoYcRgMSmjTXXqwIIIcOIP///TT00xFofbbPr9Fs+woyyRl+FwSf8bdUAJLrHISSuVN+401AkEiUrJf/5ICP7F4AxtV7d/r8AksAbU/+lr6YQX4f2GzfAEQU",
+	"mWfy3++WYybWQ+O7fo+LRsjX/v98AIS/q1zGAfMzuzA7y+HhzQjC5cDoI6Cw6COgviCU2ALKM92ehwdmcSSvYEn2ab3DfRpvfC3gwBMglAEyDjWIAnxlpC5v",
+	"bKmhc3hVsLFOQ1V75Xg8UxTVXvEQJURaHs+WxW01gQI0juDY2Q88xDj4AhewSGStX3Y5FvFAANw+gIALnGbgm8v54fvm7llgJ92d7+HBMiAIc021TRGo4R+v",
+	"XvwcECEd8HACKgkAJgPgNVOJd47Ay8HbBlBWZCT7Q9gKUUBQgRYIb1abNjjiEcQQdiBI641nEBnQSAsP9NP4TgOsBZhy/4IHzvCNbb8NlwE0hu1akFpUgBQq",
+	"bwAV5khxJ2/8//AFpIaOw2p+JwQ+CFXeH/D/gh8EOdgnlYQ4ZBQwMg9L74VJBieCay75//zfoQPxnvBCteCHwQxMAAAA7kEDKaYD7xWCHRvz//+G+pqFTgBF",
+	"86cn37Qz////8Z5jvn8/H+ug0MYqhXwgX/w0NC47CRp6BbhuQf5yL34HYkCWAe2g4+fJR4Scb6rUAD/ovLrv/uX7xomgtxL+AqUX87qENp2B+1EDUHfSH6A+",
+	"2AwiQORFkIm1PaHXn3beAWuMhtT+CSexfue2+X98wVC/CUSDEkSGuEbUf94xakMz2wy2B9g4bSVge+4RLMETeySIkYA5ZGnPIc/Lg0fv2Xwi66C3BG+BtAbc",
+	"Zm0pguFGD3+BUpqUHDfbfbwLhachLS4x4vh8pSwpDeS1I3fHv4AAAAOkQQGSaYD7ywQcQs5f58UEQuCbADWWzMifqQs8OXWC7qNTLdd6cABldE0Ay8BgVB7e",
+	"tX//dQiQJavK/V9CteAGL2uY/op17yn+ZHCicy/QwxXYd4B82KIXKn54XW9Tg/ZrGwAYC72hxtZZqx2WErD9tTGK/3TISKRj/smiqCV9vX3r0PB9Sqodv0Iz",
+	"GIH2nFFhlA4ufSB3rRxgLNo/I/ZQB//xDg/A5fFsFU9IPZ7YHeIa/7A9DexgotZIOXA0g3QAcZT6T3QS/zA8xIt+grkna8C/unE46gpHxQH6f/ty4uO/zGfb",
+	"tHbA4SWSx/apWBBQUKHeAxefS7a3BWAA3bfRj98yq1nfb7UrdZQgZsfwOLgs3b1DvkF7LZEysc5mAJ0tVQFX5DjyKjbkN9T4Fad2LtSzofvmxH/qBnTyV5CJ",
+	"/wfIHpolmflpnOuzfrGz/P+YXvU7qDjK1fCJPHDZIkft/+1SUwKdvzLlGqttaS4/A1+o/P+FocaZP97ndfU6//8Fs/36V//vdziV1N6PsN28P/X8rBx8Qs9w",
+	"0IBEfWmsBOf//fg5sROetDkm8guQm2SSi/8f/DS4gdY3qf0DAny+LGKowcHuYmNvb8R//5WU0SL88/6/kp/4KiCE24UzxTLm/7vjrV9VKo5PxMaHxYzvpTH/",
+	"WwnVed40HtPAhLZgOLpc8Xn/K1Lo+DdcfXE9J3tAOzTSjvf+C8FEu/tT2TYrdRYptDG8JHuA+/wAzevT//EBCz9J72kdV97++Z28mp/PErFHuldqdLdbu7I9",
+	"eBA/IWXVueqCIYcoIAg4LNDJidtYFypt+/rN8IDTjHetx7eAgr+E9NxvSM3v9g9w9Udl4/YRMv2Bf4CR7Z1vun8AdUuzu+wtsDWg7+24v9PJrsD3qDpAeBjd",
+	"81+LHkHKd5KRyPAIqpNxpRLZZM66DHjotn+3ikwKMhXLUvxuXh3lDz4ulEft9c40bjntyqdo6oz3Jgf6DhdxDKo/XcnmBFB4O4bcIsqNQq+INobU0y5bzmuv",
+	"ZC/7oOxKzi1ktmef/54dz8cX8NE8NAoKsvgNM7ZfZ+3xJ6kWE6koRGezT5fgTW/J3Kb781xf/EOCstZfcq//dcy0rSp/+3NQ287FuMv/Bx82nv98gZw+P/0Z",
+	"7N/AgLv/3//Yah+t6QFzrgdF9S/3wdwGiFxtW/WPO4Nq8QAVleU3+fyIMkR3wDZsEVsEV+4DQ29oT+J/+bsX6Cnv8ddff/X/gsgAAAKTQZqAU/zyqcN2QHfc",
+	"Zoifz8uYcMe/kL4i55I3gB7GiH2SnvwAXrUyMto17E+7A9vfgAXfsiQL3gp/v9BBM7W4enynappiX4vCNe+83Qosf/RRbaRsiDiBapdX/kv+b2+fCKQgVSA0",
+	"BgBC+n69xK6jmNC6RJdQAXjd6G03yhPRaOt/nhuB6RpwMHqire33udh0VCDg/31xdbf/4sSRe/PMwjCMMYHEAg6CHEAg6AOQDDoMOQDDoMQBIhCawOIhbgeE",
+	"JcwPMVwOmO5gghuBwQYQgw4IMIQYRJmKXhxDFueVXcz8F5S8UenJ1CSd/Cd8V17/0Bg4MDvHWWBjPigLsvFCO41RDFufJoE6/z3C8m1gwCII/c/rWDHhBB+I",
+	"tDznMnMppg/0f7QZxIcBJAAdESIxvCvBaCEMBEK3fwBie00/eoP4AL50nHkf/9TCA/C32GzfAGlhlIlav6p/q6ffB5U/F/HyP/O8UIJfhNuTbxuECr+/djPO",
+	"MEOZ3hGFvBgmgygmg+iV+AozSNkme8O9JEiTPefgiOov9wKEPRWKz4Aupg1NK1CsVskbIrDZInmFsvBOCdNbL4dl2Sty9HeWXwYhCEAMEChBQYsAYoA4Ongo",
+	"NzxyxtCCSmgIYAHHodECRq+XtXwz8GCcTTTTAIG6t+55WgNAgGIRDFQNf7KR7mv+BM3Lcm9qz/g9qIwR9o/eIdBGfF/x991D7l8I8IQjDZQGpMqXhl4V3AFP",
+	"L9az+AFoKT9iS0vfeYXBPRrQQWREQxLUS/GJaiX+CEI6CIR0CTtBfhc4cUglWXvfox/BZ7H7NghRoPBDj2CWkveMXNRczPCMMgmlAXQRdfIRRL+DeUYRb93r",
+	"/i19da8EK14IVMnghzwTxMAAAAEVQQMpqAPvE4If/Hgmd9333rHfiyu7vd3/////+M5Lveh3Nd+1wT9VVVV2sQEITL//U0sMSOfv/oR1HYK4R9dAmLR5f7xw",
+	"VC/ZgxhJAEn/EH+3I596t5ruKzEfpM6qkw8AX7jxKOmiAKpXbTEdf2xjC3FWgUY65sX6rqwU+ulaP/7jy6fgfWxD6taEBlxBOCFrzkiSHqWAS8lnpJ99EX2x",
+	"0RC/+d+eF+ASt1pp1EVTpzI4cTO/HD1Afrkj95kezwTQsS8BJ+rfGsOMmIAFzL6nvUoPd5H+bt+4IgtzbhVQWxwGv5C1c4ViOvMyb7+nv9jKVPp/fbGbptF0",
+	"iQG6mrVK87fHqdulwXfcCmVf/ufCLBPX3viFqAAAA9xBAZJqAPvI8EHELRf8EPmL+JeVBcE2AMIq5z9/QDi3qh9n8QRGZNAKofuv4cgT/Ui4qP//cAyxy7/4",
+	"uTfutoh+c62XsPTOBC9WWs/M/5ZCFtniJ7OyyXxClQjDvEIeJbAP8/qsNZAHu070ad5fChoHSRfYGohKg2bXj8PiKRh+3ao1/+UHk7lRSE/20qTijzE7+K4G",
+	"n8YETX79G1LNmv7aAqT0aEqe/RNk416DsLkDEPTZtFtmxjsD/2QGo/Yaf73ScHMX+R2oesfvDFtUCn2k3wFNWB9ba2rAygL041QiaGHWVoBPwTqlj1QuNJBm",
+	"34SFeHgGMGzZSt+7oO+UrH3aAm99h+x1AD/HQCYMZ/cxzvTf9Hfwnb++nzCbrQHHylX12n/ThGr/69ofz1d5+gJwBD7fQU76buIORj77Qwr5NG4/dJMSTqkK",
+	"6WpLaLQpRZcHsoev81N/Jgvj7Mc4r9O0Bnf8CB/oKXit5n7+G3h3nuWHPr+lKNqsa7Ly5GaXmTtG8jJXOvTa+nu+8ajo1HZ8tQ2JMgecMB16pDRCw///I8EG",
+	"2CHzUQNCAekY8yxIIrUFxmS0HyeFDtiUgfiqAZlTOR9QASQYfbT7X4S/h/h/+d+X7ppCw91SxIyXrYXddlJGiWQ/9PSLb3jfj4/M9upxt3fk2/O+/t4SRGqv",
+	"0LXK6g4ceJW5O0za+A38tF6EbuJ901NeAHu/97jqRUnyEg3HPtMr+AQalWKtff38psZRFTmEv0SDIANfTzatAS/u3/2n9qMD/7zbko5MTkyDb12x/vNlzzq8",
+	"fYus4Xc9bqA9H99/CIMKQEAEDhZQDZidsFMqP/If+35DS/tBhKBkFIOyvhDNkPfeI+PdbUXOJU/7h1nh62x8jcXL5eOz6vgb1D34ljuBYQPMWAKNaRRhdViN",
+	"THu4PunI6Qrs4BDTLQkmmsANn7/dvQVc9kj79qLL0vgEaHXWdVft6pCCA70S/yZ6migo2BN18h8ssce+w/kCaj/tYP/N/b+sX4zOyhyEJ0CH0qc5o/dT704/",
+	"/HvATV6MjdbME3h/2CblIda2+g+wyLDkHVhY22qGz/XNTv/+eHc/HKKw0CiQ2BubFqY+ZxckKE3vkQGvpBXYRMjjRrFO+v8JqQelG5f/1/sWLJDJWOqcdXqD",
+	"SdWH+4PE9Qo9vk/mTjB0y/H/gkymLOrX/m8HEf9AsikcvbD/j4Hap2Bv/+mnRdfqbougP1cEBKQ4QABQFMPjC1IOf0/BWTdIgQPT3fsglwyRvuch8IX8fE0y",
+	"O9HfEgHQLdNBnW/5C3xWFqd/4RYKaJV73vn8/BTAAAADGEGaoFP9fSl8THehvAEAqyTVY9+AFFahkr20GjO+h/3ngcQAQIghOIRCGrUUhGpTvqqhMP+QlP/H",
+	"+bs+3XXzxck8MBcBSwlqjougHFcsK06uUxAStZ3lAANarCe77fOTbJm+dnhbgTf2pf9/d+trFYVvdv+3ydpkATcHb7p5yFX+ixYv84o1msvDmDAEiCUASIAh",
+	"IjAR4HIYlzgxVzCMEe92aCHDeB4DGQQ8BjIAIcITJYHtXPA4IhNzPw6V3W9xRqqrYwEFbe8/Dx1HoC9ghOcKkgO+0q0EHX/Mk+fsfCEaHwaWgLWRFYdulBpa",
+	"AtZEVh26VsZb6xluOGOMAaj9OIaj9OIUjIuZupEjIuZuoCehNyI9CbkCWaOBMXZo4E2Yf/w0HASf8AIQgSUrh8MN2ocWBQRtLDbXwHpgofXzB4dgKmBILYQm",
+	"verX0F/NU7I/68C77dZI2oKpNPxfO/9TQ/X+w2b4GPluvk+/794KTLP5b/fI8WjRk/92+QgXQxXA1jI9NNzj7/id+eaEIX4MASIMoAkQfEuwBa0q89HSkt5p",
+	"6HLW0C1t4RjfBpNAHIAYKg8GhZAVJoA5ADBUH5ULIOIBkcACiRkTNm9M6b9EnZMmb2rbfofiZ52vBsGu7ds8vB7tnFa9MgxnbPnl4/BKUnnVYD9lxQERkdAE",
+	"MvggBACGDAIggh/2XD4WDxQGKAwEMbO1amBNkNoyKtGDMI2lnHZpgDG8otr+kvhOBAghCIfCIdJBibLpB4f85zcVltzAIoP/7kU9tlX80BHAADXk8GAqyAb5",
+	"Ab2tX1fvASNVPn/8GLYXJgBiPaHKbnhNHgso6gJptCLn/fg+Mno7AGDOVIbn/+wMEChDHFMK2W6NAb/2hgNy0IK6Vf/ppiHYRhbAe2ulAEiCDqa7hp4eAx0f",
+	"RAgUZG74F7+HQfQRhCGywE6klWr5RA3bwEvt1W/wAL0Zk4SpusfeYXBPRoAcQvBCEfBCgVJ1wQoT2oIRE9/h/BD/BCiXeCHFwTxikYfz+foILHGIIJeKLFF/",
+	"kDzv+jV9a8EKJl4Ic7BTFQAAAR1BAymqA+8Q+CH/wRAoWutY6sY+Lu+7/+v////4v/J3ejCMwm9+0ZvflzvnYJ8/n47/QJGy+EF46juGdh/Pwg8+ugUdrCFc",
+	"vr0cuQL8wGAdXEiAHGdGB9sQI8qIfj9dQ8OwsADJTah6L8YCV9UiEp6Sb6f/xYTLhYuAt7+gP2lRYNM3qryXnuMS3th9m1xDPA4Lqcw+aZEWU4Br7/affIV6",
+	"OyswvvVr9++X/7C/CMFAyIJGPI2UAw3XV/dKnklTn39QYu22n72Po/xnVCE4gEuCiKtwDzdd7+b+AHeKUokI2oICT7XOlt//3y+LBBrhYnhFoN8ebEB6GuUd",
+	"/P+O4t/e7cg9Q7UIAvss2+UXXMUt7r7m+EUCmOkcbbbbfuAAAAOoQQGSaoD7yPBx/iFy/4IfMX8dynC4JsAVGRPjjfALn1pO3d//gbWFU6TSM26lxBLmyu//",
+	"+IMgR5IhI+6vsSYWdyolEPf/3/wAvb333fnAEj/ed+S+PTaPh3guzuyHs/cjA+nW7gAjOpUWe65eCodmJrFr5X15nvYAGBJmYjQ/b1beKtbP6f5rPZ45saU/",
+	"/vaIu9UOv+9MaDGlgRu/nF9hWTqHmDCRoIwQjh/qvtn+3jacQ8wOX5BR8qD0Io/ctn6s3fcti+GjTYv7/MzjfpIDC2zocXOdI3BxruQb332kC/kOVP8pdVi6",
+	"jG7F+Bi2qNHT/I16nuv33haEktl5/xYKYIkHeA6u1Q7oPwBM3ph9/znvrkIKyhv0TWMzCHf0n9a+eAOP2BPiWv5Z3jdxSvAKDXDgYycOn+GADsoHIjXf7mBZ",
+	"RbYnWxf/+w5fHoYXig9rx9O779FsinzlDOPT5uf/EScBXVfh2Kn4XXOtBw799xGey+llKXmjBzdnS2kbR///k2m8f/P8G8l6Wv//75UFhONnC0bNNAsaNqxw",
+	"b/nfZD/zP8QuIXYIfM3YWDQgHjidLKWiP6+oiSfhu2d/1ANkl/7BUz93Wcm96BQ3//wIsmBmcF1cOSNP9/P9oBoo4+v8vqHLigmHrgIs79Qud7ZNWzyxv8ko",
+	"qbUh/3bP3S9iH9b+MUxri88SPR/8ONqAuXMn/g/K9cyzveChy/nrP3sqtHPwFv9/KjuvHRRCPjRVgEcP/9L/81glYNId4HuvA3tdRiftX6gv9e8OP/jhm72b",
+	"LAtvvODvV4gsd+v2a32BPDQm3/dO//MiPqTsoMLV6t//sMxaCMYWnM/qshd2if1tv7hy/I7jBQeqsb16cXPkF7IS3gXZWuwzryHs2SSw/oI1/gb+wDr13B+P",
+	"ybNrAf/mRqT1Y/+MHEFi4OUMPb18PdvHUq0iy7ojdpeNB5F73l+6COw72jwbgzg43dH/uPIqDQ45ockA2Gsaterc5zf1z9q4/92//5gHskJ87IMneyfzktiv",
+	"pnzyDUbOmj7g8TDItJWPvlbHKo/31g0//hB6QaGCL6aGX6asmBt6LkO0q6ncVqkfD5/hZWNfbT19/sSTDJQzqn9f/znH58gP/pUDN/8H+fQnXBzRwAcThhT/",
+	"7miHrUP9H/l/N8NRC7tjvJPhqgP9htvH6q/UDdU9H79X8zD8iv8/94iGSMPT2NfR9NMgO2Lh/czX/z/69eETeTX/lZxi9EVX/BZAAAAC9EGawFP89eGJ8fIX",
+	"8Idwv4AWWiM1nd/wPV2iCo8W/8w6JGAYM8LQZzrxeAZ3Ic/bA4AIQPaiazf/8vhGLpBcMDeCaNMFz71Ht9+AF42WyNN1sGEfq5/f39ljpXcWLRpd/hlAVXZL",
+	"W3/tuLTA1cvP3OoZl6yn791LoxKvBSNXpXjDRXZrq0OojpooVb9U9Qb6v3EmDN84JSMImyxKujv74i5KhtRVuK2l+fQ8FOr31GmxULcCernuq/7vwn/CMNHn",
+	"83e+QFNtFC6c2+eQhPWZaq7z34X0xr7rz3mfAk5f8EIEj/////+DAuP5W0K1wsHUmusa3obruOsCBDZ3u4hKIuAasmeHQbxg/JXu8FcVndMeTmH+H9ArD5s4",
+	"gmhAomEwsHS0HS0VZa2hbwuCb/gAuTf11n7+dCbZY0dEXajdYIxhK1GEA//ADn91Hrq/4AoKibZwdXsnw8s2kmbU3neEQJAW8HIfg5D+JogUgZ2xUIazYoEA",
+	"HaH2Z3SvdIOLJidnSvfOwV5/O+d8/n8v4S4IAiDAEywXosgcSyKPTrHPRMal6dAQYRhIkHXm78yxDAQ8NDrKpswYDWQeGrKy/EREQQimBZTeCG3cWwIhiaxU",
+	"LzNgGALGEBJ9gTFjZBL6oABflZkoiX82ARLkEv/4rB4ZEPggDwCUau44TQEw+vLlVewAaC3kRBrlYyNvRp0OSFj6SEUXtAOIcsCBieF6QcelSaCY3S6Exr/g",
+	"DEsWvcMxM0mDL4R4Q4b4G9dC+dLuBX9z/wc0Thkrz1z52CvO+d8/n8XxBCjlvCEgIokc7CMIQSiHfd92wQwQhENwBFNAzHNWr/8dfwCDX6PT//wBJqvR638v",
+	"gzhAIj+CITqrbCOCFY5j2RDL2tb3nYJ53hGGQTSpGghRnSQpIhFr6/P+EekwluOHQvzsE+d875/P5/P28JepgQQx7y/9wyj9l/CIIfy+EQQwyEA0ERKHQa8N",
+	"+BCKJoJBOoAXABCrN6Ih9fgAZHclM2SDFwAAAhtBAymsA+8RCIIQyCaAmkZirV84kEASK+ov9wfwAOcyatbm4P8v4MsPYIeqiYXBnDta134CamZVqAEgNqAB",
+	"kW0RTNkg8ADHS29EjYcvggCAQu+X/CP4LwiUXjR345/////xS85lDCXXz4fl9Qh8hlWsvhOuEJqr44IbHwigSVqqZWCAIBGYuW87BLnfO+fz8bCEgYh495fw",
+	"gLCMIhH4cFcBsm6T/4AYzX2v+9p4RCOb/1HCwWkwA0dH7fa9CAAIhSCNvgAOheuYpfmUEBNg54J8/CHIHuH3r4RQgtwjC3u98BNEV2rUODBrfhwAKyMzQmzl",
+	"dmD8Mk4CZIbFrUOwtLwAHyow2S1MvUMP4bwEKNmLWr5UA3AS/o+erYhwAHjWYlbdOscMcX9coSC/DsNCaBkSAAg9LC6hJ6em5UsunAJO6T5nwwkbAIyRJ45m",
+	"+79h94WLgEX/l/Ov6IIzj5eSTl4He2L3RRIH7dX7v/+EeIJwYqXj9wfBwfGVj5AOlWy2Pe9+wQxQQC/COiRgf2jL9ADG/WMRQGrslKNvlGH/ZvCvgguqQIfc",
+	"8h1nN1X6gCRsmmB0DZjYqWPVaGsLsIQtwFZrN1gP7s3CkGaYLsMd+I8FGqrYjfzuZedAb4RLiNHCXEh2nqzUCN0kxpiV2vXDJOAhjZ2rUdAO+AA8byCVZF6Z",
+	"gw/hvATRO7Vq+CmBv/DTPVYcAB8nENH8XJWDgAAABARBAZJrAPvJw2CriHiyA3AHHSbz34A1dEz573w5wdfipAH4A6ybWe4AxXI2VV4xfwRdEC5cAEH1+r//",
+	"6MItV4+O/wuQSTMXhzvbbGiFmNanqD7MchnAf/iSn5oH6J7qZpwBV6pn32+CfZ95y+CMShDNh3gqp6k80fvAP4kF7KWZ+9wAq3uzs9yj82W0nx4DUON+OfAY",
+	"+0VLn//dTZVIoXP/NEr4ZpL1J/JUiUmleQxYajYSsGw1cyshG5ab75tANxJZbn33Ta1vsHL52QmoehPT7vn+nT/LHGr148Bf9l9oBdIc05UbMr8wD3dpgf7I",
+	"b9aX+FT3ATmedj+QgASpoao4+w8KceEfvT59lVoyii//7o1cvu+bwU3msyP3rw7zP3ego0zvCCJQ5pGP2uE34cq9YTXbwwxiDVYff975fXb+GDej+dL3ICbJ",
+	"IIJL2WAW6765wrk6Ou9DV3WNfoHD5LVj2/HUMxInhUs+/Ycvnm8aHp8RXoYl05CO7nRHBor99QFH2hxm93v/Ue0b5YqncPNgb3z5wOC3qG4602rMnEpR0xWb",
+	"TL//o2mpZvPB9XT3ulXhYTmQJkRvc3AJgRoKDdTk/dhff///k4WFQe/B78Hv4EEgICxAiLcwG3Rp895AghbmAzKyNHVe98Lwdfg6/B1/gUJAUC0giNcgNciR",
+	"c9IIIS5AZVIiRVXjPZQ1BYr33m2rq/ZAOf+eNr/78HRx/IlyPutqs/Flfz//6HTEvujrv9Oh1/l+QKeID1xQvCyAUV2CbJJScHe9/j6VFefT9x++t2ftIcg3",
+	"hBugPv8dF/LzQ5uXn4bIN8f5vwNRhMo7C7/IwMT3Sar0366XgITcnI++l9yKSw7wIXsPugwnZ+f8N7U68Cd0fA/Ab5Af7qwKG8ZWFfaPi8z/1QFFfJtyZM7M",
+	"MyAHX7z5WeRfroYJc1GVORNPZP3r6B52HsLzdR/87768CWscVpZJj4lG4Dd37DzQl072YW3Qf5VTmh/kT4AgmxwEFgg9i8hJODIN69tg0Nbori7UM8v2eDyu",
+	"ch1///67hAO8E3juySoFXQHG6+27841vc/u6Y/5kJZ0h7za2dX/mR9+HQO6duYjNWcd5H6QrTn+WnITHEey5un/whDI04BTMRecoPej3U3+d//zw7n455IaB",
+	"RIMz/EIZQPBAjH1PpDz1SKALe7hfN+DwbPvvNVr/CAZK2LSgN9izOzTIOHNGC7Ez+Hp03llNBLNhAJSlbhH2l/5//A/ij7ETBFQP/Q3hqBi7wgL/WBXpNqh8",
+	"3znqQykufDxBdYQXZ4DNc7P/8/B3ZIPIVzr//X7UIwyRk/2A64jcsD/buYeX+AH1RIkB1ObD7tclEnx/4uCmCRizP5+CmAAAAgJBmuBTzF9dyRvASDdgafaB",
+	"Hoqbj9X23fYDu0FeFJ/lqHu/ftbSIC94KaV/oIJnJLB4bf7ymoyeHQT333TJ0Vgarjh2JLQ0ORdRHTSdH4bqq94QUhAqkBmD4AxZlvb60aJ6e5hqXfiF0AJo",
+	"3kPTXfTyoLLL0tw3AypGnAweqKv997lsOnIQ4P99eVWNf22JLL1nlhH/QQhHOuCELFxnLoo4gxjNglYu9Sn0KJs3gYJziABEiAvHgzMdBGZ4TM4EzIhUIghD",
+	"Rv+AFO5fQ+PwvoVyf9Ji+98v/BNhY3zYCUpC6WJVcBu7f+v++zTvCs7wjW3CObh8tFHspQgeLAA/gwBIyyoEjIsAAxAQEJKNPbA1qnxVgS3JZzy+Bj4oIqCk",
+	"jiXMUGD3kHXmCbyf70wTY/wiEEP4CFGxC1q55F8HCDkXi4GLIDB5ACf08XMzl9YG1oKlwAGJ7p4/Mxy+QE5U0BdDlNCGAACh7G+AmpjatX1fWAAX5WYtEy/o",
+	"AISogkGAASgCwgAWARYqqph5ilmRjTCN+f4AGC3kUzRkZGS0WPIXVBUTyngPGLSoUvD8sZ/AgFtoJf8B6S74oiUwLdNZqDQR349gAjvy/Ie8BgakqKS763t7",
+	"NtnwQopxVz3//hpFbPghDMNyRfXwJ3ofsQ4v8EIKDjqR+543eEveCHwQ+CHPBDFwAAABIUEDKa4D7zvgh/9AmH3wSb3r5b3/iYJ4R5AUXnxqCE0EInd4x4If",
+	"BDCPrgkJyY31bwQgkKq6QJ3zsEMI+jYY4/0ODTfd/WGgQeBwA8MovDoRiuOfO7wQod3ghBJ3eLwQxxf1xQwL+GkkQBV3wv+anG/8TdeBMmYl/6O+xMY6aK0f",
+	"GEV2NAeKvf952CdYW5XhrNe9YT/u9BinXB/2sPDpiU1eA3VIeIrodqvAUa5fd8vxqNcQ7rP194UDwXLgj8n9NGD+EZ8O9Ac/p8j/cAL3/5x8L3peXFlw9HAf",
+	"/6ncgIv6O3PCgBt9uyl/7BDwsTMWDdS4T0XoH5A41LgPtIvWBp+114++Z56RxfVON7cmVr6Ps6T0V9/6vXUzfDmtVw0tz/AAAAPwQQGSa4D7ycNgowPDIgDo",
+	"IiAJ6CJGeBa3enwDnAxFBdO1hGHMDoEMglFoDQiZlwBCPJLlQd3gYAE7tYYv4e4kJhfgEh4mYcKtA3dIUv7zP/d4G+TH7meER77qHGNG2lj+u8DG1TPOwCnf",
+	"aZ1oX3uhfuWHYrKAXrjOZvH1igDAzc28fYfQd4Vq2xol3yD7uSwM/4AH0087rR31WB6+76DTYDbsj1lufVN/vpN9p2Pvv5uWRD8XZH/2Eth2u76V//uzoNXM",
+	"vXYuRag/8Wgb2O3z43HAKhZEl2f9/DAD1/f98B+HrLpHAQT2YsoQ87kerJal5fA3ycBk4w76cWQnV4H3tZopZSQhM18MTHz7hoGfEv/nzyw0vEZ3D/6sACvv",
+	"vtd/Yq8alT8A6GtriyP1vl+UYRqw79wwQSPSA6AUAy67Y4/27sO72AAtfnAbp9oRVNfDd1UWmOQxORC8vW+BTPk/vh29TKR8kZDu41/9R34tvv+7sPGoPZM/",
+	"01unH4EB34QPvN9b+L7+6PbXaND4ea6yHeiKhqQ/4BZ+tNe/ecr2/ptml4RAtJXnS/dixanGqMAkaTVef/rhoRA4Qc9lwCQgWdoAb2WJXT7X4AORBkHotxj9",
+	"2vkQIOG4HgxEAdAjIPAuggs78B1srT8Ae5AEM0dadwjC5JRaCUWglFoIdAhkAHmQgAmyAJfcgOBqy9EHdhwCd7kHQEL7WGeZBooCi0PJ/JCyf/WJoNHefnxv",
+	"66bF6OSu8jJi1hwslmVf0e+r//SnQeJhNY7dRMu3v+43m2zQvK//3lil/3UfxUd2EzI+7l/D4HzytIKPxneKulikRnwPm8NdV0/twvBHBRb+MFteA+4Ugjrs",
+	"yvLfF4CobqtmfOmyh3rCwoYXgB9TwPeIL8tLn/GxO1PxmcQ/29c+6HF0kiLo8ZcwNXxHvVh348oBqeB5A9NCI8R5pbneypaR4pFfCWcrf8wLcgaKHpp7mnGf",
+	"FyxxptI7j3wiG8ylJALe/da/6g/dXnzXD2dVgdd1+2BdmwEw3Iuoy5d7qwQ0grl392+BtPknd/5/4X+juN0+XwmUUpLDvTIYJSJ5vwv7j+gNG31FA6jQ14Hk",
+	"J42B+yKrguxkUNb+zD3DB3nvmX6OtpiuqPfdDN5bO77Q/DI0hCikieiC+ZZ/uX//whjg0MMEoqTS2JUkyrlFSQE8IjRYDYbKc/PwdgaWVTYpP0ThkqTMEyg7",
+	"f8jr3fhxna8NbxcbWwcpf+//TSMUa6Rf/9/+X3GPw1GNZVt8/PR/fV6toESYZhv7OISmpGai34ZhNckt5/mDJBuxXGv+jj73ge4uT1zFJ1w3I5z/nIT+q77f",
+	"/BZAAAACVEGbAFPNxvgAUWx/7VpFv3hfY40rV24BRK+v0sUgEEMQQFVsKGIStK4RinLpU6Cd7413//AYYgBakogmzf2AhYTqYGPpwEwKr1oPUrq5wdS74/s3",
+	"dAEvCWzozpROemzqu8LcCb+1X/f3fjeKwre7d7b5O0yAJuDt9085C3+S8s19ecU1ms5f8IwQw3g0JUEqEqADtBALsTA6Q7ngcBCG3M64fRZuAgIYE3u94gAC",
+	"MhALrB4GwDoExiQsCAWCJwgYLiPwAd5G13vv+IXwNi8GOQb7iAyGM1sRDqwUyn/gBlG5df/7z/gApouzu//9zwsb4I6u+Vn/9t9kOWss3uvvvxyPAa4N/7zz",
+	"wlpUPcH35gsjLZuF/BoEiCVAkQcQnLgBztrKMvQ1GTKc8vQjzfs17ft4RjS/A4IIUg7A8MqDDgghSD2HhlQccAUQQFEExpdM8LZZt+sCQ0nmeF9ZN+jemm+e",
+	"DUAUYxcfvLw0ZtPnpoD3MXm7y9ghzKHggEQpJ7PPgo18N+B1q6+8doGMfBgTB7wQ5A5AYVl6QOE35wJRrnlBqC6G/FYAimgZjtWpziVqGfl+MR+ud//nzQEM",
+	"Ah+xvgJqY2rV9X14SBIBQgACeAJ4KqqYeYpZRrmABkFvIpmjIiMksgCFMuYsvhDhCofKDeyy3AZNHSYOcJNaXwIwgUgJz+Qc9oaUHnWAEdfE2xB4C+x+Tf/I",
+	"mXH11tbyvYR7CIa5PX72WbPwiCX5VVVV/4IfBCsfwQnFv8WELCKCoEJfzHh3P4ha6BI5oR0dKr4IfBD4IYyAAAABU0EDKbAD7zB2FAAIrd3dd8STP/oC/gIn",
+	"l95++CH/wkENVVf/l7vGwS0YqJ4Q9cYCa73e7v3vWO5f4LxA4QzHvfghzsEMIxI/eIsEDz48vhbiYqC2psWW1rxHGoIdk1XQIYS+9/o7eCFG7wQ+CFEKLOwU",
+	"xzxA4LgowEuPJ1CdnlRPdgPhoyYxzCd+u/3P8B7qwrsICXeArjJetxKekLZAB2PFNThI31QsFO1+mqvUGA0JBQFi5DaAwREWjdYas5tZoCAq6dl3iitcfv4o",
+	"AySFnTkQTJRUvGrKlav8eRklGCMnjTmRibZ9Q84X46WIibgNQkAbPNdCP5qvDFLv9z4llUfYqwbQ/6tEvKjggfGp4ARWXPlr6BKcq+9+S+wQcihYnW4YoPZK",
+	"PG+w/74a+zvAh949GbN62FUaNGg3B3h1ZqBHJHpLZ0r+f66+HhzWp5H46DP6wAAAA+9BAZJsAPvcEHghhsFGB0IyDMgqfhC2N4AT3k2JH9XvawjDmB0CGQdC",
+	"7XBLtrvACoZeyqirr1YRyl/GPEBIL8AzugP9xCBZI70gC5hrcX+Ce+7LScX/QKRDy3+tD9/01f2CPEnZ+/+xo4Jp+/zg1zZL42SFKQd4W5fVo66hRppr1/9o",
+	"CRqIDedieYP3qFOwYLit4H/5LOLI4PyX/vptpjhcOdyCh33iQH6sP+3xkae+BZsIACI95Q+DvMswYD7QnzueGpdkJT/a+dfwF4mNNQyHuDl92Vpw9GXP6H/2",
+	"EdVH95rbsD7zHssVSCG5ANly4DYS2w/6DnidegGNItksF7R3lXM9e4ngj2+15itszzv49y7/ATC8elN51uiB3hunP2Ay5fwi+tBAMR+qIbUP/bGQoy5tGB/v",
+	"EfOH8hkbe3j/jBmqcnPIAkM5rCVyKE/lHf4AWucnDW2wL+abIyFuuDsaQYJD2Ikp/gRVqgNN6veCtAl8E20/3DPKFmBCN/h355/jUJY+Kb8glOhNm311Mmu1",
+	"4t8wbtuEtCwyL3HWQi8gxKXmLhjX//nD4DqDU5f/2EbL//oFUEMNgmBoBMg+YAqb4Ga9/ACiozMNyrr3sIKAAhO7MxXd2ZiuwCIQVdvAhWS7V+AKLSAhWm2q",
+	"vleG0GoJhLEb6PY86ATEpMPUI6gF/3dy3/OWHOLvgCQCYLmgi+r0wT6+X5h08SID2hbQdi9BP/9zQ22u1T+t6AY2bhxH/JFuLVqd9v+pIJnKkANbwuOzqYDr",
+	"V6AbcYHQrQzz4b6CBtK93tpH/rELryJsqgLmEW/5Hf+kbUO6vAnCko3NapzCg7wjq8D//3qOPXoiDAc0uA29DR1ZzsruO7m77wPnUE1Vz7+/rs8Nz6mqwP2D",
+	"AhzVw/rIWl8I+JG9YQ4prZ6/88smi1VfWBy+VAoKVqHrcHp2uIHWGPyKmwbwPf+47S9uDBRvQMBAU15+eN9VAff6pi87pSjTx9kpji6OlGAcvgNd3I7rBx8x",
+	"x9kJ3Alur2yreC6MV3SKy6/S/UQc1h3gt6P3wm3LS42WYufpGIVusDwNwSP0C43FPKwPP6Z/fh/9+Kc4DWofYxbfB9x8MbXdnGBOmo/f1uA7/XVZnhy+Exle",
+	"cWt4Jcf/88O5+O4aBQGpql9Vm4Nqe7cegakb6K0KSCz0PoR4PUs3RCv+6fyMMlEPfwG88BvtZaf7ombtRn1L/zi9AOIvTpz8IDLPCoX1f+y7DUBTf0Rr/FaX",
+	"M6hR7XBVYJDPgQQrTjC363r+f4ExOZb3hdW/ZOGSJryv5X3x1zj11pWUNCF7AdPyKi/APs6Rn/sv/FwUxXFmfz8FMAAAAflBmyBTy8OYADzcZCk/Lt+2WgtC",
+	"Su4v7peHkrx4CV6i/jcbwh473GjBe3AlA147BwWwGJnmli0Ku9YyhZKLG3h6ekrbYKad/bdQHyrRo5zBsnUou7//JjyBkMuCuX/bwaYe1oQRpwahEfnebZAV",
+	"TzlCDINvgeOBgakisQ5Y+eTW2F0e/UCBD57oFvUzOP95WP1c4B1n/3ULcDern9W//234X/CMNHn83e+QFNtFC6c2+eQhPXMtKu89/wvpjX2XnvNCPYQhGtf/",
+	"KuEe5xoVNi54BKCryECjxPMagYSv7BFlUhBB+MVT6fSAACzBpYcAAswaWU0U0QAneWHATvLfDgJIALmkdhOZXboNZmQisUHPN2jQEf+AIXRN961/wAXE5saV",
+	"JB7oLG+AJf3ad8+iaqf86rfVWmcUn/X78hf/6LbS787+fh2P5XtPBjsioRWWFbKSuMNMCPHTQnzY/whAUP7cgJkjJ1qLbP4uByAHGQMkB8ja1mpwjrZxbMVs",
+	"H0yWmZAleU/ccVRhUuVYMAjFvz8x9mQcJSiwhP0XgVRCbxDAVaYe84NmbBCCU6SchQKh/5MU6OqQIfsIgmJVarV/BCCPe7+CEEZd3rMAf/8IglDABgkMAEQN",
+	"jz/zwCWBEd08/ABEbXa+ProFT6CC0JmNQQivghRK8EOdgnjIAAABakEDKbIBC82CEEQcFb3Z9CBVfBZWvm65UEm+iV8XXXlzynz/EwRwhzgiWEf2b+uCo1VW",
+	"97z4QGXxwQhHFSd34IRPd3f4ISiS5d4TYgPqY9/vf4R/yd3l800tQUCXfzw14IUZvBDt4MYREIE9cQCStdVl8VXGQRnVeGL4IfBD4IY/DwXFYAjuvgP5Vit0",
+	"//Dxf6ZXhr9Y/+JM2BMcHOnrBRMY0aJCdt6gCu/6/Sgb0KrpF6l+cNBbnabpmVBAQXtcnB/w6Qo3M+hwu0r10nX/k5Xbc9XZwAdEPptvgfh2Y8CqeTkbJH4r",
+	"IU3trz7fW4X4CR4yM9qIxkB/sQY/q7f9nOpX2g5EpXx9JlyxSWAmwrE8B+YqeB1/UdcAbBlgrvvnCgNVfUTS1lDmFuOff06XogiFbyj0Yxn1f3Qenz6AnX0c",
+	"32j/8nQFuYtBHuIT5NaMhtT9w84Vp97H+CXe7u7jUHwV3u7v7v3zEmysAAAD4EEBkmyAQvcEFAkNSdE7WCGeuP4/KjxI0L8AOgtZb9VeBbYvJPXZ/76gLWCV",
+	"aglfSq3YVkHFsS0Z+6Br+iToL/+SCK2bREEbrBKIYFXBD6VOGr55/GpdePTEEDuFFMAp6yiyZ6o4FKbceoEY6bA/68d8r4DY+p9M0YDubiTHy3qcYzDT8D7G",
+	"OPUh1n4sfEf/9WBizsNyMhlfXrq7RMSyqIzwl152d86tyaREf/4jSIwcvjYSbuHs6bWq//1cySmYFTt5qeDQQ6xQTTy18JPUsdwZPvINnsyXJp/zg/NyLDp4",
+	"78n9be5+A43lZ//SpeZmm4lv/XK+dn68EIPfymjVf/xL4M2CghGkHeRmwP6lHBgQAdbuAztiX9w7ZkrQmU3QH+sgauUg+nDV7mBcPTW6kBT1tb9PvDxr2WC2",
+	"9gQztsy9Pd53pGnwMy8SXtsDsQ895ZS7B0jzB7KZivwdfmiP/laBwZRmvjewcR7gP9keFH3csX7/yhtWP/rfFAFlR85Zzf4URFgF7SJ19zJ3CwnwC97Io7u/",
+	"0Gxc4YC8BrgKe6tG9///fBD9Dut4IMnMfi8v/5eLyvFMNQfTY0iDQOW/lFYN11+Z724NdjsLR/xbpG62eKQxf8sBkAFbVst9/wGgvfT+f8viSz4gYHtgWSMZ",
+	"on9N+cVLMH4mPNjmUTFapRcVn+U/Bw/NfwH/8+2daZ81yPjxU8qw+/HEq9w7yizA+JQMMv4xS6l3+gb9A0ml6ecFFXutuvPMhV1P+Xzlc0kO9EgMAYffof8N",
+	"gT3WiVb/8TO+uEfvdf7A/7jrJXrFSC6vpQcenjjToPlSENwFbSMtfCQcfXgMPDCX4FnB2AhX/I/qPMW9LuWnmbv////3BRbH3/s3+g5fefECA9ess0Bvhsf4",
+	"0oD6B/7sDbH6acOP8gfO3rEvs3HQGsuzveN534gznY8+I8iTHG7kDviNU8fXH+GdztFtNLu//XsQNPgGfoXnSe/JfEiZRaEMO+D6A3uPMAIbTagPvC/cehpr",
+	"dz/vnXWG/5WGW0csr4A4UaliVfnnkvxGea92p5TH77PQGhrbop+Dl8TrwyJDDBhYS99qxr3nWZ//88P51jthoFAlF8VzmRp8idpvZn1H3Xwc59Zjw/Y+C5ev",
+	"fGv7v+Xwc/wyVlNXHy8y3WlLf39r0W36tFL+ut/+zkw/pPn5f+hI+ZlRf74/8v4ovhqF2VTMz/9bpzspD2sggRnHdSP96ASFachdi9PBa/yyma+3f6DJoL0f",
+	"4sLb6rD/6RYAyb366edgD8N/R/5KQ1k90+7/xcFcYoEjn8/Hi+DAns/nfO+fz8KwAAACPkGbQFPM80b4ADTma7fx7UnZrUyNfGvaqw2ftbRIEt4c0r/IDA0q",
+	"ztLh4baf5hlTI8OwN7/9bJ0Vg1VCh2KWhoL0bUu6LLrPw3Vb/CKQgVSA4AUVWn7e9SQee5hHi/n0DAF8j/IelT74aqFvL0s8NwPSNOAweqKt7fe5bDpyEOD/",
+	"fXKrGv22JLL1nneEYcwYCVBKAlQBXwQErk4HJ9zgcAAoFTcwj/NA4TjwraAR4HERZfBiUsiE5xo78AF6X8FClY/N/himiMyLV74PTQ3RGFIXOg+bE6I45C5x",
+	"gTCKTABymQfItm2+B82JkRxiFztDipZ5xpiin+EmgYEixIvBGKXqEi7P+YYWr/ZdNxPT4P1BLrsUu/XldBuTAQJJNJ0+U6gKMU4/v/f7VMPok/+f/5n/jdx/",
+	"f5uF/BgCZBKAJkHEuJeASmzQuvRhuZGVV6E+xpk2N4W+b5vnn2qL7NViQeWe+ENrPfhDMX7BBIhgRDMKq5R2ZWfkULx000LNLBBDHFBlzDI9hAxUBlMPjTv9",
+	"6ZztfCCuICdCSQh0Q6nGJ6J7jC/4Q4bsCAYObIXJGY9cxK/Ds9eBi5PMAKYnzNG0mCDNGBFl4DVpGpfBvcLBEwRBHcV9ZfDARCAR8EJNxW2oIcN4AdpIDFa0",
+	"NtX8mWAML33++/AAKXbXy7vwQBGKfzC4KYxjHELsIfL/hEVhsFEAbjiDcVWr5RfgEzW67z/gBajGjdLX/XPl8LzQh0JbL4IAjDfYIum6QLBBhHOwQxsAAAGv",
+	"QQMptAPvK8IBH4ZD3DHl8CPWf9j/+jQjRB0tioRoh7QQ/BiEeCT/EwTx5fCH/QQ6BQdN5QgusvjAgUIbubIuvhssBBG7vWr64Zl3+GZd/YQwyUXieQkXwl/y",
+	"/uEP8EZuBrLny/BCEAj+whCAR8CTCIUQR/He//2PCIR5f8IX46GR0DKXPsfCDF0/3wjwiCHOw/HvDqC4KMNwYCCRnp/wBI9evyRlu+l9waKl3/aRNodcSxCe",
+	"DFS4PqKGgBN6qzC33uDQV+u1m/dWhShYuL9w2oQz+kWS+Xf34FPHeeL/9CWnJMgW9XGH41enqpfKTl8G+KX001HAcjbu/5fyBAEcKFD2H3u+DgRNp3VB9gf/",
+	"/GEaJwp3n1Ae+NtGlm+sbKpn+9oE3Hhhwa27cQC7fH6/wK2MaJapUaXwqEBEZcLeeeG+0P4NTcrmBXgIruu2RRD63dsDtVnBwuDwBGbX5ldfnmJr4/v9/TaO",
+	"ORkHMI//fQIAQBEIqJ04RBCGjcBCjZi1qHYClMO4D8ACXSTG9Rs6w8IghDF7vwEyJ29ahLQB+zAG3+kfPDwAHyUY2S9MtWAAAAO0QQGSbQD73BBlWCHKg/cL",
+	"gmwAiBf0xkK/6wxoEBiI+quoi+Pf/VpXxiT18vf/AocdezZfG/6BZzg6qL7iWEv5AfSdtG8h3jwTWyoxL4II6F00HcD5pgA8Un8aRn0b2B24Ex+QvyIFVPHD",
+	"yxmYnlcd4jG3odl89f+das+8po99tfQWyexHN2q7Lwi8jr/CQhMlR+Bboweyvmye+284q/PDgDaskHAbqncMnr7/wcvhFij1IHsV7AfnDPv0ovg4764NaJMB",
+	"Ah2iECL6NCYAmY5V+Uc2rR76iHdaAv+wfkD341Q0GQKFtuBGP4zPdgAMRUlK/jX2rueHQ/2uqu/7xZg76RYNeiI2BtIgBbLuJN6cqNvA3VoPLGyFN52iO8bL",
+	"wvY4+ohmnsb7ZiBujD/tuAsJmnaAhv//7//ldNIN8tev39YnbPN+///9lA2aE0Rf9YOw6QOED2R8DqsPX17A+ldiDBZGjuyDgx1Y/6jCg7B8PgOD1lgTe3nE",
+	"4k8ZNNYT8XeuZrFJr4mXufwCva9o7tS/LbF0cXVaaMP8+5f4j//4EChwqsv/wiHt7utQECN2atXPwRQFfgDO/VO/2rAAeFqjI369OrL+u8pf/5XgwKGjgq0K",
+	"+6QlN/mMioVNdZCt/4DumlRMb76tIAlu+klEX9si2ZRvzfxX/mzl9Ly+QoShNFCQeJonGynNnr/92JfL9Znz/2ZmzfsnH/qmb5IwPccf6BBnHQDV9gb9UVvO",
+	"kFEgZB++qob40KaRP/8Pz/sYBymk5U8XleAdd0ulfqX5WhJ0g71oSFokxD21gO0R9jezQ11znY/esye+D/1ejn/yoqSTQP+A/1cod1jPDvt7Q+HMuM4/30C0",
+	"Z6L/9/aDl/8gQD0df7l+GLg8AuvOJDUBcCXcb+jqoYu7A7XMDbqEHmPxgOPe6De/tFIsB1duB/AwyxTSu3uful2/AKqhz6y/799Q74QsD/ZbMN4eU7n04T1+",
+	"cNzDOCq1N/cMjv8f75bg7gMcdgfyUVeAaaXI3z5BakHCloI2PxvLXwVzEnTf9Ds3DI0VNAmqm72Ozn/+dB3OscX9/DQKAI25Qce/EMocZtoU3cknUNfYbd+D",
+	"x2Of2Lf/9/l//DJTNtcj+a/bWgL52Kf6WjnF++vi1Ot+ek/ICeS6r+9fT/3uGo2+VAD/APa9b47gS9TAwacb6Y5d+gLgLN30+u/DwCioqyPrv+GSN03D/DGN",
+	"18bhctG/4NjX7nF6AcRcID300wj8N9/4uCmMxZn8/BTAAAAB4UGbYFPNxvgAcWx37Vot+/sET4ONOSubwDbSfT9KSBACBEEBusIhiVqWgJinLpU6E73xrv/+",
+	"PApANJyS0QTaClhLUwNAYCO1V60IVdXKCRy/nIbS4Ah7Etn/npROeTN1XeFuBt/ar+f/7b+bsVhY3u3/BydpkATcHb7p5yFv5LyzX+cU1ms0I9hCEQS8Igk/",
+	"NzgrCAAJhiCwgJSkwAUqiUil//9yAADgA4FS8AM69//7/cgBDDZfnpl/brbL+J+FwUfADQTEmSqOD3+AC2zrQ2EH93aBoWPdlMFzTdsmOqHcaZBEkHaflrgO",
+	"7FY4Aan9oGaWP/poH8P7DZPgBC/L6z/eHD5smRkbU3kIDeF723a6L5JsRCGZYIAiHy4NI8qeAnkmdahWe+4CZJkHWrXCQV/WEzj+TgICeEAJDkCJkfgCExtM",
+	"eIcp/wGBlsSAfwgTC6QDwZlaaEvJ++eTR6y1hCHtwVUCBBeWeFlhYvnqCX5+u0DAgycfqc7z+vD8dZbe2wQDJo6XiAapqlwY0CgwIhfznfFGnPDL74fACEmf",
+	"r53gW6aNaHkUAZFpkcxK6YQyoOso9FOLlBCr+CHwQ8DROCV/hO/PiuCIEz2qRGGwTxjGN8EYKE34PBCiuKg58WyZR0AAAAEyQQMptgELy4If/QIh/+jQf+Gw",
+	"U8MvLhx9/+J4//QKMK4I9ax1F//zwUwj7UEJJAQbvwQ+CHCLBDPTwnh9HeP5A47f7FaqsEPghzsE8IYJguCrNEAc/8j2wCBlKPfunHBcKQqlfRFUByywyulg",
+	"a/afdYA1K3M7N9MoO7I93WyicLFxl19r/5kjrp4V1H/6wfS3UBsF38aZ3E+vUbMwcmusXE+jx3jHUel9r6anojxk6vl/h7QwLy5AKq/NdUP8d40T4rHbEMvy",
+	"SJrkAvLco3/OFs/0HD9MCuEwiyiDAIWd776QIuWd5EEScxFTdf+aXxIIg1HhMQCELc41wGz4R6gP/93S1Eu9OnlO9t1swdkuHELikAtoVxWFNTOPyi/zynne",
+	"8+z9mGufNH8/ghUdvBCjReCHAAAD/0EBkm2AQvawQZXghoFCZf+y/rsoX4BD0gZg//fQPOZGdFj4r6CnaSCmJT7vrCR7Cu0+pr7AbQRNq1kbfu2xSLdzadv9",
+	"8MZcCEtOeSZvR63gQ+55txI5fbMhQpQ7wNuwi26Xf7+D2K/jsWQIVMDemH+KqP8uLe8hu/uc3VYDsrCbBNzdPugJ/lEFX9VYANsrIR3xXgRRJT3/7gZzAgA7",
+	"i5RcSK2O2SD60UaOU/B7UAHHEzi53+vAEXToyMC77By+VRL0Hryfzjbpz9586fNjWd/KYedMDXFBxfermCX/L36BuJ4ErTeZ+by4ED+jDg4jplqD/59ichBW",
+	"YLyVq0P4KcvwkP0dlqwuhGS2k3+5JmIvb8A9IhT/ZG7UvjTDNuHfSYXZaGoAMGWz9+90caKz/9VkQcFgdIDUNC27BYUV65zjwMjTzhHZ9Mhn5njEIEAKaikf",
+	"dBQvXceDtXEg4UyaYTEe8BxYLuqeRWBy+PYwnOHqXcH2GZs35oYPf/78XW1Px3s3ucI6Sz6e8bCvcBv897oyC5eP/f0WAnfpY97CJtx2/4sloTngKiZt3Hvz",
+	"1BHhXlym+L6EgJPX+5K3///hjefK18ayZ7L//LBDVs7BTI85w0CYFiVHz6WI/6+VmbKzsKMfuAxk45Jf/80jvMzjQ+IC3Mx53o/8fm3L//y+5ZZB4eJQPvr5",
+	"LIuv9HpdwpH9/eUVvbaU7ryxJrcnNm+u/Ucd2G2JfYEDpQydG9AeBUzDdJ/Padhv1+2xLp4BmrHTWWrbcq7th/dtPAH0VpNJm7/3YcMHS4BFueHeHUFb1Xzy",
+	"/9Czx9aPfC+FZtUWt0ds36f0KDbujd3t49NnfqtsNR9yrVNWBf8TIjM2tDXnZqJ/D9B4CC1Xpf3exMUqzf1f/KQWFVzWR6ug5fKhCBG2w9nuf23/xAXb+j/7",
+	"bP+sC7w1+0B/svkXQG9/BbOA1/gEAnaw4bavZuKmgHs+vpt07Mv4Pzie2/Q/73b0/gODv5n7XtWcmn1//7RlNM6ba8DYPu6VP3Rf/8vvMJGqHeAl9fB2PiEq",
+	"vjdYPFXcz/6z6BQM268BoevDG9cH/+KFGT3hXTx50vzYI8GFz+i3+Fvwtnrvcd18xeZfycE/DeQ/BbYerrGfRf//7h8wZFh7uxI/Hnv0DUO0uKnF3n//zoO4",
+	"hY54ogaBQG45XOH9/63WsC7xUNu2hg/bLAc1Tzvwz8PIokz878M/YIWGoZtO7LvX+f4D0WL7e70oqysimvziqkE/x7/8waKU0RRmi+Kd8SN9oPXyuNqyOXRw",
+	"ff1BbCtOcZ+b8R4LUOPFsq+6v4pBkx5gKzBmBbbIEFr4tJFCAig/IJXnuba3/i4K4xQsz+fgpg=="
+].join("");
+function createM1StaticFmp4Fixture() {
+	return {
+		mimeType: M1_VIDEO_MIME,
+		codec: "avc1.42C01E",
+		width: 320,
+		height: 240,
+		duration: .4,
+		initSegment: decodeBase64(INIT_SEGMENT_BASE64),
+		mediaSegment: decodeBase64(MEDIA_SEGMENT_BASE64)
+	};
+}
+function decodeBase64(value) {
+	const binary = atob(value);
+	const bytes = new Uint8Array(binary.length);
+	for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+	return bytes.buffer;
+}
+//#endregion
+//#region src/latency/buffer-ranges.ts
+function normalizeBufferedRanges(input) {
+	if (isBufferedRangeArray(input)) return input.filter(isValidRange).map((range) => ({
+		start: range.start,
+		end: range.end
+	}));
+	const ranges = [];
+	for (let index = 0; index < input.length; index += 1) {
+		const range = {
+			start: input.start(index),
+			end: input.end(index)
+		};
+		if (isValidRange(range)) ranges.push(range);
+	}
+	return ranges;
+}
+function getBufferedStart(ranges) {
+	return ranges.length === 0 ? void 0 : ranges[0]?.start;
+}
+function getLiveEdge(ranges) {
+	return ranges[ranges.length - 1]?.end;
+}
+function getBufferedDuration(ranges) {
+	if (ranges.length === 0) return;
+	return ranges.reduce((total, range) => total + Math.max(0, range.end - range.start), 0);
+}
+function getForwardBuffer(ranges, currentTime) {
+	if (!Number.isFinite(currentTime)) return;
+	const liveEdge = getLiveEdge(ranges);
+	if (liveEdge === void 0) return;
+	return Math.max(0, liveEdge - currentTime);
+}
+function isValidRange(range) {
+	return Number.isFinite(range.start) && Number.isFinite(range.end) && range.end > range.start;
+}
+function isBufferedRangeArray(input) {
+	return Array.isArray(input);
+}
+//#endregion
+//#region src/latency/latency-controller.ts
+var LatencyController = class {
+	constructor(config) {
+		this.startupPlayRequested = false;
+		this.lastSeekRequestAtMs = Number.NEGATIVE_INFINITY;
+		this.latency = config.latency;
+		this.playback = config.playback;
+	}
+	evaluate(input) {
+		const metrics = this.computeMetrics(input);
+		const evaluation = { metrics };
+		if (metrics.currentTime !== void 0) {
+			const cleanupBefore = metrics.currentTime - this.latency.backwardBuffer;
+			if (cleanupBefore > 0) evaluation.cleanupBefore = cleanupBefore;
+		}
+		const forwardBuffer = metrics.forwardBuffer ?? metrics.bufferedDuration;
+		if (forwardBuffer !== void 0) {
+			if (!input.loaderPaused && forwardBuffer >= this.latency.maxForwardBuffer) evaluation.loaderCommand = "pause";
+			else if (input.loaderPaused && forwardBuffer <= this.latency.target) evaluation.loaderCommand = "resume";
+		}
+		evaluation.playbackControl = this.evaluatePlaybackControl(input, metrics);
+		return evaluation;
+	}
+	recordPlaybackControlResult(result) {
+		if (this.pendingPlaybackControl === result.type) this.pendingPlaybackControl = void 0;
+	}
+	reset() {
+		this.startupPlayRequested = false;
+		this.pendingPlaybackControl = void 0;
+		this.lastSeekRequestAtMs = Number.NEGATIVE_INFINITY;
+	}
+	computeMetrics(input) {
+		const bufferedStart = getBufferedStart(input.ranges);
+		const bufferedEnd = getLiveEdge(input.ranges);
+		const bufferedDuration = getBufferedDuration(input.ranges);
+		const videoState = input.videoState;
+		const metrics = {
+			bufferedStart,
+			bufferedEnd,
+			bufferedDuration
+		};
+		if (videoState === void 0) return metrics;
+		const forwardBuffer = getForwardBuffer(input.ranges, videoState.currentTime);
+		metrics.currentTime = videoState.currentTime;
+		metrics.forwardBuffer = forwardBuffer;
+		metrics.playbackRate = videoState.playbackRate;
+		metrics.readyState = videoState.readyState;
+		metrics.droppedFrames = videoState.droppedFrames;
+		metrics.liveLatency = forwardBuffer;
+		return metrics;
+	}
+	evaluatePlaybackControl(input, metrics) {
+		if (this.pendingPlaybackControl !== void 0) return;
+		if (!this.startupPlayRequested && this.playback.autoPlay && metrics.bufferedDuration !== void 0 && metrics.bufferedDuration >= this.latency.startupBuffer) {
+			this.startupPlayRequested = true;
+			this.pendingPlaybackControl = "play";
+			return {
+				type: "play",
+				reason: "startup-buffer-ready"
+			};
+		}
+		if (input.videoState === void 0 || metrics.liveLatency === void 0 || metrics.bufferedEnd === void 0) return;
+		if (metrics.liveLatency > this.latency.max) {
+			const seekTarget = Math.max(metrics.bufferedStart ?? 0, metrics.bufferedEnd - this.latency.target);
+			if (input.nowMs - this.lastSeekRequestAtMs >= SEEK_COOLDOWN_MS && Math.abs(seekTarget - input.videoState.currentTime) >= SEEK_MIN_DELTA_SECONDS) {
+				this.lastSeekRequestAtMs = input.nowMs;
+				this.pendingPlaybackControl = "seek";
+				return {
+					type: "seek",
+					targetTime: seekTarget,
+					reason: "latency-max-exceeded"
+				};
+			}
+			return;
+		}
+		if (metrics.liveLatency > this.latency.target + PLAYBACK_RATE_CHASE_THRESHOLD_SECONDS) {
+			if (Math.abs(input.videoState.playbackRate - PLAYBACK_RATE_CHASE) >= PLAYBACK_RATE_EPSILON) {
+				this.pendingPlaybackControl = "set-playback-rate";
+				return {
+					type: "set-playback-rate",
+					playbackRate: PLAYBACK_RATE_CHASE,
+					reason: "latency-above-target"
+				};
+			}
+		} else if (input.videoState.playbackRate !== 1 && metrics.liveLatency <= this.latency.target + PLAYBACK_RATE_RESTORE_THRESHOLD_SECONDS) {
+			this.pendingPlaybackControl = "set-playback-rate";
+			return {
+				type: "set-playback-rate",
+				playbackRate: 1,
+				reason: "latency-near-target"
+			};
+		}
+	}
+};
+const PLAYBACK_RATE_CHASE = 1.05;
+const PLAYBACK_RATE_EPSILON = .005;
+const PLAYBACK_RATE_CHASE_THRESHOLD_SECONDS = .25;
+const PLAYBACK_RATE_RESTORE_THRESHOLD_SECONDS = .1;
+const SEEK_COOLDOWN_MS = 1e3;
+const SEEK_MIN_DELTA_SECONDS = .1;
+//#endregion
+//#region src/loader/retry-policy.ts
+function createRetryPolicy(input) {
+	return {
+		maxAttempts: clampInteger(input?.maxAttempts, 1),
+		backoffMs: clampInteger(input?.backoffMs, 0)
+	};
+}
+function getRetryDelayMs(policy, attempt) {
+	if (policy.backoffMs === 0) return 0;
+	return policy.backoffMs * Math.max(1, attempt);
+}
+function clampInteger(value, minimum) {
+	if (value === void 0 || !Number.isFinite(value)) return minimum;
+	return Math.max(minimum, Math.trunc(value));
+}
+//#endregion
+//#region src/loader/http-flv-loader.ts
+var HttpFlvLoaderError = class extends Error {
+	constructor(code, message, status) {
+		super(message);
+		this.name = "HttpFlvLoaderError";
+		this.code = code;
+		this.status = status;
+	}
+};
+var HttpFlvLoader = class {
+	constructor(config) {
+		this.retry = createRetryPolicy(void 0);
+		this.state = "idle";
+		this.pausedState = false;
+		this.resumeWaiters = [];
+		this.mutableStats = {
+			bytesReceived: 0,
+			currentNetworkSpeed: 0
+		};
+		this.url = config.url;
+		this.headers = config.network.headers;
+		this.credentials = config.network.credentials;
+		this.retry = createRetryPolicy(config.network.retry);
+		this.fetchImpl = config.fetch ?? globalThis.fetch.bind(globalThis);
+		this.now = config.now ?? (() => performance.now());
+		this.sleep = config.sleep ?? wait;
+	}
+	get closed() {
+		return this.state === "closed";
+	}
+	get paused() {
+		return this.pausedState;
+	}
+	get stats() {
+		return { ...this.mutableStats };
+	}
+	async open() {
+		if (this.state !== "idle") throw new HttpFlvLoaderError("RIVMUX_LOADER_INVALID_STATE", "HTTP Fetch loader can only be opened once.");
+		this.state = "opening";
+		this.mutableStats.startedAtMs = this.now();
+		for (let attempt = 1; attempt <= this.retry.maxAttempts; attempt += 1) {
+			this.abortController = new AbortController();
+			try {
+				await this.openAttempt();
+				return;
+			} catch (cause) {
+				if (this.closed || isAbortLikeError(cause) || attempt >= this.retry.maxAttempts) throw cause;
+				await this.sleep(getRetryDelayMs(this.retry, attempt), this.abortController.signal);
+			}
+		}
+	}
+	async read() {
+		await this.waitUntilResumed();
+		if (this.closed) return null;
+		const reader = this.reader;
+		if (reader === void 0) {
+			if (this.closed) return null;
+			throw new HttpFlvLoaderError("RIVMUX_LOADER_NOT_OPEN", "HTTP Fetch loader must be opened before read().");
+		}
+		const result = await reader.read();
+		if (result.done) {
+			releaseReader(reader);
+			if (this.reader === reader) this.reader = void 0;
+			return null;
+		}
+		const bytes = result.value;
+		const receivedAtMs = this.now();
+		const previousChunkAtMs = this.mutableStats.lastChunkAtMs ?? this.mutableStats.startedAtMs ?? receivedAtMs;
+		const elapsedSeconds = Math.max((receivedAtMs - previousChunkAtMs) / 1e3, 0);
+		this.mutableStats.bytesReceived += bytes.byteLength;
+		this.mutableStats.currentNetworkSpeed = elapsedSeconds === 0 ? bytes.byteLength : bytes.byteLength / elapsedSeconds;
+		this.mutableStats.lastChunkAtMs = receivedAtMs;
+		return {
+			bytes,
+			receivedAtMs
+		};
+	}
+	pause() {
+		if (this.closed) return;
+		this.pausedState = true;
+	}
+	resume() {
+		if (!this.pausedState) return;
+		this.pausedState = false;
+		this.resolveResumeWaiters();
+	}
+	async close() {
+		if (this.closed) return;
+		this.state = "closed";
+		this.pausedState = false;
+		this.resolveResumeWaiters();
+		this.abortController?.abort();
+		const reader = this.reader;
+		this.reader = void 0;
+		if (reader === void 0) return;
+		try {
+			await reader.cancel();
+		} catch {} finally {
+			releaseReader(reader);
+		}
+	}
+	async openAttempt() {
+		const abortController = this.abortController;
+		if (abortController === void 0) throw new HttpFlvLoaderError("RIVMUX_LOADER_INVALID_STATE", "HTTP Fetch loader abort controller is missing.");
+		const response = await this.fetchImpl(this.url, {
+			method: "GET",
+			headers: createHeaders(this.headers),
+			credentials: this.credentials,
+			signal: abortController.signal
+		});
+		if (this.closed) {
+			await response.body?.cancel();
+			return;
+		}
+		if (!response.ok) {
+			await response.body?.cancel();
+			throw new HttpFlvLoaderError("RIVMUX_HTTP_STATUS", `HTTP Fetch loader received status ${response.status} ${response.statusText}.`, response.status);
+		}
+		if (response.body === null) throw new HttpFlvLoaderError("RIVMUX_HTTP_BODY_UNAVAILABLE", "HTTP Fetch loader response body is unavailable.");
+		const contentLength = response.headers.get("Content-Length");
+		if (contentLength !== null) {
+			const parsedContentLength = Number.parseInt(contentLength, 10);
+			if (Number.isFinite(parsedContentLength) && parsedContentLength >= 0) this.mutableStats.contentLength = parsedContentLength;
+		}
+		this.reader = response.body.getReader();
+		this.state = "open";
+	}
+	waitUntilResumed() {
+		if (!this.pausedState || this.closed) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.resumeWaiters.push(resolve);
+		});
+	}
+	resolveResumeWaiters() {
+		const waiters = this.resumeWaiters;
+		this.resumeWaiters = [];
+		for (const resolve of waiters) resolve();
+	}
+};
+function isAbortLikeError(cause) {
+	return cause instanceof DOMException && cause.name === "AbortError";
+}
+function createHeaders(headers) {
+	const result = new Headers();
+	for (const [key, value] of Object.entries(headers)) result.append(key, value);
+	return result;
+}
+function releaseReader(reader) {
+	try {
+		reader.releaseLock();
+	} catch {}
+}
+function wait(ms, signal) {
+	if (ms <= 0) return Promise.resolve();
+	if (signal.aborted) return Promise.reject(createAbortError());
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+		};
+		const onAbort = () => {
+			cleanup();
+			reject(createAbortError());
+		};
+		const timer = setTimeout(() => {
+			cleanup();
+			resolve();
+		}, ms);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function createAbortError() {
+	return new DOMException("HTTP Fetch loader was aborted.", "AbortError");
+}
+//#endregion
+//#region src/mse/mime.ts
+const M1_VIDEO_MIME$1 = "video/mp4; codecs=\"avc1.42C01E\"";
+function createMp4VideoMime(codec) {
+	return `video/mp4; codecs="${codec}"`;
+}
+function createMp4AudioMime(codec) {
+	return `audio/mp4; codecs="${codec}"`;
+}
+function isMseSupported(mimeType) {
+	return typeof MediaSource !== "undefined" && typeof MediaSource.isTypeSupported === "function" && MediaSource.isTypeSupported(mimeType);
+}
+function assertMseSupport(mimeType) {
+	if (typeof MediaSource === "undefined") throw new Error("MediaSource is not available in this worker.");
+	if (MediaSource.canConstructInDedicatedWorker !== true) throw new Error("MediaSource cannot be constructed in this dedicated worker.");
+	if (!isMseSupported(mimeType)) throw new Error(`MSE does not support ${mimeType}.`);
+}
+//#endregion
+//#region src/mse/source-buffer-queue.ts
+var SourceBufferQueue = class {
+	constructor(sourceBuffer) {
+		this.queue = [];
+		this.activeAppendBytes = 0;
+		this.destroyed = false;
+		this.sourceBuffer = sourceBuffer;
+	}
+	get length() {
+		return this.queue.length + (this.sourceBuffer.updating ? 1 : 0);
+	}
+	get queuedBytes() {
+		return this.activeAppendBytes + this.queue.reduce((total, operation) => total + (operation.type === "append" ? operation.data.byteLength : 0), 0);
+	}
+	get updating() {
+		return this.sourceBuffer.updating;
+	}
+	get bufferedRanges() {
+		return normalizeBufferedRanges(this.sourceBuffer.buffered);
+	}
+	get bufferedStart() {
+		return getBufferedStart(this.bufferedRanges);
+	}
+	get bufferedEnd() {
+		return getLiveEdge(this.bufferedRanges);
+	}
+	get bufferedDuration() {
+		return getBufferedDuration(this.bufferedRanges);
+	}
+	append(data) {
+		if (this.destroyed) return Promise.reject(/* @__PURE__ */ new Error("SourceBufferQueue has been destroyed."));
+		this.queue.push({
+			type: "append",
+			data
+		});
+		this.pendingDrain ??= this.drain();
+		return this.pendingDrain;
+	}
+	cleanupBefore(cutoff) {
+		if (this.destroyed) return Promise.reject(/* @__PURE__ */ new Error("SourceBufferQueue has been destroyed."));
+		const removals = this.createCleanupOperations(cutoff);
+		if (removals.length === 0) return this.pendingDrain ?? Promise.resolve();
+		this.queue.unshift(...removals);
+		this.pendingDrain ??= this.drain();
+		return this.pendingDrain;
+	}
+	reset() {
+		this.queue.length = 0;
+		this.activeAppendBytes = 0;
+	}
+	destroy() {
+		this.destroyed = true;
+		this.reset();
+	}
+	async drain() {
+		try {
+			while (this.queue.length > 0 && !this.destroyed) {
+				await this.waitForIdle();
+				this.activeAppendBytes = 0;
+				const operation = this.queue.shift();
+				if (operation?.type === "append") {
+					this.activeAppendBytes = operation.data.byteLength;
+					try {
+						this.sourceBuffer.appendBuffer(operation.data);
+					} catch (cause) {
+						this.activeAppendBytes = 0;
+						throw cause;
+					}
+				} else if (operation?.type === "remove") this.sourceBuffer.remove(operation.start, operation.end);
+			}
+			await this.waitForIdle();
+			this.activeAppendBytes = 0;
+		} finally {
+			if (this.queue.length === 0 && !this.sourceBuffer.updating) this.activeAppendBytes = 0;
+			this.pendingDrain = void 0;
+		}
+	}
+	createCleanupOperations(cutoff) {
+		if (!Number.isFinite(cutoff) || cutoff <= 0) return [];
+		return this.bufferedRanges.map((range) => ({
+			type: "remove",
+			start: range.start,
+			end: Math.min(range.end, cutoff)
+		})).filter((operation) => operation.end > operation.start);
+	}
+	waitForIdle() {
+		if (!this.sourceBuffer.updating) return Promise.resolve();
+		return new Promise((resolve, reject) => {
+			const cleanup = () => {
+				this.sourceBuffer.removeEventListener("updateend", onUpdateEnd);
+				this.sourceBuffer.removeEventListener("error", onError);
+				this.sourceBuffer.removeEventListener("abort", onAbort);
+			};
+			const onUpdateEnd = () => {
+				cleanup();
+				resolve();
+			};
+			const onError = () => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("SourceBuffer append failed."));
+			};
+			const onAbort = () => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("SourceBuffer append was aborted."));
+			};
+			this.sourceBuffer.addEventListener("updateend", onUpdateEnd, { once: true });
+			this.sourceBuffer.addEventListener("error", onError, { once: true });
+			this.sourceBuffer.addEventListener("abort", onAbort, { once: true });
+		});
+	}
+};
+//#endregion
+//#region src/mse/mse-controller.ts
+var MseController = class {
+	constructor() {
+		this.sourceBuffers = /* @__PURE__ */ new Map();
+		this.queues = /* @__PURE__ */ new Map();
+		this.lastCleanupBefore = 0;
+	}
+	get appendQueueLength() {
+		return Array.from(this.queues.values()).reduce((total, queue) => total + queue.length, 0);
+	}
+	get appendQueueBytes() {
+		return Array.from(this.queues.values()).reduce((total, queue) => total + queue.queuedBytes, 0);
+	}
+	get sourceBufferUpdating() {
+		return Array.from(this.queues.values()).some((queue) => queue.updating);
+	}
+	get sourceBufferCount() {
+		return this.sourceBuffers.size;
+	}
+	get bufferedStart() {
+		return this.primaryQueue?.bufferedStart;
+	}
+	get bufferedEnd() {
+		return this.primaryQueue?.bufferedEnd;
+	}
+	get bufferedDuration() {
+		return this.primaryQueue?.bufferedDuration;
+	}
+	get bufferedRanges() {
+		return this.primaryQueue?.bufferedRanges ?? [];
+	}
+	get bufferedRangeCount() {
+		return Array.from(this.queues.values()).reduce((total, queue) => total + queue.bufferedRanges.length, 0);
+	}
+	async createMediaSourceHandle() {
+		assertMseSupport(M1_VIDEO_MIME$1);
+		const mediaSource = new MediaSource();
+		this.mediaSource = mediaSource;
+		const handle = mediaSource.handle;
+		if (handle === void 0) throw new Error("MediaSourceHandle is not available.");
+		return handle;
+	}
+	async appendFixture(fixture) {
+		const mediaSource = this.mediaSource;
+		if (mediaSource === void 0) throw new Error("MediaSource has not been created.");
+		await waitForSourceOpen(mediaSource);
+		const queue = this.ensureQueue("video", fixture.mimeType);
+		await queue.append(fixture.initSegment);
+		await queue.append(fixture.mediaSegment);
+		mediaSource.duration = fixture.duration;
+	}
+	async appendInitSegment(segment) {
+		const mediaSource = this.requireMediaSource();
+		const mimeType = createMp4Mime(segment.track, segment.codec);
+		assertMseSupport(mimeType);
+		await waitForSourceOpen(mediaSource);
+		await this.ensureQueue(segment.track, mimeType).append(toAppendBuffer(segment.bytes));
+	}
+	async appendMediaSegment(segment) {
+		const queue = this.queues.get(segment.track) ?? this.queues.get("muxed");
+		if (queue === void 0) throw new Error(`Cannot append ${segment.track} media segment before init segment.`);
+		await queue.append(toAppendBuffer(segment.bytes));
+		const mediaSource = this.requireMediaSource();
+		const duration = segment.dtsEndMs / 1e3;
+		if (Number.isFinite(duration) && duration > 0 && mediaSource.readyState === "open") mediaSource.duration = Math.max(mediaSource.duration, duration);
+	}
+	async cleanupBefore(cutoff) {
+		if (!Number.isFinite(cutoff) || cutoff <= 0 || cutoff <= this.lastCleanupBefore + CLEANUP_STEP_SECONDS) return;
+		this.lastCleanupBefore = cutoff;
+		await Promise.all(Array.from(this.queues.values(), (queue) => queue.cleanupBefore(cutoff)));
+	}
+	reset() {
+		for (const queue of this.queues.values()) queue.reset();
+		this.lastCleanupBefore = 0;
+	}
+	destroy() {
+		for (const queue of this.queues.values()) queue.destroy();
+		this.queues.clear();
+		if (this.mediaSource !== void 0) for (const sourceBuffer of this.sourceBuffers.values()) try {
+			this.mediaSource.removeSourceBuffer(sourceBuffer);
+		} catch {}
+		this.sourceBuffers.clear();
+		this.mediaSource = void 0;
+	}
+	get primaryQueue() {
+		return this.queues.get("video") ?? this.queues.get("muxed") ?? this.queues.get("audio");
+	}
+	requireMediaSource() {
+		if (this.mediaSource === void 0) throw new Error("MediaSource has not been created.");
+		return this.mediaSource;
+	}
+	ensureQueue(track, mimeType) {
+		const existing = this.queues.get(track);
+		if (existing !== void 0) return existing;
+		const sourceBuffer = this.requireMediaSource().addSourceBuffer(mimeType);
+		const queue = new SourceBufferQueue(sourceBuffer);
+		this.sourceBuffers.set(track, sourceBuffer);
+		this.queues.set(track, queue);
+		return queue;
+	}
+};
+function waitForSourceOpen(mediaSource) {
+	if (mediaSource.readyState === "open") return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			mediaSource.removeEventListener("sourceopen", onOpen);
+			mediaSource.removeEventListener("sourceclose", onClose);
+			mediaSource.removeEventListener("error", onError);
+		};
+		const onOpen = () => {
+			cleanup();
+			resolve();
+		};
+		const onClose = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error("MediaSource closed before sourceopen."));
+		};
+		const onError = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error("MediaSource failed before sourceopen."));
+		};
+		mediaSource.addEventListener("sourceopen", onOpen, { once: true });
+		mediaSource.addEventListener("sourceclose", onClose, { once: true });
+		mediaSource.addEventListener("error", onError, { once: true });
+	});
+}
+function toAppendBuffer(bytes) {
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy.buffer;
+}
+function createMp4Mime(track, codec) {
+	return track === "audio" ? createMp4AudioMime(codec) : createMp4VideoMime(codec);
+}
+const CLEANUP_STEP_SECONDS = .25;
+//#endregion
+//#region src/wasm/rivmux-transmux-wasm.ts
+var WasmTransmuxCoreHost = class {
+	constructor(Core) {
+		this.core = new Core();
+	}
+	pushChunk(chunk) {
+		return normalizeCoreEvents(this.core.pushChunk(chunk));
+	}
+	flush() {
+		return normalizeCoreEvents(this.core.flush());
+	}
+	reset() {
+		this.core.reset();
+	}
+	destroy() {
+		this.core.destroy();
+	}
+};
+function normalizeCoreEvents(value) {
+	if (!Array.isArray(value)) throw new TypeError("Transmux core returned a non-array event payload.");
+	return value.map((event) => normalizeCoreEvent(event));
+}
+function coreMediaInfoToPlayerMediaInfo(mediaInfo) {
+	const result = { container: mediaInfo.container };
+	if (mediaInfo.videoCodec !== void 0) result.videoCodec = mediaInfo.videoCodec;
+	if (mediaInfo.audioCodec !== void 0) result.audioCodec = mediaInfo.audioCodec;
+	if (mediaInfo.width !== void 0) result.width = mediaInfo.width;
+	if (mediaInfo.height !== void 0) result.height = mediaInfo.height;
+	if (mediaInfo.audioSampleRate !== void 0) result.audioSampleRate = mediaInfo.audioSampleRate;
+	if (mediaInfo.audioChannelCount !== void 0) result.audioChannelCount = mediaInfo.audioChannelCount;
+	return result;
+}
+function coreErrorToPlayerError(error) {
+	return {
+		kind: coreErrorKind(error.code),
+		code: `RIVMUX_CORE_${coreErrorCodeLabel(error.code)}`,
+		message: error.message,
+		terminal: true
+	};
+}
+function coreWarningToPlayerWarning(warning) {
+	return {
+		code: warning.code,
+		message: warning.message
+	};
+}
+function normalizeCoreEvent(value) {
+	if (!isRecord$1(value) || typeof value.type !== "string") throw new TypeError("Transmux core event is missing a string type.");
+	const data = value.data;
+	switch (value.type) {
+		case "probeResult": return {
+			type: "probeResult",
+			data: normalizeProbeResult(data)
+		};
+		case "mediaInfo": return {
+			type: "mediaInfo",
+			data: normalizeMediaInfo(data)
+		};
+		case "initSegment": return {
+			type: "initSegment",
+			data: normalizeInitSegment(data)
+		};
+		case "mediaSegment": return {
+			type: "mediaSegment",
+			data: normalizeMediaSegment(data)
+		};
+		case "videoConfig":
+		case "audioConfig":
+		case "videoSample":
+		case "audioSample":
+		case "metadata":
+		case "discontinuity": return {
+			type: value.type,
+			data
+		};
+		case "warning": return {
+			type: "warning",
+			data: normalizeWarning(data)
+		};
+		case "fatalError": return {
+			type: "fatalError",
+			data: normalizeError(data)
+		};
+		default: throw new TypeError(`Unsupported transmux core event type: ${value.type}.`);
+	}
+}
+function normalizeInitSegment(value) {
+	if (!isRecord$1(value)) throw new TypeError("Transmux core initSegment event payload must be an object.");
+	return {
+		track: normalizeTrackKind(value.track),
+		codec: normalizeRequiredPrimitive(value.codec, "string", "initSegment codec"),
+		timescale: normalizeRequiredPrimitive(value.timescale, "number", "initSegment timescale"),
+		bytes: normalizeBytes(value.bytes, "initSegment bytes")
+	};
+}
+function normalizeMediaSegment(value) {
+	if (!isRecord$1(value)) throw new TypeError("Transmux core mediaSegment event payload must be an object.");
+	return {
+		track: normalizeTrackKind(value.track),
+		dtsStartMs: normalizeRequiredPrimitive(value.dtsStartMs, "number", "mediaSegment dtsStartMs"),
+		dtsEndMs: normalizeRequiredPrimitive(value.dtsEndMs, "number", "mediaSegment dtsEndMs"),
+		keyframe: normalizeRequiredPrimitive(value.keyframe, "boolean", "mediaSegment keyframe"),
+		bytes: normalizeBytes(value.bytes, "mediaSegment bytes")
+	};
+}
+function normalizeProbeResult(value) {
+	if (!isRecord$1(value) || value.container !== "flv" && value.container !== "mpegTs") throw new TypeError("Transmux core probe result has an unsupported container.");
+	const result = { container: value.container };
+	const video = normalizeOptionalString(value.video, [
+		"avc",
+		"hevc",
+		"av1"
+	]);
+	const audio = normalizeOptionalString(value.audio, [
+		"aac",
+		"mp3",
+		"ac3",
+		"eac3",
+		"opus"
+	]);
+	if (video !== void 0) result.video = video;
+	if (audio !== void 0) result.audio = audio;
+	return result;
+}
+function normalizeMediaInfo(value) {
+	if (!isRecord$1(value)) throw new TypeError("Transmux core mediaInfo event payload must be an object.");
+	const result = { ...normalizeProbeResult(value) };
+	const videoCodec = normalizeOptionalPrimitive(value.videoCodec, "string");
+	const audioCodec = normalizeOptionalPrimitive(value.audioCodec, "string");
+	const width = normalizeOptionalPrimitive(value.width, "number");
+	const height = normalizeOptionalPrimitive(value.height, "number");
+	const audioSampleRate = normalizeOptionalPrimitive(value.audioSampleRate, "number");
+	const audioChannelCount = normalizeOptionalPrimitive(value.audioChannelCount, "number");
+	if (videoCodec !== void 0) result.videoCodec = videoCodec;
+	if (audioCodec !== void 0) result.audioCodec = audioCodec;
+	if (width !== void 0) result.width = width;
+	if (height !== void 0) result.height = height;
+	if (audioSampleRate !== void 0) result.audioSampleRate = audioSampleRate;
+	if (audioChannelCount !== void 0) result.audioChannelCount = audioChannelCount;
+	return result;
+}
+function normalizeWarning(value) {
+	if (!isRecord$1(value) || typeof value.code !== "string" || typeof value.message !== "string") throw new TypeError("Transmux core warning payload must include code and message.");
+	return {
+		code: value.code,
+		message: value.message
+	};
+}
+function normalizeError(value) {
+	if (!isRecord$1(value) || typeof value.code !== "string" || typeof value.message !== "string") throw new TypeError("Transmux core error payload must include code and message.");
+	return {
+		code: normalizeCoreErrorCode(value.code),
+		message: value.message
+	};
+}
+function normalizeCoreErrorCode(code) {
+	if (![
+		"unsupportedContainer",
+		"unsupportedVideoCodec",
+		"unsupportedAudioCodec",
+		"invalidContainerData",
+		"invalidCodecConfig",
+		"invalidTimestamp",
+		"muxerError",
+		"internalError"
+	].includes(code)) throw new TypeError(`Unsupported transmux core error code: ${code}.`);
+	return code;
+}
+function coreErrorKind(code) {
+	switch (code) {
+		case "unsupportedContainer":
+		case "unsupportedVideoCodec":
+		case "unsupportedAudioCodec": return "unsupported";
+		case "invalidContainerData": return "demux";
+		case "invalidCodecConfig": return "codec";
+		case "invalidTimestamp": return "demux";
+		case "muxerError": return "mux";
+		case "internalError": return "runtime";
+	}
+}
+function coreErrorCodeLabel(code) {
+	return code.replace(/[A-Z]/g, (letter) => `_${letter}`).toUpperCase();
+}
+function normalizeOptionalString(value, allowed) {
+	if (value === void 0 || value === null) return;
+	if (typeof value === "string" && allowed.includes(value)) return value;
+	throw new TypeError(`Unexpected transmux core enum value: ${String(value)}.`);
+}
+function normalizeOptionalPrimitive(value, expectedType) {
+	if (value === void 0 || value === null) return;
+	if (typeof value === expectedType) return value;
+	throw new TypeError(`Expected optional ${expectedType}, received ${typeof value}.`);
+}
+function normalizeRequiredPrimitive(value, expectedType, field) {
+	if (typeof value !== expectedType) throw new TypeError(`Expected ${field} to be ${expectedType}, received ${typeof value}.`);
+	return value;
+}
+function normalizeTrackKind(value) {
+	if (value === "video" || value === "audio" || value === "muxed") return value;
+	throw new TypeError(`Unsupported transmux core track kind: ${String(value)}.`);
+}
+function normalizeBytes(value, field) {
+	if (value instanceof Uint8Array) return value;
+	if (Array.isArray(value) && value.every((entry) => Number.isInteger(entry) && entry >= 0 && entry <= 255)) return new Uint8Array(value);
+	throw new TypeError(`Expected ${field} to be Uint8Array-compatible bytes.`);
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region \0wasm-helpers.js
+function instantiate(source, imports, stream) {
+	const instantiate = WebAssembly[stream ? "instantiateStreaming" : "instantiate"];
+	return instantiate(source, imports).then(({ instance }) => instance);
+}
+function loadWasmModule(sync, fileUrl, src, imports) {
+	let buf = null;
+	if (fileUrl) return instantiate(fetch(fileUrl), imports, true);
+	const raw = globalThis.atob(src);
+	const len = raw.length;
+	buf = new Uint8Array(new ArrayBuffer(len));
+	for (let i = 0; i < len; i++) buf[i] = raw.charCodeAt(i);
+	if (sync) {
+		const mod = new WebAssembly.Module(buf);
+		return new WebAssembly.Instance(mod, imports);
+	} else return instantiate(buf, imports);
+}
+//#endregion
+//#region ../../crates/transmux-core/dist/rivmux_transmux_core_bg.js
+var TransmuxCore = class {
+	__destroy_into_raw() {
+		const ptr = this.__wbg_ptr;
+		this.__wbg_ptr = 0;
+		TransmuxCoreFinalization.unregister(this);
+		return ptr;
+	}
+	free() {
+		const ptr = this.__destroy_into_raw();
+		wasm.__wbg_transmuxcore_free(ptr, 0);
+	}
+	destroy() {
+		wasm.transmuxcore_destroy(this.__wbg_ptr);
+	}
+	/**
+	* @returns {any}
+	*/
+	flush() {
+		try {
+			const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+			wasm.transmuxcore_flush(retptr, this.__wbg_ptr);
+			var r0 = getDataViewMemory0().getInt32(retptr + 0, true);
+			var r1 = getDataViewMemory0().getInt32(retptr + 4, true);
+			if (getDataViewMemory0().getInt32(retptr + 8, true)) throw takeObject(r1);
+			return takeObject(r0);
+		} finally {
+			wasm.__wbindgen_add_to_stack_pointer(16);
+		}
+	}
+	constructor() {
+		const ret = wasm.transmuxcore_new();
+		this.__wbg_ptr = ret;
+		TransmuxCoreFinalization.register(this, this.__wbg_ptr, this);
+		return this;
+	}
+	/**
+	* @param {Uint8Array} data
+	* @returns {any}
+	*/
+	pushChunk(data) {
+		try {
+			const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+			const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+			const len0 = WASM_VECTOR_LEN;
+			wasm.transmuxcore_pushChunk(retptr, this.__wbg_ptr, ptr0, len0);
+			var r0 = getDataViewMemory0().getInt32(retptr + 0, true);
+			var r1 = getDataViewMemory0().getInt32(retptr + 4, true);
+			if (getDataViewMemory0().getInt32(retptr + 8, true)) throw takeObject(r1);
+			return takeObject(r0);
+		} finally {
+			wasm.__wbindgen_add_to_stack_pointer(16);
+		}
+	}
+	reset() {
+		wasm.transmuxcore_reset(this.__wbg_ptr);
+	}
+};
+if (Symbol.dispose) TransmuxCore.prototype[Symbol.dispose] = TransmuxCore.prototype.free;
+function __wbg_Error_fdd633d4bb5dd76a(arg0, arg1) {
+	return addHeapObject(Error(getStringFromWasm0(arg0, arg1)));
+}
+function __wbg_String_8564e559799eccda(arg0, arg1) {
+	const ptr1 = passStringToWasm0(String(getObject(arg1)), wasm.__wbindgen_export, wasm.__wbindgen_export2);
+	const len1 = WASM_VECTOR_LEN;
+	getDataViewMemory0().setInt32(arg0 + 4, len1, true);
+	getDataViewMemory0().setInt32(arg0 + 0, ptr1, true);
+}
+function __wbg___wbindgen_throw_ea4887a5f8f9a9db(arg0, arg1) {
+	throw new Error(getStringFromWasm0(arg0, arg1));
+}
+function __wbg_new_2e117a478906f062() {
+	return addHeapObject(/* @__PURE__ */ new Object());
+}
+function __wbg_new_36e147a8ced3c6e0() {
+	return addHeapObject(new Array());
+}
+function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
+	getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+}
+function __wbg_set_dc601f4a69da0bc2(arg0, arg1, arg2) {
+	getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+}
+function __wbindgen_cast_0000000000000001(arg0) {
+	return addHeapObject(arg0);
+}
+function __wbindgen_cast_0000000000000002(arg0) {
+	return addHeapObject(arg0);
+}
+function __wbindgen_cast_0000000000000003(arg0, arg1) {
+	return addHeapObject(getStringFromWasm0(arg0, arg1));
+}
+function __wbindgen_object_clone_ref(arg0) {
+	return addHeapObject(getObject(arg0));
+}
+function __wbindgen_object_drop_ref(arg0) {
+	takeObject(arg0);
+}
+const TransmuxCoreFinalization = typeof FinalizationRegistry === "undefined" ? {
+	register: () => {},
+	unregister: () => {}
+} : new FinalizationRegistry((ptr) => wasm.__wbg_transmuxcore_free(ptr, 1));
+function addHeapObject(obj) {
+	if (heap_next === heap.length) heap.push(heap.length + 1);
+	const idx = heap_next;
+	heap_next = heap[idx];
+	heap[idx] = obj;
+	return idx;
+}
+function dropObject(idx) {
+	if (idx < 1028) return;
+	heap[idx] = heap_next;
+	heap_next = idx;
+}
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+	if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+	return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+	return decodeText(ptr >>> 0, len);
+}
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+	if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+	return cachedUint8ArrayMemory0;
+}
+function getObject(idx) {
+	return heap[idx];
+}
+let heap = new Array(1024).fill(void 0);
+heap.push(void 0, null, true, false);
+let heap_next = heap.length;
+function passArray8ToWasm0(arg, malloc) {
+	const ptr = malloc(arg.length * 1, 1) >>> 0;
+	getUint8ArrayMemory0().set(arg, ptr / 1);
+	WASM_VECTOR_LEN = arg.length;
+	return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+	if (realloc === void 0) {
+		const buf = cachedTextEncoder.encode(arg);
+		const ptr = malloc(buf.length, 1) >>> 0;
+		getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+		WASM_VECTOR_LEN = buf.length;
+		return ptr;
+	}
+	let len = arg.length;
+	let ptr = malloc(len, 1) >>> 0;
+	const mem = getUint8ArrayMemory0();
+	let offset = 0;
+	for (; offset < len; offset++) {
+		const code = arg.charCodeAt(offset);
+		if (code > 127) break;
+		mem[ptr + offset] = code;
+	}
+	if (offset !== len) {
+		if (offset !== 0) arg = arg.slice(offset);
+		ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+		const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+		const ret = cachedTextEncoder.encodeInto(arg, view);
+		offset += ret.written;
+		ptr = realloc(ptr, len, offset, 1) >>> 0;
+	}
+	WASM_VECTOR_LEN = offset;
+	return ptr;
+}
+function takeObject(idx) {
+	const ret = getObject(idx);
+	dropObject(idx);
+	return ret;
+}
+let cachedTextDecoder = new TextDecoder("utf-8", {
+	ignoreBOM: true,
+	fatal: true
+});
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+	numBytesDecoded += len;
+	if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+		cachedTextDecoder = new TextDecoder("utf-8", {
+			ignoreBOM: true,
+			fatal: true
+		});
+		cachedTextDecoder.decode();
+		numBytesDecoded = len;
+	}
+	return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+const cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) cachedTextEncoder.encodeInto = function(arg, view) {
+	const buf = cachedTextEncoder.encode(arg);
+	view.set(buf);
+	return {
+		read: arg.length,
+		written: buf.length
+	};
+};
+let WASM_VECTOR_LEN = 0;
+let wasm;
+function __wbg_set_wasm(val) {
+	wasm = val;
+}
+//#endregion
+//#region ../../crates/transmux-core/dist/rivmux_transmux_core_bg.wasm
+var rivmux_transmux_core_bg_exports = /* @__PURE__ */ __exportAll({
+	__abort_handler: () => __abort_handler,
+	__instance_terminated: () => __instance_terminated,
+	__wbg_transmuxcore_free: () => __wbg_transmuxcore_free,
+	__wbindgen_add_to_stack_pointer: () => __wbindgen_add_to_stack_pointer,
+	__wbindgen_export: () => __wbindgen_export,
+	__wbindgen_export2: () => __wbindgen_export2,
+	memory: () => memory,
+	transmuxcore_destroy: () => transmuxcore_destroy,
+	transmuxcore_flush: () => transmuxcore_flush,
+	transmuxcore_new: () => transmuxcore_new,
+	transmuxcore_pushChunk: () => transmuxcore_pushChunk,
+	transmuxcore_reset: () => transmuxcore_reset
+});
+function __wasm_init(imports) {
+	return loadWasmModule(false, new URL("rivmux-transmux-core.wasm", import.meta.url), null, imports);
+}
+const instance = await __wasm_init({ "./rivmux_transmux_core_bg.js": {
+	"__wbindgen_object_drop_ref": __wbindgen_object_drop_ref,
+	"__wbg_set_dc601f4a69da0bc2": __wbg_set_dc601f4a69da0bc2,
+	"__wbg_set_6be42768c690e380": __wbg_set_6be42768c690e380,
+	"__wbindgen_object_clone_ref": __wbindgen_object_clone_ref,
+	"__wbg_String_8564e559799eccda": __wbg_String_8564e559799eccda,
+	"__wbg_new_36e147a8ced3c6e0": __wbg_new_36e147a8ced3c6e0,
+	"__wbg_new_2e117a478906f062": __wbg_new_2e117a478906f062,
+	"__wbg___wbindgen_throw_ea4887a5f8f9a9db": __wbg___wbindgen_throw_ea4887a5f8f9a9db,
+	"__wbg_Error_fdd633d4bb5dd76a": __wbg_Error_fdd633d4bb5dd76a,
+	"__wbindgen_cast_0000000000000001": __wbindgen_cast_0000000000000001,
+	"__wbindgen_cast_0000000000000002": __wbindgen_cast_0000000000000002,
+	"__wbindgen_cast_0000000000000003": __wbindgen_cast_0000000000000003
+} });
+const memory = instance.exports.memory;
+const __wbg_transmuxcore_free = instance.exports.__wbg_transmuxcore_free;
+const transmuxcore_destroy = instance.exports.transmuxcore_destroy;
+const transmuxcore_flush = instance.exports.transmuxcore_flush;
+const transmuxcore_new = instance.exports.transmuxcore_new;
+const transmuxcore_pushChunk = instance.exports.transmuxcore_pushChunk;
+const transmuxcore_reset = instance.exports.transmuxcore_reset;
+const __abort_handler = instance.exports.__abort_handler;
+const __instance_terminated = instance.exports.__instance_terminated;
+const __wbindgen_export = instance.exports.__wbindgen_export;
+const __wbindgen_export2 = instance.exports.__wbindgen_export2;
+const __wbindgen_add_to_stack_pointer = instance.exports.__wbindgen_add_to_stack_pointer;
+//#endregion
+//#region ../../crates/transmux-core/dist/rivmux_transmux_core.js
+__wbg_set_wasm(rivmux_transmux_core_bg_exports);
+//#endregion
+//#region src/wasm/wasm-loader.ts
+function createWasmTransmuxCoreHost(Core) {
+	return Core === void 0 ? void 0 : new WasmTransmuxCoreHost(Core);
+}
+function createBundledWasmTransmuxCoreHost() {
+	return new WasmTransmuxCoreHost(TransmuxCore);
+}
+async function loadWasmTransmuxCoreHost(wasmUrl) {
+	if (wasmUrl === void 0) return createBundledWasmTransmuxCoreHost();
+	const wasmModule = normalizeWasmBindgenModule(await nativeDynamicImport(toWasmBindgenGlueUrl(wasmUrl)));
+	await wasmModule.default(wasmUrl);
+	return new WasmTransmuxCoreHost(wasmModule.TransmuxCore);
+}
+function toWasmBindgenGlueUrl(wasmUrl) {
+	const url = new URL(wasmUrl, globalThis.location?.href ?? "http://localhost/");
+	const path = url.pathname;
+	url.pathname = path.endsWith("_bg.wasm") ? `${path.slice(0, -8)}.js` : path.replace(/\.wasm$/u, ".js");
+	return url.href;
+}
+function normalizeWasmBindgenModule(value) {
+	if (!isRecord(value) || typeof value.default !== "function" || typeof value.TransmuxCore !== "function") throw new TypeError("WASM transmux module must export default init and TransmuxCore.");
+	return value;
+}
+function nativeDynamicImport(url) {
+	return new Function("url", "return import(url)")(url);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region src/runtime.ts
+var RuntimeWorker = class {
+	constructor(port, dependencies = {}) {
+		this.state = "idle";
+		this.lastLatencyMetrics = {};
+		this.statsTickInFlight = false;
+		this.loaderRunId = 0;
+		this.outputBytes = 0;
+		this.appendQueueMaxLength = 0;
+		this.appendQueueMaxBytes = 0;
+		this.port = port;
+		this.createMseController = dependencies.createMseController ?? (() => new MseController());
+		this.createLoader = dependencies.createLoader ?? ((config) => new HttpFlvLoader(config));
+		this.createTransmuxCore = dependencies.createTransmuxCore ?? ((options) => loadWasmTransmuxCoreHost(options.runtime.wasmUrl));
+		this.now = dependencies.now ?? (() => performance.now());
+	}
+	async handleCommand(command) {
+		if (this.state === "destroyed") return;
+		try {
+			switch (command.type) {
+				case "init":
+					this.url = command.url;
+					this.options = command.options;
+					this.latencyController = createLatencyController(command.options);
+					this.state = "ready";
+					this.post({ type: "ready" });
+					return;
+				case "attach-media-source":
+					await this.attachMediaSource();
+					return;
+				case "start":
+					await this.start();
+					return;
+				case "stop":
+					await this.stop();
+					return;
+				case "update-options":
+					this.options = this.options === void 0 ? void 0 : mergeOptions(this.options, command.options);
+					if (this.options !== void 0) this.latencyController = createLatencyController(this.options);
+					return;
+				case "video-state":
+					this.videoState = command.state;
+					await this.applyLatencyPolicy();
+					this.postStats();
+					return;
+				case "playback-control-result":
+					this.latencyController?.recordPlaybackControlResult(command.result);
+					return;
+				case "destroy":
+					await this.destroy();
+					return;
+			}
+		} catch (cause) {
+			this.fail("runtime", "RIVMUX_WORKER_COMMAND_FAILED", "Worker command failed.", true, cause);
+		}
+	}
+	async attachMediaSource() {
+		if (this.state === "idle") {
+			this.fail("runtime", "RIVMUX_WORKER_NOT_INITIALIZED", "Worker must be initialized before attach.", true);
+			return;
+		}
+		if (this.mse === void 0) this.mse = this.createMseController();
+		try {
+			const handle = await this.mse.createMediaSourceHandle();
+			this.post({
+				type: "media-source-handle",
+				handle
+			}, [handle]);
+			this.state = "attached";
+		} catch (cause) {
+			this.fail("mse", "RIVMUX_MSE_ATTACH_FAILED", "MSE media source attachment failed.", true, cause);
+		}
+	}
+	async start() {
+		const options = this.options;
+		if (this.mse === void 0 || options === void 0 || this.state === "idle" || this.state === "ready") {
+			this.fail("runtime", "RIVMUX_WORKER_START_REQUIRES_ATTACH", "Worker start requires an attached MediaSource.", true);
+			return;
+		}
+		if (this.state === "started") return;
+		const fixture = createM1StaticFmp4Fixture();
+		const transmuxCore = await this.createTransmuxCore(options);
+		const hasTransmuxCore = transmuxCore !== void 0;
+		if (transmuxCore !== void 0) {
+			this.transmuxCore?.destroy();
+			this.transmuxCore = transmuxCore;
+		} else try {
+			await this.mse.appendFixture(fixture);
+		} catch (cause) {
+			this.fail("mse", "RIVMUX_MSE_APPEND_FAILED", "MSE append failed.", true, cause);
+			return;
+		}
+		this.state = "started";
+		this.outputBytes = hasTransmuxCore ? 0 : fixture.initSegment.byteLength + fixture.mediaSegment.byteLength;
+		this.appendQueueMaxLength = 0;
+		this.appendQueueMaxBytes = 0;
+		if (!hasTransmuxCore) this.post({
+			type: "media-info",
+			mediaInfo: {
+				container: "fmp4",
+				videoCodec: fixture.codec,
+				width: fixture.width,
+				height: fixture.height
+			}
+		});
+		this.startStatsTimer();
+		await this.applyLatencyPolicy();
+		this.postStats();
+		this.startLoader();
+	}
+	async stop() {
+		await this.closeLoader();
+		this.mse?.destroy();
+		this.mse = void 0;
+		this.latencyController?.reset();
+		this.videoState = void 0;
+		this.lastLatencyMetrics = {};
+		this.state = "stopped";
+		this.post({ type: "stopped" });
+	}
+	async destroy() {
+		await this.closeLoader();
+		this.mse?.destroy();
+		this.mse = void 0;
+		this.latencyController?.reset();
+		this.videoState = void 0;
+		this.lastLatencyMetrics = {};
+		this.state = "destroyed";
+		this.post({ type: "destroyed" });
+		this.port.close();
+	}
+	startLoader() {
+		const options = this.options;
+		const url = this.url;
+		if (options === void 0 || url === void 0) {
+			this.fail("runtime", "RIVMUX_WORKER_NOT_INITIALIZED", "Worker must be initialized before loader start.", true);
+			return;
+		}
+		const loader = this.createLoader({
+			url,
+			network: options.network
+		});
+		const runId = this.loaderRunId + 1;
+		this.loaderRunId = runId;
+		this.loader = loader;
+		this.runLoader(loader, runId);
+	}
+	async runLoader(loader, runId) {
+		try {
+			await loader.open();
+			while (this.isCurrentLoader(loader, runId)) {
+				await this.applyLatencyPolicy();
+				const chunk = await loader.read();
+				if (chunk === null) break;
+				this.postStats(loader.stats);
+				if (!await this.processTransmuxEvents(this.transmuxCore?.pushChunk(chunk.bytes) ?? [])) {
+					await this.closeCurrentLoader(loader, runId);
+					return;
+				}
+				await this.applyLatencyPolicy();
+				this.postStats(loader.stats);
+			}
+		} catch (cause) {
+			if (!this.isCurrentLoader(loader, runId) || isAbortLikeError(cause)) return;
+			await this.closeCurrentLoader(loader, runId);
+			this.fail("network", getNetworkErrorCode(cause), "HTTP Fetch loader failed.", true, cause);
+			return;
+		} finally {
+			if (this.isCurrentLoader(loader, runId)) await this.closeCurrentLoader(loader, runId);
+		}
+	}
+	async closeLoader() {
+		this.stopStatsTimer();
+		const loader = this.loader;
+		if (loader === void 0) return;
+		this.loader = void 0;
+		this.loaderRunId += 1;
+		this.transmuxCore?.destroy();
+		this.transmuxCore = void 0;
+		await loader.close();
+	}
+	async closeCurrentLoader(loader, runId) {
+		if (this.loader !== loader || this.loaderRunId !== runId) return;
+		this.stopStatsTimer();
+		this.loader = void 0;
+		this.loaderRunId += 1;
+		this.transmuxCore?.destroy();
+		this.transmuxCore = void 0;
+		await loader.close();
+	}
+	isCurrentLoader(loader, runId) {
+		return this.loader === loader && this.loaderRunId === runId && this.state === "started";
+	}
+	postStats(loaderStats) {
+		const metrics = this.lastLatencyMetrics;
+		const mseStats = this.collectMseStats();
+		const loaderSnapshot = loaderStats ?? this.loader?.stats;
+		this.post({
+			type: "stats",
+			stats: {
+				bytesReceived: loaderSnapshot?.bytesReceived ?? 0,
+				currentNetworkSpeed: loaderSnapshot?.currentNetworkSpeed ?? 0,
+				networkIdleMs: getNetworkIdleMs(loaderSnapshot, this.now()),
+				outputBytes: this.outputBytes,
+				appendQueueLength: mseStats.appendQueueLength,
+				appendQueueBytes: mseStats.appendQueueBytes,
+				appendQueueMaxLength: this.appendQueueMaxLength,
+				appendQueueMaxBytes: this.appendQueueMaxBytes,
+				loaderPaused: this.loader?.paused ?? false,
+				sourceBufferUpdating: mseStats.sourceBufferUpdating,
+				sourceBufferCount: mseStats.sourceBufferCount,
+				bufferedStart: metrics.bufferedStart ?? this.mse?.bufferedStart,
+				bufferedEnd: metrics.bufferedEnd ?? this.mse?.bufferedEnd,
+				bufferedDuration: metrics.bufferedDuration ?? this.mse?.bufferedDuration,
+				bufferedRangeCount: mseStats.bufferedRangeCount,
+				currentTime: metrics.currentTime,
+				liveLatency: metrics.liveLatency,
+				playbackRate: metrics.playbackRate,
+				readyState: metrics.readyState,
+				droppedFrames: metrics.droppedFrames
+			}
+		});
+	}
+	async processTransmuxEvents(events) {
+		for (const event of events) switch (event.type) {
+			case "mediaInfo":
+				this.post({
+					type: "media-info",
+					mediaInfo: coreMediaInfoToPlayerMediaInfo(event.data)
+				});
+				break;
+			case "warning":
+				this.post({
+					type: "warning",
+					warning: coreWarningToPlayerWarning(event.data)
+				});
+				break;
+			case "fatalError":
+				this.post({
+					type: "error",
+					error: coreErrorToPlayerError(event.data)
+				});
+				this.state = "fatal-error";
+				return false;
+			case "initSegment":
+				if (!await this.appendToMse(() => this.mse?.appendInitSegment(event.data))) return false;
+				this.outputBytes += event.data.bytes.byteLength;
+				await this.applyLatencyPolicy();
+				break;
+			case "mediaSegment":
+				if (!await this.appendToMse(() => this.mse?.appendMediaSegment(event.data))) return false;
+				this.outputBytes += event.data.bytes.byteLength;
+				await this.applyLatencyPolicy();
+				break;
+			case "probeResult":
+			case "videoConfig":
+			case "audioConfig":
+			case "videoSample":
+			case "audioSample":
+			case "metadata":
+			case "discontinuity": break;
+		}
+		return true;
+	}
+	collectMseStats() {
+		const appendQueueLength = this.mse?.appendQueueLength ?? 0;
+		const appendQueueBytes = this.mse?.appendQueueBytes ?? 0;
+		this.appendQueueMaxLength = Math.max(this.appendQueueMaxLength, appendQueueLength);
+		this.appendQueueMaxBytes = Math.max(this.appendQueueMaxBytes, appendQueueBytes);
+		return {
+			appendQueueLength,
+			appendQueueBytes,
+			sourceBufferUpdating: this.mse?.sourceBufferUpdating ?? false,
+			sourceBufferCount: this.mse?.sourceBufferCount ?? 0,
+			bufferedRangeCount: this.mse?.bufferedRangeCount ?? 0
+		};
+	}
+	async appendToMse(append) {
+		try {
+			await append();
+			return true;
+		} catch (cause) {
+			this.fail("mse", "RIVMUX_MSE_APPEND_FAILED", "MSE append failed.", true, cause);
+			return false;
+		}
+	}
+	async applyLatencyPolicy() {
+		const latencyController = this.latencyController;
+		const mse = this.mse;
+		if (latencyController === void 0 || mse === void 0) return;
+		const loader = this.loader;
+		const evaluation = latencyController.evaluate({
+			ranges: mse.bufferedRanges,
+			videoState: this.videoState,
+			loaderPaused: loader?.paused ?? false,
+			nowMs: this.now()
+		});
+		this.lastLatencyMetrics = evaluation.metrics;
+		if (evaluation.cleanupBefore !== void 0) await mse.cleanupBefore(evaluation.cleanupBefore);
+		if (loader !== void 0 && evaluation.loaderCommand === "pause") loader.pause();
+		else if (loader !== void 0 && evaluation.loaderCommand === "resume") loader.resume();
+		if (evaluation.playbackControl !== void 0) this.post({
+			type: "playback-control",
+			action: evaluation.playbackControl
+		});
+	}
+	startStatsTimer() {
+		this.stopStatsTimer();
+		const intervalMs = this.options?.diagnostics.statsIntervalMs;
+		if (intervalMs === void 0 || intervalMs <= 0) return;
+		this.statsTimer = setInterval(() => {
+			this.emitStatsTick();
+		}, intervalMs);
+	}
+	stopStatsTimer() {
+		if (this.statsTimer === void 0) return;
+		clearInterval(this.statsTimer);
+		this.statsTimer = void 0;
+		this.statsTickInFlight = false;
+	}
+	async emitStatsTick() {
+		if (this.statsTickInFlight || this.state !== "started") return;
+		this.statsTickInFlight = true;
+		try {
+			await this.applyLatencyPolicy();
+			this.postStats();
+		} catch (cause) {
+			this.fail("mse", "RIVMUX_MSE_LATENCY_POLICY_FAILED", "MSE latency policy failed.", true, cause);
+		} finally {
+			this.statsTickInFlight = false;
+		}
+	}
+	fail(kind, code, message, terminal, cause) {
+		const error = cause === void 0 ? {
+			kind,
+			code,
+			message,
+			terminal
+		} : {
+			kind,
+			code,
+			message,
+			terminal,
+			cause: serializeCause(cause)
+		};
+		if (terminal) this.state = "fatal-error";
+		this.post({
+			type: "error",
+			error
+		});
+	}
+	post(message, transfer) {
+		this.port.postMessage(message, transfer);
+	}
+};
+function getNetworkErrorCode(cause) {
+	return cause instanceof HttpFlvLoaderError ? cause.code : "RIVMUX_HTTP_LOADER_FAILED";
+}
+function getNetworkIdleMs(stats, nowMs) {
+	const markerMs = stats?.lastChunkAtMs ?? stats?.startedAtMs;
+	if (markerMs === void 0) return;
+	return Math.max(nowMs - markerMs, 0);
+}
+function serializeCause(cause) {
+	if (cause instanceof Error) return {
+		name: cause.name,
+		message: cause.message
+	};
+	return cause;
+}
+function createLatencyController(options) {
+	return new LatencyController({
+		latency: options.latency,
+		playback: options.playback
+	});
+}
+function mergeOptions(current, updates) {
+	return {
+		playback: {
+			...current.playback,
+			...updates.playback
+		},
+		latency: {
+			...current.latency,
+			...updates.latency
+		},
+		network: {
+			...current.network,
+			...updates.network,
+			headers: {
+				...current.network.headers,
+				...updates.network?.headers
+			},
+			retry: {
+				...current.network.retry,
+				...updates.network?.retry
+			}
+		},
+		runtime: {
+			...current.runtime,
+			...updates.runtime
+		},
+		diagnostics: {
+			...current.diagnostics,
+			...updates.diagnostics
+		}
+	};
+}
+//#endregion
+//#region src/worker-entry.ts
+function startRuntimeWorker(scope) {
+	const runtime = new RuntimeWorker({
+		postMessage: (message, transfer) => scope.postMessage(message, transfer),
+		close: () => scope.close()
+	});
+	scope.addEventListener("message", (event) => {
+		runtime.handleCommand(event.data);
+	});
+	scope.postMessage({ type: "worker-ready" });
+	return runtime;
+}
+const globalScope = globalThis;
+const workerGlobalScope = globalThis.WorkerGlobalScope;
+if (workerGlobalScope !== void 0 && globalScope instanceof workerGlobalScope && typeof globalScope.postMessage === "function") startRuntimeWorker(globalScope);
+//#endregion
+export { HttpFlvLoader, HttpFlvLoaderError, M1_VIDEO_MIME, MseController, RuntimeWorker, SourceBufferQueue, WasmTransmuxCoreHost, createM1StaticFmp4Fixture, createWasmTransmuxCoreHost, isMseSupported, normalizeCoreEvents, startRuntimeWorker };
+//# sourceMappingURL=rivmux-runtime-worker.js.map