@moq/watch 0.2.13 → 0.2.15

package/main-bFFHfuX4.js

@@ -0,0 +1,1999 @@
+//#region ../../node_modules/@kixelated/libavjs-webcodecs-polyfill/dist/encoded-audio-chunk.js
+var e = class {
+	constructor(e) {
+		{
+			this.type = e.type, this.timestamp = e.timestamp, typeof e.duration == "number" ? this.duration = e.duration : this.duration = null, this.byteLength = e.data.byteLength;
+			let t = !1;
+			if (e.transfer) {
+				let n;
+				n = e.data.buffer ? e.data.buffer : e.data;
+				let r;
+				r = e.transfer instanceof Array ? e.transfer : Array.from(e.transfer);
+				for (let e of r) if (e === n) {
+					t = !0;
+					break;
+				}
+			}
+			let n = new Uint8Array(e.data.buffer || e.data, e.data.byteOffset || 0, e.data.BYTES_PER_ELEMENT ? e.data.BYTES_PER_ELEMENT * e.data.length : e.data.byteLength);
+			t ? this._data = n : this._data = n.slice(0);
+		}
+	}
+	_libavGetData() {
+		return this._data;
+	}
+	copyTo(e) {
+		new Uint8Array(e.buffer || e, e.byteOffset || 0).set(this._data);
+	}
+};
+//#endregion
+//#region ../../node_modules/@ungap/global-this/esm/index.js
+(function(e) {
+	typeof globalThis != "object" && (this ? t() : (e.defineProperty(e.prototype, "_T_", {
+		configurable: !0,
+		get: t
+	}), _T_));
+	function t() {
+		var t = this || self;
+		t.globalThis = t, delete e.prototype._T_;
+	}
+})(Object);
+//#endregion
+//#region ../../node_modules/@kixelated/libavjs-webcodecs-polyfill/dist/audio-data.js
+var t = class e {
+	constructor(t) {
+		e._checkValidAudioDataInit(t);
+		{
+			this.format = t.format, this.sampleRate = t.sampleRate, this.numberOfFrames = t.numberOfFrames, this.numberOfChannels = t.numberOfChannels, this.timestamp = t.timestamp;
+			let e = !1;
+			if (t.transfer) {
+				let n;
+				n = t.data.buffer ? t.data.buffer : t.data;
+				let r;
+				r = t.transfer instanceof Array ? t.transfer : Array.from(t.transfer);
+				for (let t of r) if (t === n) {
+					e = !0;
+					break;
+				}
+			}
+			let r, i = 0;
+			e ? (r = t.data, i = t.data.byteOffset || 0) : r = t.data.slice(0);
+			let a = n(t.format, r.buffer || r, i);
+			this._data = a;
+		}
+		this.duration = t.numberOfFrames / t.sampleRate * 1e6;
+	}
+	toNative(e = {}) {
+		let t = new globalThis.AudioData({
+			data: this._data,
+			format: this.format,
+			sampleRate: this.sampleRate,
+			numberOfFrames: this.numberOfFrames,
+			numberOfChannels: this.numberOfChannels,
+			timestamp: this.timestamp,
+			transfer: e.transfer ? [this._data.buffer] : []
+		});
+		return e.transfer && this.close(), t;
+	}
+	static fromNative(t) {
+		let n = t, r = i(n.format) ? 1 : n.numberOfChannels, a = n.allocationSize({
+			format: n.format,
+			planeIndex: 0
+		}), o = new Uint8Array(a * r);
+		for (let e = 0; e < r; e++) n.copyTo(o.subarray(e * a), {
+			format: n.format,
+			planeIndex: e
+		});
+		return new e({
+			data: o,
+			format: n.format,
+			sampleRate: n.sampleRate,
+			numberOfFrames: n.numberOfFrames,
+			numberOfChannels: n.numberOfChannels,
+			timestamp: n.timestamp,
+			transfer: [o.buffer]
+		});
+	}
+	_libavGetData() {
+		return this._data;
+	}
+	static _checkValidAudioDataInit(e) {
+		if (e.sampleRate <= 0) throw TypeError(`Invalid sample rate ${e.sampleRate}`);
+		if (e.numberOfFrames <= 0) throw TypeError(`Invalid number of frames ${e.numberOfFrames}`);
+		if (e.numberOfChannels <= 0) throw TypeError(`Invalid number of channels ${e.numberOfChannels}`);
+		{
+			let t = e.numberOfFrames * e.numberOfChannels, n = r(e.format) * t;
+			if (e.data.byteLength < n) throw TypeError(`This audio data must be at least ${n} bytes`);
+		}
+	}
+	allocationSize(e) {
+		if (this._data === null) throw new DOMException("Detached", "InvalidStateError");
+		let t = this._computeCopyElementCount(e), n = this.format;
+		return e.format && (n = e.format), r(n) * t;
+	}
+	_computeCopyElementCount(e) {
+		let t = this.format;
+		e.format && (t = e.format);
+		let n = i(t);
+		if (n) {
+			if (e.planeIndex > 0) throw RangeError("Invalid plane");
+		} else if (e.planeIndex >= this.numberOfChannels) throw RangeError("Invalid plane");
+		if (this.format !== t && t !== "f32-planar") throw new DOMException("Only conversion to f32-planar is supported", "NotSupportedError");
+		let r = this.numberOfFrames, a = e.frameOffset || 0;
+		if (a >= r) throw RangeError("Frame offset out of range");
+		let o = r - a;
+		if (typeof e.frameCount == "number") {
+			if (e.frameCount >= o) throw RangeError("Frame count out of range");
+			o = e.frameCount;
+		}
+		let s = o;
+		return n && (s *= this.numberOfChannels), s;
+	}
+	copyTo(e, t) {
+		if (this._data === null) throw new DOMException("Detached", "InvalidStateError");
+		let a = this._computeCopyElementCount(t), o = this.format;
+		if (t.format && (o = t.format), r(o) * a > e.byteLength) throw RangeError("Buffer too small");
+		let s = this._data.subarray(t.planeIndex * this.numberOfFrames), c = t.frameOffset || 0, l = this.numberOfChannels;
+		if (this.format === o) {
+			let t = n(o, e.buffer || e, e.byteOffset || 0);
+			i(o) ? t.set(s.subarray(c * l, c * l + a)) : t.set(s.subarray(c, c + a));
+		} else {
+			let r = n(o, e.buffer || e, e.byteOffset || 0), u = 0, d = 1;
+			switch (this.format) {
+				case "u8":
+				case "u8-planar":
+					u = 128, d = 128;
+					break;
+				case "s16":
+				case "s16-planar":
+					d = 32768;
+					break;
+				case "s32":
+				case "s32-planar":
+					d = 2147483648;
+					break;
+			}
+			if (i(this.format)) for (let e = t.planeIndex + c * l, n = 0; n < a; e += l, n++) r[n] = (s[e] - u) / d;
+			else for (let e = c, t = 0; t < a; e++, t++) r[t] = (s[e] - u) / d;
+		}
+	}
+	clone() {
+		if (this._data === null) throw new DOMException("Detached", "InvalidStateError");
+		return new e({
+			format: this.format,
+			sampleRate: this.sampleRate,
+			numberOfFrames: this.numberOfFrames,
+			numberOfChannels: this.numberOfChannels,
+			timestamp: this.timestamp,
+			data: this._data
+		});
+	}
+	close() {
+		this._data = null;
+	}
+};
+function n(e, t, n) {
+	switch (e) {
+		case "u8":
+		case "u8-planar": return new Uint8Array(t, n);
+		case "s16":
+		case "s16-planar": return new Int16Array(t, n);
+		case "s32":
+		case "s32-planar": return new Int32Array(t, n);
+		case "f32":
+		case "f32-planar": return new Float32Array(t, n);
+		default: throw TypeError("Invalid AudioSampleFormat");
+	}
+}
+function r(e) {
+	switch (e) {
+		case "u8":
+		case "u8-planar": return 1;
+		case "s16":
+		case "s16-planar": return 2;
+		case "s32":
+		case "s32-planar":
+		case "f32":
+		case "f32-planar": return 4;
+		default: throw TypeError("Invalid AudioSampleFormat");
+	}
+}
+function i(e) {
+	switch (e) {
+		case "u8":
+		case "s16":
+		case "s32":
+		case "f32": return !0;
+		case "u8-planar":
+		case "s16-planar":
+		case "s32-planar":
+		case "f32-planar": return !1;
+		default: throw TypeError("Invalid AudioSampleFormat");
+	}
+}
+//#endregion
+//#region ../../node_modules/@kixelated/libavjs-webcodecs-polyfill/dist/event-target.js
+var a = class {
+	constructor() {
+		let e = this._eventer = new EventTarget();
+		this.addEventListener = e.addEventListener.bind(e), this.removeEventListener = e.removeEventListener.bind(e), this.dispatchEvent = e.dispatchEvent.bind(e);
+	}
+}, o = class extends a {
+	constructor() {
+		super(), this.addEventListener("dequeue", (e) => {
+			this.ondequeue && this.ondequeue(e);
+		});
+	}
+}, s = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+}, c = null, l = [], u = {}, d = null, f = null;
+function p(e) {
+	c = e;
+}
+function m(e) {
+	u = e;
+}
+function h() {
+	return s(this, void 0, void 0, function* () {
+		return l.length ? l.shift() : yield c.LibAV(u);
+	});
+}
+function g(e) {
+	l.push(e);
+}
+function _(e) {
+	return s(this, void 0, void 0, function* () {
+		let t = yield h(), n = [];
+		for (let [r, i] of [
+			["flac", "flac"],
+			["libopus", "opus"],
+			["libvorbis", "vorbis"],
+			["libaom-av1", "av01"],
+			["libvpx-vp9", "vp09"],
+			["libvpx", "vp8"]
+		]) e ? (yield t.avcodec_find_encoder_by_name(r)) && n.push(i) : (yield t.avcodec_find_decoder_by_name(r)) && n.push(i);
+		return g(t), n;
+	});
+}
+function v() {
+	return s(this, void 0, void 0, function* () {
+		c ||= LibAV, d = yield _(!1), f = yield _(!0);
+	});
+}
+function y(e, t) {
+	if (typeof e == "string") {
+		e = e.replace(/\..*/, "");
+		let n = e;
+		switch (e) {
+			case "flac":
+				if (t.description === void 0) return null;
+				break;
+			case "opus":
+				if (t.description !== void 0) return null;
+				n = "libopus";
+				break;
+			case "vorbis":
+				if (t.description === void 0) return null;
+				n = "libvorbis";
+				break;
+			case "av01":
+				n = "libaom-av1";
+				break;
+			case "vp09":
+				n = "libvpx-vp9";
+				break;
+			case "vp8":
+				n = "libvpx";
+				break;
+			case "mp3":
+			case "mp4a":
+			case "ulaw":
+			case "alaw":
+			case "avc1":
+			case "avc3":
+			case "hev1":
+			case "hvc1": return null;
+			default: throw TypeError("Unrecognized codec");
+		}
+		return d.indexOf(e) >= 0 ? { codec: n } : null;
+	} else return e.libavjs;
+}
+function b(e, t) {
+	if (typeof e == "string") {
+		let n = e.split(".");
+		e = n[0];
+		let r = e, i = {}, a = {}, o = !1;
+		switch (e) {
+			case "flac":
+				if (i.sample_fmt = 2, i.bit_rate = 0, typeof t.flac == "object" && t.flac !== null) {
+					let e = t.flac;
+					if (typeof e.blockSize == "number" && (i.frame_size = e.blockSize), typeof e.compressLevel == "number") return null;
+				}
+				break;
+			case "opus":
+				if (r = "libopus", i.sample_fmt = 3, i.sample_rate = 48e3, typeof t.opus == "object" && t.opus !== null) {
+					let e = t.opus;
+					if (typeof e.frameDuration == "number" && (a.frame_duration = "" + e.frameDuration / 1e3), e.complexity !== void 0) return null;
+					if (typeof e.packetlossperc == "number") {
+						if (e.packetlossperc < 0 || e.packetlossperc > 100) return null;
+						a.packet_loss = "" + e.packetlossperc;
+					}
+					if (typeof e.useinbandfec == "boolean" && (a.fec = e.useinbandfec ? "1" : "0"), typeof e.usedtx == "boolean" || typeof e.format == "string" && e.format !== "opus") return null;
+				}
+				break;
+			case "vorbis":
+				r = "libvorbis", i.sample_fmt = 8;
+				break;
+			case "av01":
+				if (o = !0, r = "libaom-av1", t.latencyMode === "realtime" && (a.usage = "realtime", a["cpu-used"] = "8"), !x(n, i)) return null;
+				break;
+			case "vp09":
+				if (o = !0, r = "libvpx-vp9", t.latencyMode === "realtime" && (a.quality = "realtime", a["cpu-used"] = "8"), !S(n, i)) return null;
+				break;
+			case "vp8":
+				o = !0, r = "libvpx", t.latencyMode === "realtime" && (a.quality = "realtime", a["cpu-used"] = "8");
+				break;
+			case "mp3":
+			case "mp4a":
+			case "ulaw":
+			case "alaw":
+			case "avc1": return null;
+			default: throw TypeError("Unrecognized codec");
+		}
+		if (!(f.indexOf(e) >= 0)) return null;
+		if (o) {
+			typeof i.pix_fmt != "number" && (i.pix_fmt = 0);
+			let e = i.width = t.width, n = i.height = t.height;
+			t.framerate && (i.framerate_num = Math.round(t.framerate), i.framerate_den = 1);
+			let r = t.displayWidth || t.width, a = t.displayHeight || t.height;
+			(r !== e || a !== n) && (i.sample_aspect_ratio_num = r * n, i.sample_aspect_ratio_den = a * e);
+		} else if (i.sample_rate ||= t.sampleRate || 48e3, t.numberOfChannels) {
+			let e = t.numberOfChannels;
+			i.channel_layout = e === 1 ? 4 : (1 << e) - 1;
+		}
+		return typeof i.bit_rate != "number" && t.bitrate && (i.bit_rate = t.bitrate), {
+			codec: r,
+			ctx: i,
+			options: a
+		};
+	} else return e.libavjs;
+}
+function x(e, t) {
+	if (e[1]) {
+		let n = +e[1];
+		if (n >= 0 && n <= 2) t.profile = n;
+		else throw TypeError("Invalid AV1 profile");
+	}
+	if (e[2]) {
+		let n = +e[2];
+		if (n >= 0 && n <= 23) t.level = n;
+		else throw TypeError("Invalid AV1 level");
+	}
+	if (e[3]) switch (e[3]) {
+		case "M": break;
+		case "H":
+			if (t.level && t.level >= 8) return !1;
+			throw TypeError("The AV1 high tier is only available for level 4.0 and up");
+		default: throw TypeError("Invalid AV1 tier");
+	}
+	if (e[4]) {
+		let t = +e[3];
+		if (t === 10 || t === 12) return !1;
+		if (t !== 8) throw TypeError("Invalid AV1 bit depth");
+	}
+	if (e[5]) switch (e[5]) {
+		case "0": break;
+		case "1": return !1;
+		default: throw TypeError("Invalid AV1 monochrome flag");
+	}
+	if (e[6]) switch (e[6]) {
+		case "000":
+			t.pix_fmt = 5;
+			break;
+		case "100":
+			t.pix_fmt = 4;
+			break;
+		case "110":
+			t.pix_fmt = 0;
+			break;
+		case "111": return !1;
+		default: throw TypeError("Invalid AV1 subsampling mode");
+	}
+	return !0;
+}
+function S(e, t) {
+	if (e[1]) {
+		let n = +e[1];
+		if (n >= 0 && n <= 3) t.profile = n;
+		else throw TypeError("Invalid VP9 profile");
+	}
+	if (e[2]) {
+		let n = [+e[2][0], +e[2][1]];
+		if (n[0] >= 1 && n[0] <= 4) {
+			if (!(n[1] >= 0 && n[1] <= 1)) throw TypeError("Invalid VP9 level");
+		} else if (n[0] >= 5 && n[0] <= 6) {
+			if (!(n[1] >= 0 && n[1] <= 2)) throw TypeError("Invalid VP9 level");
+		} else throw TypeError("Invalid VP9 level");
+		t.level = +e[2];
+	}
+	if (e[3]) {
+		let t = +e[3];
+		if (t === 10 || t === 12) return !1;
+		if (t !== 8) throw TypeError("Invalid VP9 bit depth");
+	}
+	if (e[4]) switch (+e[4]) {
+		case 0:
+		case 1:
+			t.pix_fmt = 0;
+			break;
+		case 2:
+			t.pix_fmt = 4;
+			break;
+		case 3:
+			t.pix_fmt = 5;
+			break;
+		default: throw TypeError("Invalid VP9 chroma subsampling format");
+	}
+	return !0;
+}
+//#endregion
+//#region ../../node_modules/@kixelated/libavjs-webcodecs-polyfill/dist/misc.js
+function C(e, t) {
+	let n = {};
+	for (let r of t) r in e && (n[r] = e[r]);
+	return n;
+}
+//#endregion
+//#region ../../node_modules/@kixelated/libavjs-webcodecs-polyfill/dist/audio-decoder.js
+var w = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+}, T = class extends o {
+	constructor(e) {
+		super(), this._p = Promise.all([]), this._libav = null, this._codec = this._c = this._pkt = this._frame = 0, this._output = e.output, this._error = e.error, this.state = "unconfigured", this.decodeQueueSize = 0;
+	}
+	configure(e) {
+		if (this.state === "closed") throw new DOMException("Decoder is closed", "InvalidStateError");
+		this._libav && (this._p = this._p.then(() => this._free())), this.state = "configured", this._p = this._p.then(() => w(this, void 0, void 0, function* () {
+			let t;
+			if (e.description) if (ArrayBuffer.isView(e.description)) {
+				let n = e.description;
+				t = new Uint8Array(n.buffer, n.byteOffset, n.byteLength);
+			} else {
+				let n = e.description;
+				t = new Uint8Array(n);
+			}
+			let n = y(e.codec, e);
+			if (!n) {
+				this._closeAudioDecoder(new DOMException("Unsupported codec", "NotSupportedError"));
+				return;
+			}
+			let r = this._libav = yield h(), i = yield r.avcodec_parameters_alloc(), a = [
+				r.AVCodecParameters_channels_s(i, e.numberOfChannels),
+				r.AVCodecParameters_sample_rate_s(i, e.sampleRate),
+				r.AVCodecParameters_codec_type_s(i, 1)
+			], o = 0;
+			t ? (a.push(r.AVCodecParameters_extradata_size_s(i, t.byteLength)), o = yield r.calloc(t.byteLength + 64, 1), a.push(r.copyin_u8(o, t)), a.push(r.AVCodecParameters_extradata_s(i, o))) : (a.push(r.AVCodecParameters_extradata_s(i, 0)), a.push(r.AVCodecParameters_extradata_size_s(i, 0))), yield Promise.all(a), [this._codec, this._c, this._pkt, this._frame] = yield r.ff_init_decoder(n.codec, i);
+			let s = [r.AVCodecContext_time_base_s(this._c, 1, 1e3), r.avcodec_parameters_free_js(i)];
+			o && s.push(r.free(o)), yield Promise.all(s);
+		})).catch(this._error);
+	}
+	_free() {
+		return w(this, void 0, void 0, function* () {
+			this._c && (yield this._libav.ff_free_decoder(this._c, this._pkt, this._frame), this._codec = this._c = this._pkt = this._frame = 0), this._libav &&= (g(this._libav), null);
+		});
+	}
+	_closeAudioDecoder(e) {
+		this._resetAudioDecoder(e), this.state = "closed", this._p = this._p.then(() => this._free()), e.name !== "AbortError" && (this._p = this._p.then(() => {
+			this._error(e);
+		}));
+	}
+	_resetAudioDecoder(e) {
+		if (this.state === "closed") throw new DOMException("Decoder closed", "InvalidStateError");
+		this.state = "unconfigured", this._p = this._p.then(() => this._free());
+	}
+	decode(e) {
+		if (this.state !== "configured") throw new DOMException("Unconfigured", "InvalidStateError");
+		this.decodeQueueSize++, this._p = this._p.then(() => w(this, void 0, void 0, function* () {
+			let t = this._libav, n = this._c, r = this._pkt, i = this._frame, a = null;
+			this.decodeQueueSize--, this.dispatchEvent(new CustomEvent("dequeue"));
+			try {
+				let o = Math.floor(e.timestamp / 1e3), [s, c] = t.f64toi64(o), l = {
+					data: e._libavGetData(),
+					pts: s,
+					ptshi: c,
+					dts: s,
+					dtshi: c
+				};
+				e.duration && (l.duration = Math.floor(e.duration / 1e3), l.durationhi = 0), a = yield t.ff_decode_multi(n, r, i, [l]);
+			} catch (e) {
+				this._p = this._p.then(() => {
+					this._closeAudioDecoder(e);
+				});
+				return;
+			}
+			a && this._outputAudioData(a);
+		})).catch(this._error);
+	}
+	_outputAudioData(e) {
+		let n = this._libav;
+		for (let r of e) {
+			let e, i = !1;
+			switch (r.format) {
+				case n.AV_SAMPLE_FMT_U8:
+					e = "u8";
+					break;
+				case n.AV_SAMPLE_FMT_S16:
+					e = "s16";
+					break;
+				case n.AV_SAMPLE_FMT_S32:
+					e = "s32";
+					break;
+				case n.AV_SAMPLE_FMT_FLT:
+					e = "f32";
+					break;
+				case n.AV_SAMPLE_FMT_U8P:
+					e = "u8", i = !0;
+					break;
+				case n.AV_SAMPLE_FMT_S16P:
+					e = "s16", i = !0;
+					break;
+				case n.AV_SAMPLE_FMT_S32P:
+					e = "s32", i = !0;
+					break;
+				case n.AV_SAMPLE_FMT_FLTP:
+					e = "f32", i = !0;
+					break;
+				default: throw new DOMException("Unsupported libav format!", "EncodingError");
+			}
+			let a = r.sample_rate, o = r.nb_samples, s = r.channels, c = n.i64tof64(r.pts, r.ptshi) * 1e3, l;
+			if (i) {
+				let e = 0;
+				for (let t = 0; t < r.data.length; t++) e += r.data[t].length;
+				l = new r.data[0].constructor(e), e = 0;
+				for (let t = 0; t < r.data.length; t++) {
+					let n = r.data[t];
+					l.set(n, e), e += n.length;
+				}
+			} else l = r.data;
+			let u = new t({
+				format: e,
+				sampleRate: a,
+				numberOfFrames: o,
+				numberOfChannels: s,
+				timestamp: c,
+				data: l
+			});
+			this._output(u);
+		}
+	}
+	flush() {
+		if (this.state !== "configured") throw new DOMException("Invalid state", "InvalidStateError");
+		let e = this._p.then(() => w(this, void 0, void 0, function* () {
+			if (!this._c) return;
+			let e = this._libav, t = this._c, n = this._pkt, r = this._frame, i = null;
+			try {
+				i = yield e.ff_decode_multi(t, n, r, [], !0);
+			} catch (e) {
+				this._p = this._p.then(() => {
+					this._closeAudioDecoder(e);
+				});
+			}
+			i && this._outputAudioData(i);
+		}));
+		return this._p = e, e;
+	}
+	reset() {
+		this._resetAudioDecoder(new DOMException("Reset", "AbortError"));
+	}
+	close() {
+		this._closeAudioDecoder(new DOMException("Close", "AbortError"));
+	}
+	static isConfigSupported(e) {
+		return w(this, void 0, void 0, function* () {
+			let t = y(e.codec, e), n = !1;
+			if (t) {
+				let e = yield h();
+				try {
+					let [, r, i, a] = yield e.ff_init_decoder(t.codec);
+					yield e.ff_free_decoder(r, i, a), n = !0;
+				} catch {}
+				yield g(e);
+			}
+			return {
+				supported: n,
+				config: C(e, [
+					"codec",
+					"sampleRate",
+					"numberOfChannels"
+				])
+			};
+		});
+	}
+}, E = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+}, D = class extends o {
+	constructor(e) {
+		super(), this._outputMetadata = null, this._outputMetadataFilled = !1, this._pts = null, this._p = Promise.all([]), this._libav = null, this._codec = this._c = this._frame = this._pkt = 0, this._filter_in_ctx = this._filter_out_ctx = null, this._filter_graph = this._buffersrc_ctx = this._buffersink_ctx = 0, this._output = e.output, this._error = e.error, this.state = "unconfigured", this.encodeQueueSize = 0;
+	}
+	configure(e) {
+		let t = this;
+		if (this.state === "closed") throw new DOMException("Encoder is closed", "InvalidStateError");
+		this._libav && (this._p = this._p.then(() => this._free())), this.state = "configured", this._p = this._p.then(function() {
+			return E(this, void 0, void 0, function* () {
+				let n = b(e.codec, e);
+				if (t._outputMetadata = { decoderConfig: {
+					codec: e.codec,
+					sampleRate: 0,
+					numberOfChannels: 0
+				} }, t._outputMetadataFilled = !1, !n) {
+					t._closeAudioEncoder(new DOMException("Unsupported codec", "NotSupportedError"));
+					return;
+				}
+				let r = t._libav = yield h(), i;
+				[t._codec, t._c, t._frame, t._pkt, i] = yield r.ff_init_encoder(n.codec, n), t._pts = null, yield r.AVCodecContext_time_base_s(t._c, 1, n.ctx.sample_rate), t._filter_out_ctx = {
+					sample_rate: n.ctx.sample_rate,
+					sample_fmt: n.ctx.sample_fmt,
+					channel_layout: n.ctx.channel_layout,
+					frame_size: i
+				};
+			});
+		}).catch(this._error);
+	}
+	_free() {
+		return E(this, void 0, void 0, function* () {
+			this._filter_graph &&= (yield this._libav.avfilter_graph_free_js(this._filter_graph), this._filter_in_ctx = this._filter_out_ctx = null, this._buffersrc_ctx = this._buffersink_ctx = 0), this._c && (yield this._libav.ff_free_encoder(this._c, this._frame, this._pkt), this._codec = this._c = this._frame = this._pkt = 0), this._libav &&= (g(this._libav), null);
+		});
+	}
+	_closeAudioEncoder(e) {
+		this._resetAudioEncoder(e), this.state = "closed", this._p = this._p.then(() => this._free()), e.name !== "AbortError" && (this._p = this._p.then(() => {
+			this._error(e);
+		}));
+	}
+	_resetAudioEncoder(e) {
+		if (this.state === "closed") throw new DOMException("Encoder closed", "InvalidStateError");
+		this.state = "unconfigured", this._p = this._p.then(() => this._free());
+	}
+	encode(e) {
+		if (e._libavGetData() === null) throw TypeError("Detached");
+		if (this.state !== "configured") throw new DOMException("Unconfigured", "InvalidStateError");
+		let t = e.clone();
+		this.encodeQueueSize++, this._p = this._p.then(() => E(this, void 0, void 0, function* () {
+			let e = this._libav, n = this._c, r = this._pkt, a = this._frame, o = null;
+			this.encodeQueueSize--, this.dispatchEvent(new CustomEvent("dequeue"));
+			try {
+				let s = t._libavGetData(), c = t.numberOfFrames;
+				if (!i(t.format)) {
+					let e = [];
+					for (let n = 0; n < t.numberOfChannels; n++) e.push(s.subarray(n * c, (n + 1) * c));
+					s = e;
+				}
+				let l;
+				switch (t.format) {
+					case "u8":
+						l = e.AV_SAMPLE_FMT_U8;
+						break;
+					case "s16":
+						l = e.AV_SAMPLE_FMT_S16;
+						break;
+					case "s32":
+						l = e.AV_SAMPLE_FMT_S32;
+						break;
+					case "f32":
+						l = e.AV_SAMPLE_FMT_FLT;
+						break;
+					case "u8-planar":
+						l = e.AV_SAMPLE_FMT_U8P;
+						break;
+					case "s16-planar":
+						l = e.AV_SAMPLE_FMT_S16P;
+						break;
+					case "s32-planar":
+						l = e.AV_SAMPLE_FMT_S32P;
+						break;
+					case "f32-planar":
+						l = e.AV_SAMPLE_FMT_FLTP;
+						break;
+					default: throw TypeError("Invalid AudioSampleFormat");
+				}
+				let u = Math.floor(t.timestamp / 1e3), [d, f] = e.f64toi64(u), p = t.numberOfChannels, m = p === 1 ? 4 : (1 << p) - 1, h = t.sampleRate, g = {
+					data: s,
+					format: l,
+					pts: d,
+					ptshi: f,
+					channel_layout: m,
+					sample_rate: h
+				}, _ = null;
+				if (this._filter_in_ctx) {
+					let t = this._filter_in_ctx;
+					if (t.sample_fmt !== g.format || t.channel_layout !== g.channel_layout || t.sample_rate !== g.sample_rate) {
+						let t = yield this._filter([], !0);
+						t = t.filter((e) => {
+							let t;
+							return t = e.data[0].length ? e.data[0].length : e.data.length / e.channels, t === this._filter_out_ctx.frame_size;
+						}), t.length && (_ = yield e.ff_encode_multi(n, a, r, t)), yield e.avfilter_graph_free_js(this._filter_graph), this._filter_in_ctx = null, this._filter_graph = this._buffersrc_ctx = this._buffersink_ctx = 0;
+					}
+				}
+				if (!this._filter_graph) {
+					let t = this._filter_in_ctx = {
+						sample_rate: g.sample_rate,
+						sample_fmt: g.format,
+						channel_layout: g.channel_layout
+					};
+					[this._filter_graph, this._buffersrc_ctx, this._buffersink_ctx] = yield e.ff_init_filter_graph("aresample", t, this._filter_out_ctx);
+				}
+				let v = yield this._filter([g]);
+				o = yield e.ff_encode_multi(n, a, r, v), _ && (o = _.concat(o)), o.length && !this._outputMetadataFilled && v && v.length && (yield this._getOutputMetadata(v[0]));
+			} catch (e) {
+				this._p = this._p.then(() => {
+					this._closeAudioEncoder(e);
+				});
+			}
+			o && this._outputEncodedAudioChunks(o);
+		})).catch(this._error);
+	}
+	_filter(e, t = !1) {
+		return E(this, void 0, void 0, function* () {
+			e.length && this._pts === null && (this._pts = e[0].pts || 0);
+			let n = yield this._libav.ff_filter_multi(this._buffersrc_ctx, this._buffersink_ctx, this._frame, e, t);
+			for (let e of n) e.pts = this._pts, e.ptshi = 0, this._pts += e.nb_samples;
+			return n;
+		});
+	}
+	_getOutputMetadata(e) {
+		return E(this, void 0, void 0, function* () {
+			let t = this._libav, n = this._c, r = yield t.AVCodecContext_extradata(n), i = yield t.AVCodecContext_extradata_size(n), a = null;
+			r && i && (a = yield t.copyout_u8(r, i)), this._outputMetadata.decoderConfig.sampleRate = e.sample_rate, this._outputMetadata.decoderConfig.numberOfChannels = e.channels, a && (this._outputMetadata.decoderConfig.description = a), this._outputMetadataFilled = !0;
+		});
+	}
+	_outputEncodedAudioChunks(t) {
+		let n = this._libav, r = this._filter_out_ctx.sample_rate;
+		for (let i of t) {
+			let t = i.data, a = i.flags & 1 ? "key" : "delta", o = n.i64tof64(i.pts, i.ptshi);
+			o = Math.floor(o / r * 1e6);
+			let s;
+			i.duration !== void 0 && (s = n.i64tof64(i.duration, i.durationhi || 0), s = Math.floor(s / r * 1e6));
+			let c = new e({
+				data: t,
+				type: a,
+				timestamp: o,
+				duration: s
+			});
+			this._outputMetadataFilled ? this._output(c, this._outputMetadata || void 0) : this._output(c);
+		}
+	}
+	flush() {
+		if (this.state !== "configured") throw new DOMException("Invalid state", "InvalidStateError");
+		let e = this._p.then(() => E(this, void 0, void 0, function* () {
+			if (!this._c) return;
+			let e = this._libav, t = this._c, n = this._frame, r = this._pkt, i = this._buffersrc_ctx;
+			this._buffersink_ctx;
+			let a = null;
+			try {
+				let o = null;
+				i && (o = yield this._filter([], !0)), a = yield e.ff_encode_multi(t, n, r, o || [], !0), !this._outputMetadataFilled && o && o.length && (yield this._getOutputMetadata(o[0]));
+			} catch (e) {
+				this._p = this._p.then(() => {
+					this._closeAudioEncoder(e);
+				});
+			}
+			a && this._outputEncodedAudioChunks(a);
+		}));
+		return this._p = e, e;
+	}
+	reset() {
+		this._resetAudioEncoder(new DOMException("Reset", "AbortError"));
+	}
+	close() {
+		this._closeAudioEncoder(new DOMException("Close", "AbortError"));
+	}
+	static isConfigSupported(e) {
+		return E(this, void 0, void 0, function* () {
+			let t = b(e.codec, e), n = !1;
+			if (t) {
+				let e = yield h();
+				try {
+					let [, r, i, a] = yield e.ff_init_encoder(t.codec, t);
+					yield e.ff_free_encoder(r, i, a), n = !0;
+				} catch {}
+				yield g(e);
+			}
+			return {
+				supported: n,
+				config: C(e, [
+					"codec",
+					"sampleRate",
+					"numberOfChannels",
+					"bitrate"
+				])
+			};
+		});
+	}
+}, O = e, k = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+}, A = null, j = class e {
+	constructor(t, n) {
+		if (this.format = "I420", this.codedWidth = 0, this.codedHeight = 0, this.codedRect = null, this.visibleRect = null, this.displayWidth = 0, this.displayHeight = 0, this.timestamp = 0, this._layout = null, this._data = null, this._nonSquarePixels = !1, this._sar_num = 1, this._sar_den = 1, t instanceof ArrayBuffer || t.buffer instanceof ArrayBuffer) this._constructBuffer(t, n);
+		else if (t instanceof e || globalThis.VideoFrame && t instanceof globalThis.VideoFrame) {
+			let e = new Uint8Array(t.allocationSize());
+			t.copyTo(e), this._constructBuffer(e, {
+				transfer: [e.buffer],
+				format: t.format,
+				codedHeight: t.codedHeight,
+				codedWidth: t.codedWidth,
+				colorSpace: t.colorSpace,
+				visibleRect: n?.visibleRect || t.visibleRect,
+				displayHeight: n?.displayHeight || t.displayHeight,
+				displayWidth: n?.displayWidth || t.displayWidth,
+				duration: n?.duration || t.duration,
+				timestamp: n?.timestamp || t.timestamp,
+				metadata: JSON.parse(JSON.stringify(n?.metadata))
+			});
+		} else if (t instanceof HTMLVideoElement) {
+			if (t.readyState === HTMLVideoElement.prototype.HAVE_NOTHING || t.readyState === HTMLVideoElement.prototype.HAVE_METADATA) throw new DOMException("Video is not ready for reading frames", "InvalidStateError");
+			if (t.networkState === t.NETWORK_EMPTY) throw new DOMException("Video network state is empty", "InvalidStateError");
+			this._constructCanvas(t, Object.assign(Object.assign({}, n), { timestamp: n?.timestamp || t.currentTime * 1e6 }));
+		} else this._constructCanvas(t, n);
+	}
+	_constructCanvas(e, t) {
+		let n = 0, r = 0;
+		if (e.naturalWidth ? (n = e.naturalWidth, r = e.naturalHeight) : e.videoWidth ? (n = e.videoWidth, r = e.videoHeight) : e.width && (n = e.width, r = e.height), !n || !r) throw new DOMException("Could not determine dimensions", "InvalidStateError");
+		A === null && (typeof OffscreenCanvas < "u" ? A = new OffscreenCanvas(n, r) : (A = document.createElement("canvas"), A.style.display = "none", document.body.appendChild(A))), A.width = n, A.height = r;
+		let i = A.getContext("2d", {
+			desynchronized: !0,
+			willReadFrequently: !0
+		});
+		i.clearRect(0, 0, n, r), i.drawImage(e, 0, 0), this._constructBuffer(i.getImageData(0, 0, n, r).data, {
+			format: "RGBA",
+			codedWidth: n,
+			codedHeight: r,
+			timestamp: t?.timestamp || 0,
+			duration: t?.duration || 0,
+			layout: [{
+				offset: 0,
+				stride: n * 4
+			}],
+			displayWidth: t?.displayWidth || n,
+			displayHeight: t?.displayHeight || r
+		});
+	}
+	_constructBuffer(t, n) {
+		e._checkValidVideoFrameBufferInit(n);
+		let r = new DOMRect(0, 0, n.codedWidth, n.codedHeight), i;
+		n.visibleRect && (i = DOMRect.fromRect(n.visibleRect)), this.codedWidth = n.codedWidth, this.codedHeight = n.codedHeight;
+		let a = this._parseVisibleRect(r, i || null), o;
+		n.layout && (o = n.layout instanceof Array ? n.layout : Array.from(n.layout)), this.format = n.format;
+		let s = this._computeLayoutAndAllocationSize(a, o || null);
+		if (t.byteLength < s.allocationSize) throw TypeError("data is too small for layout");
+		let c = !1;
+		if (n.transfer) {
+			let e;
+			e = t.buffer ? t.buffer : t;
+			let r;
+			r = n.transfer instanceof Array ? n.transfer : Array.from(n.transfer);
+			for (let t of r) if (t === e) {
+				c = !0;
+				break;
+			}
+		}
+		let l = n.format;
+		if (n.layout) n.layout instanceof Array ? this._layout = n.layout : this._layout = Array.from(n.layout);
+		else {
+			let e = N(l), t = [], n = 0;
+			for (let r = 0; r < e; r++) {
+				let e = F(l, r), i = I(l, r), a = ~~(this.codedWidth / e);
+				t.push({
+					offset: n,
+					stride: a
+				}), n += a * ~~(this.codedHeight / i);
+			}
+			this._layout = t;
+		}
+		if (this._data = new Uint8Array(t.buffer || t, t.byteOffset || 0), !c) {
+			let e = N(l), t = this._layout, n = Infinity, r = 0;
+			for (let i = 0; i < e; i++) {
+				let e = t[i], a = e.offset;
+				a < n && (n = a);
+				let o = I(l, i);
+				a += e.stride * ~~(this.codedHeight / o), a > r && (r = a);
+			}
+			n !== 0 && (t = this._layout = t.map((e) => ({
+				offset: e.offset - n,
+				stride: e.stride
+			}))), this._data = this._data.slice(n, r);
+		}
+		let u = n.codedWidth, d = n.codedHeight;
+		a.left, a.top, this.codedRect = new DOMRect(0, 0, u, d), this.visibleRect = a, n.visibleRect ? this.visibleRect = DOMRect.fromRect(n.visibleRect) : this.visibleRect = new DOMRect(0, 0, u, d), typeof n.displayWidth == "number" ? this.displayWidth = n.displayWidth : this.displayWidth = this.visibleRect.width, typeof n.displayHeight == "number" ? this.displayHeight = n.displayHeight : this.displayHeight = this.visibleRect.height, this.displayWidth !== this.visibleRect.width || this.displayHeight !== this.visibleRect.height ? (this._nonSquarePixels = !0, this._sar_num = this.displayWidth * this.visibleRect.width, this._sar_den = this.displayHeight * this.visibleRect.height) : (this._nonSquarePixels = !1, this._sar_num = this._sar_den = 1), this.timestamp = n.timestamp, this.duration = n.duration;
+	}
+	toNative(e = {}) {
+		let t = new globalThis.VideoFrame(this._data, {
+			layout: this._layout,
+			format: this.format,
+			codedWidth: this.codedWidth,
+			codedHeight: this.codedHeight,
+			visibleRect: this.visibleRect,
+			displayWidth: this.displayWidth,
+			displayHeight: this.displayHeight,
+			duration: this.duration,
+			timestamp: this.timestamp,
+			transfer: e.transfer ? [this._data.buffer] : []
+		});
+		return e.transfer && this.close(), t;
+	}
+	static fromNative(t) {
+		let n = t, r = new Uint8Array(n.allocationSize());
+		return n.copyTo(r), new e(r, {
+			format: n.format,
+			codedWidth: n.codedWidth,
+			codedHeight: n.codedHeight,
+			visibleRect: n.visibleRect,
+			displayWidth: n.displayWidth,
+			displayHeight: n.displayHeight,
+			duration: n.duration,
+			timestamp: n.timestamp
+		});
+	}
+	_libavGetData() {
+		return this._data;
+	}
+	_libavGetLayout() {
+		return this._layout;
+	}
+	static _checkValidVideoFrameBufferInit(e) {
+		if (!e.codedWidth || !e.codedHeight) throw TypeError("Invalid coded dimensions");
+		if (e.visibleRect) {
+			let t = DOMRect.fromRect(e.visibleRect);
+			if (t.x < 0 || !Number.isFinite(t.x) || t.y < 0 || !Number.isFinite(t.y) || t.width < 0 || !Number.isFinite(t.width) || t.height < 0 || !Number.isFinite(t.height)) throw TypeError("Invalid visible rectangle");
+			if (t.y + t.height > e.codedHeight) throw TypeError("Visible rectangle outside of coded height");
+			if (t.x + t.width > e.codedWidth) throw TypeError("Visible rectangle outside of coded width");
+			if (e.displayWidth && !e.displayHeight || !e.displayWidth && !e.displayHeight || e.displayWidth === 0 || e.displayHeight === 0) throw TypeError("Invalid display dimensions");
+		}
+	}
+	metadata() {
+		if (this._data === null) throw new DOMException("Detached", "InvalidStateError");
+		return null;
+	}
+	allocationSize(e = {}) {
+		if (this._data === null) throw new DOMException("Detached", "InvalidStateError");
+		if (this.format === null) throw new DOMException("Not supported", "NotSupportedError");
+		return this._parseVideoFrameCopyToOptions(e).allocationSize;
+	}
+	_parseVideoFrameCopyToOptions(e) {
+		let t = this.visibleRect, n = e.rect ? new DOMRect(e.rect.x, e.rect.y, e.rect.width, e.rect.height) : null, r = this._parseVisibleRect(t, n), i = null;
+		return e.layout && (i = e.layout instanceof Array ? e.layout : Array.from(e.layout)), this._computeLayoutAndAllocationSize(r, i);
+	}
+	_parseVisibleRect(e, t) {
+		let n = e;
+		if (t) {
+			if (t.width === 0 || t.height === 0 || t.x + t.width > this.codedWidth || t.y + t.height > this.codedHeight) throw TypeError("Invalid rectangle");
+			n = t;
+		}
+		if (!this._verifyRectOffsetAlignment(n)) throw TypeError("Invalid alignment");
+		return n;
+	}
+	_computeLayoutAndAllocationSize(e, t) {
+		let n = N(this.format);
+		if (t && t.length !== n) throw TypeError("Invalid layout");
+		let r = 0, i = [], a = [], o = 0;
+		for (; o < n;) {
+			let n = P(this.format, o), s = F(this.format, o), c = I(this.format, o), l = {
+				destinationOffset: 0,
+				destinationStride: 0,
+				sourceTop: Math.ceil(~~e.y / c),
+				sourceHeight: Math.ceil(~~e.height / c),
+				sourceLeftBytes: ~~(e.x / s * n),
+				sourceWidthBytes: ~~(e.width / s * n)
+			};
+			if (t) {
+				let e = t[o];
+				if (e.stride < l.sourceWidthBytes) throw TypeError("Invalid stride");
+				l.destinationOffset = e.offset, l.destinationStride = e.stride;
+			} else l.destinationOffset = r, l.destinationStride = l.sourceWidthBytes;
+			let u = l.destinationStride * l.sourceHeight, d = u + l.destinationOffset;
+			if (u >= 4294967296 || d >= 4294967296) throw TypeError("Plane too large");
+			a.push(d), d > r && (r = d);
+			let f = 0;
+			for (; f < o;) {
+				if (!(d <= i[f].destinationOffset || a[f] <= l.destinationOffset)) throw TypeError("Invalid plane layout");
+				f++;
+			}
+			i.push(l), o++;
+		}
+		return {
+			computedLayouts: i,
+			allocationSize: r
+		};
+	}
+	_verifyRectOffsetAlignment(e) {
+		if (!this.format) return !0;
+		let t = 0, n = N(this.format);
+		for (; t < n;) {
+			let n = F(this.format, t), r = I(this.format, t), i = e.x / n;
+			if (i !== ~~i) return !1;
+			let a = e.y / r;
+			if (a !== ~~a) return !1;
+			t++;
+		}
+		return !0;
+	}
+	copyTo(e, t = {}) {
+		return k(this, void 0, void 0, function* () {
+			let n = new Uint8Array(e.buffer || e, e.byteOffset || 0);
+			if (this._data === null) throw new DOMException("Detached", "InvalidStateError");
+			if (!this.format) throw new DOMException("No format", "NotSupportedError");
+			let r = this._parseVideoFrameCopyToOptions(t);
+			if (e.byteLength < r.allocationSize) throw TypeError("Insufficient space");
+			let i = [];
+			{
+				N(this.format);
+				let e = 0;
+				for (; e < r.computedLayouts.length;) {
+					let t = this._layout[e].stride, a = r.computedLayouts[e], o = a.sourceTop * t;
+					o += a.sourceLeftBytes;
+					let s = a.destinationOffset, c = a.sourceWidthBytes, l = {
+						offset: a.destinationOffset,
+						stride: a.destinationStride
+					}, u = 0;
+					for (; u < a.sourceHeight;) n.set(this._data.subarray(o, o + c), s), o += t, s += a.destinationStride, u++;
+					e++, i.push(l);
+				}
+			}
+			return i;
+		});
+	}
+	clone() {
+		return new e(this._data, {
+			format: this.format,
+			codedWidth: this.codedWidth,
+			codedHeight: this.codedHeight,
+			timestamp: this.timestamp,
+			duration: this.duration,
+			layout: this._layout,
+			transfer: [this._data.buffer]
+		});
+	}
+	close() {
+		this._data = null;
+	}
+};
+function M(e, t) {
+	let n = e.AV_PIX_FMT_RGBA;
+	switch (t) {
+		case "I420":
+			n = e.AV_PIX_FMT_YUV420P;
+			break;
+		case "I420P10":
+			n = 62;
+			break;
+		case "I420P12":
+			n = 123;
+			break;
+		case "I420A":
+			n = e.AV_PIX_FMT_YUVA420P;
+			break;
+		case "I420AP10":
+			n = 87;
+			break;
+		case "I420AP12": throw TypeError("YUV420P12 is not supported by libav");
+		case "I422":
+			n = e.AV_PIX_FMT_YUV422P;
+			break;
+		case "I422P10":
+			n = 64;
+			break;
+		case "I422P12":
+			n = 127;
+			break;
+		case "I422A":
+			n = 78;
+			break;
+		case "I422AP10":
+			n = 89;
+			break;
+		case "I422AP10":
+			n = 186;
+			break;
+		case "I444":
+			n = e.AV_PIX_FMT_YUV444P;
+			break;
+		case "I444P10":
+			n = 68;
+			break;
+		case "I444P12":
+			n = 131;
+			break;
+		case "I444A":
+			n = 79;
+			break;
+		case "I444AP10":
+			n = 91;
+			break;
+		case "I444AP12":
+			n = 188;
+			break;
+		case "NV12":
+			n = e.AV_PIX_FMT_NV12;
+			break;
+		case "RGBA":
+			n = e.AV_PIX_FMT_RGBA;
+			break;
+		case "RGBX":
+			n = 119;
+			break;
+		case "BGRA":
+			n = e.AV_PIX_FMT_BGRA;
+			break;
+		case "BGRX":
+			n = 121;
+			break;
+		default: throw TypeError("Invalid VideoPixelFormat");
+	}
+	return n;
+}
+function N(e) {
+	switch (e) {
+		case "I420":
+		case "I420P10":
+		case "I420P12":
+		case "I422":
+		case "I422P10":
+		case "I422P12":
+		case "I444":
+		case "I444P10":
+		case "I444P12": return 3;
+		case "I420A":
+		case "I420AP10":
+		case "I420AP12":
+		case "I422A":
+		case "I422AP10":
+		case "I422AP12":
+		case "I444A":
+		case "I444AP10":
+		case "I444AP12": return 4;
+		case "NV12": return 2;
+		case "RGBA":
+		case "RGBX":
+		case "BGRA":
+		case "BGRX": return 1;
+		default: throw new DOMException("Unsupported video pixel format", "NotSupportedError");
+	}
+}
+function P(e, t) {
+	switch (e) {
+		case "I420":
+		case "I420A":
+		case "I422":
+		case "I422A":
+		case "I444":
+		case "I444A": return 1;
+		case "I420P10":
+		case "I420AP10":
+		case "I422P10":
+		case "I422AP10":
+		case "I444P10":
+		case "I444AP10":
+		case "I420P12":
+		case "I420AP12":
+		case "I422P12":
+		case "I422AP12":
+		case "I444P12":
+		case "I444AP12": return 2;
+		case "NV12": return t === 1 ? 2 : 1;
+		case "RGBA":
+		case "RGBX":
+		case "BGRA":
+		case "BGRX": return 4;
+		default: throw new DOMException("Unsupported video pixel format", "NotSupportedError");
+	}
+}
+function F(e, t) {
+	if (t === 0 || t === 3) return 1;
+	switch (e) {
+		case "I420":
+		case "I420P10":
+		case "I420P12":
+		case "I420A":
+		case "I420AP10":
+		case "I420AP12":
+		case "I422":
+		case "I422P10":
+		case "I422P12":
+		case "I422A":
+		case "I422AP10":
+		case "I422AP12": return 2;
+		case "I444":
+		case "I444P10":
+		case "I444P12":
+		case "I444A":
+		case "I444AP10":
+		case "I444AP12": return 1;
+		case "NV12": return 2;
+		case "RGBA":
+		case "RGBX":
+		case "BGRA":
+		case "BGRX": return 1;
+		default: throw new DOMException("Unsupported video pixel format", "NotSupportedError");
+	}
+}
+function I(e, t) {
+	if (t === 0 || t === 3) return 1;
+	switch (e) {
+		case "I420":
+		case "I420P10":
+		case "I420P12":
+		case "I420A":
+		case "I420AP10":
+		case "I420AP12": return 2;
+		case "I422":
+		case "I422P10":
+		case "I422P12":
+		case "I422A":
+		case "I422AP10":
+		case "I422AP12":
+		case "I444":
+		case "I444P10":
+		case "I444P12":
+		case "I444A":
+		case "I444AP10":
+		case "I444AP12": return 1;
+		case "NV12": return 2;
+		case "RGBA":
+		case "RGBX":
+		case "BGRA":
+		case "BGRX": return 1;
+		default: throw new DOMException("Unsupported video pixel format", "NotSupportedError");
+	}
+}
+//#endregion
+//#region ../../node_modules/@kixelated/libavjs-webcodecs-polyfill/dist/video-decoder.js
+var L = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+}, R = class extends o {
+	constructor(e) {
+		super(), this._p = Promise.all([]), this._libav = null, this._codec = this._c = this._pkt = this._frame = 0, this._output = e.output, this._error = e.error, this.state = "unconfigured", this.decodeQueueSize = 0;
+	}
+	configure(e) {
+		if (this.state === "closed") throw new DOMException("Decoder is closed", "InvalidStateError");
+		this._libav && (this._p = this._p.then(() => this._free())), this.state = "configured", this._p = this._p.then(() => L(this, void 0, void 0, function* () {
+			let t = y(e.codec, e);
+			if (!t) {
+				this._closeVideoDecoder(new DOMException("Unsupported codec", "NotSupportedError"));
+				return;
+			}
+			let n = this._libav = yield h();
+			[this._codec, this._c, this._pkt, this._frame] = yield n.ff_init_decoder(t.codec), yield n.AVCodecContext_time_base_s(this._c, 1, 1e3);
+		})).catch(this._error);
+	}
+	_free() {
+		return L(this, void 0, void 0, function* () {
+			this._c && (yield this._libav.ff_free_decoder(this._c, this._pkt, this._frame), this._codec = this._c = this._pkt = this._frame = 0), this._libav &&= (g(this._libav), null);
+		});
+	}
+	_closeVideoDecoder(e) {
+		this._resetVideoDecoder(e), this.state = "closed", this._p = this._p.then(() => this._free()), e.name !== "AbortError" && (this._p = this._p.then(() => {
+			this._error(e);
+		}));
+	}
+	_resetVideoDecoder(e) {
+		if (this.state === "closed") throw new DOMException("Decoder closed", "InvalidStateError");
+		this.state = "unconfigured", this._p = this._p.then(() => this._free());
+	}
+	decode(e) {
+		let t = this;
+		if (this.state !== "configured") throw new DOMException("Unconfigured", "InvalidStateError");
+		this.decodeQueueSize++, this._p = this._p.then(function() {
+			return L(this, void 0, void 0, function* () {
+				let n = t._libav, r = t._c, i = t._pkt, a = t._frame, o = null;
+				t.decodeQueueSize--, t.dispatchEvent(new CustomEvent("dequeue"));
+				try {
+					let t = Math.floor(e.timestamp / 1e3), [s, c] = n.f64toi64(t), l = {
+						data: e._libavGetData(),
+						pts: s,
+						ptshi: c,
+						dts: s,
+						dtshi: c
+					};
+					e.duration && (l.duration = Math.floor(e.duration / 1e3), l.durationhi = 0), o = yield n.ff_decode_multi(r, i, a, [l]);
+				} catch (e) {
+					t._p = t._p.then(() => {
+						t._closeVideoDecoder(e);
+					});
+				}
+				o && t._outputVideoFrames(o);
+			});
+		}).catch(this._error);
+	}
+	_outputVideoFrames(e) {
+		let t = this._libav;
+		for (let n of e) {
+			let e;
+			switch (n.format) {
+				case t.AV_PIX_FMT_YUV420P:
+					e = "I420";
+					break;
+				case 62:
+					e = "I420P10";
+					break;
+				case 123:
+					e = "I420P12";
+					break;
+				case t.AV_PIX_FMT_YUVA420P:
+					e = "I420A";
+					break;
+				case 87:
+					e = "I420AP10";
+					break;
+				case t.AV_PIX_FMT_YUV422P:
+					e = "I422";
+					break;
+				case 64:
+					e = "I422P10";
+					break;
+				case 127:
+					e = "I422P12";
+					break;
+				case 78:
+					e = "I422A";
+					break;
+				case 89:
+					e = "I422AP10";
+					break;
+				case 186:
+					e = "I422AP12";
+					break;
+				case t.AV_PIX_FMT_YUV444P:
+					e = "I444";
+					break;
+				case 68:
+					e = "I444P10";
+					break;
+				case 131:
+					e = "I444P12";
+					break;
+				case 79:
+					e = "I444A";
+					break;
+				case 91:
+					e = "I444AP10";
+					break;
+				case 188:
+					e = "I444AP12";
+					break;
+				case t.AV_PIX_FMT_NV12:
+					e = "NV12";
+					break;
+				case t.AV_PIX_FMT_RGBA:
+					e = "RGBA";
+					break;
+				case 119:
+					e = "RGBX";
+					break;
+				case t.AV_PIX_FMT_BGRA:
+					e = "BGRA";
+					break;
+				case 121:
+					e = "BGRX";
+					break;
+				default: throw new DOMException("Unsupported libav format!", "EncodingError");
+			}
+			let r = n.width, i = n.height, a;
+			a = n.crop ? new DOMRect(n.crop.left, n.crop.top, r - n.crop.left - n.crop.right, i - n.crop.top - n.crop.bottom) : new DOMRect(0, 0, r, i);
+			let o = r, s = i;
+			if (n.sample_aspect_ratio && n.sample_aspect_ratio[0]) {
+				let e = n.sample_aspect_ratio;
+				e[0] > e[1] ? o = ~~(r * e[0] / e[1]) : s = ~~(i * e[1] / e[0]);
+			}
+			let c = t.i64tof64(n.pts, n.ptshi) * 1e3, l = new j(n.data, {
+				layout: n.layout,
+				format: e,
+				codedWidth: r,
+				codedHeight: i,
+				visibleRect: a,
+				displayWidth: o,
+				displayHeight: s,
+				timestamp: c
+			});
+			this._output(l);
+		}
+	}
+	flush() {
+		if (this.state !== "configured") throw new DOMException("Invalid state", "InvalidStateError");
+		let e = this._p.then(() => L(this, void 0, void 0, function* () {
+			if (!this._c) return;
+			let e = this._libav, t = this._c, n = this._pkt, r = this._frame, i = null;
+			try {
+				i = yield e.ff_decode_multi(t, n, r, [], !0);
+			} catch (e) {
+				this._p = this._p.then(() => {
+					this._closeVideoDecoder(e);
+				});
+			}
+			i && this._outputVideoFrames(i);
+		}));
+		return this._p = e, e;
+	}
+	reset() {
+		this._resetVideoDecoder(new DOMException("Reset", "AbortError"));
+	}
+	close() {
+		this._closeVideoDecoder(new DOMException("Close", "AbortError"));
+	}
+	static isConfigSupported(e) {
+		return L(this, void 0, void 0, function* () {
+			let t = y(e.codec, e), n = !1;
+			if (t) {
+				let e = yield h();
+				try {
+					let [, r, i, a] = yield e.ff_init_decoder(t.codec);
+					yield e.ff_free_decoder(r, i, a), n = !0;
+				} catch {}
+				yield g(e);
+			}
+			return {
+				supported: n,
+				config: C(e, [
+					"codec",
+					"codedWidth",
+					"codedHeight"
+				])
+			};
+		});
+	}
+}, z = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+}, B = class extends o {
+	constructor(e) {
+		super(), this._extradataSet = !1, this._extradata = null, this._nonSquarePixels = !1, this._sar_num = 1, this._sar_den = 1, this._p = Promise.all([]), this._libav = null, this._codec = this._c = this._frame = this._pkt = 0, this._output = e.output, this._error = e.error, this._metadata = null, this.state = "unconfigured", this.encodeQueueSize = 0;
+	}
+	configure(e) {
+		if (this.state === "closed") throw new DOMException("Encoder is closed", "InvalidStateError");
+		this._libav && (this._p = this._p.then(() => this._free())), this.state = "configured", this._p = this._p.then(() => z(this, void 0, void 0, function* () {
+			let t = b(e.codec, e);
+			if (!t) {
+				this._closeVideoEncoder(new DOMException("Unsupported codec", "NotSupportedError"));
+				return;
+			}
+			let n = this._libav = yield h();
+			this._metadata = { decoderConfig: { codec: t.codec } }, [this._codec, this._c, this._frame, this._pkt] = yield n.ff_init_encoder(t.codec, t), this._extradataSet = !1, this._extradata = null, yield n.AVCodecContext_time_base_s(this._c, 1, 1e3);
+			let r = e.width, i = e.height;
+			this._sws = 0, this._swsFrame = 0, this._swsOut = {
+				width: r,
+				height: i,
+				format: t.ctx.pix_fmt
+			};
+			let a = e.displayWidth || r, o = e.displayHeight || i;
+			a !== r || o !== i ? (this._nonSquarePixels = !0, this._sar_num = a * i, this._sar_den = o * r) : this._nonSquarePixels = !1;
+		})).catch(this._error);
+	}
+	_free() {
+		return z(this, void 0, void 0, function* () {
+			this._sws && (yield this._libav.av_frame_free_js(this._swsFrame), yield this._libav.sws_freeContext(this._sws), this._sws = this._swsFrame = 0, this._swsIn = this._swsOut = void 0), this._c && (yield this._libav.ff_free_encoder(this._c, this._frame, this._pkt), this._codec = this._c = this._frame = this._pkt = 0), this._libav &&= (g(this._libav), null);
+		});
+	}
+	_closeVideoEncoder(e) {
+		this._resetVideoEncoder(e), this.state = "closed", this._p = this._p.then(() => this._free()), e.name !== "AbortError" && (this._p = this._p.then(() => {
+			this._error(e);
+		}));
+	}
+	_resetVideoEncoder(e) {
+		if (this.state === "closed") throw new DOMException("Encoder closed", "InvalidStateError");
+		this.state = "unconfigured", this._p = this._p.then(() => this._free());
+	}
+	encode(e, t = {}) {
+		if (e._libavGetData() === null) throw TypeError("Detached");
+		if (this.state !== "configured") throw new DOMException("Unconfigured", "InvalidStateError");
+		let n = e.clone();
+		this.encodeQueueSize++, this._p = this._p.then(() => z(this, void 0, void 0, function* () {
+			let e = this._libav, r = this._c, i = this._pkt, a = this._frame, o = this._swsOut, s = null;
+			this.encodeQueueSize--, this.dispatchEvent(new CustomEvent("dequeue"));
+			try {
+				let c = M(e, n.format), l = n._libavGetData(), u = n._libavGetLayout(), d = Math.floor(n.timestamp / 1e3), [f, p] = e.f64toi64(d), m = {
+					data: l,
+					layout: u,
+					format: c,
+					pts: f,
+					ptshi: p,
+					width: n.codedWidth,
+					height: n.codedHeight,
+					crop: {
+						left: n.visibleRect.left,
+						right: n.visibleRect.right,
+						top: n.visibleRect.top,
+						bottom: n.visibleRect.bottom
+					},
+					key_frame: +!!t.keyFrame,
+					pict_type: +!!t.keyFrame
+				};
+				if (m.width !== o.width || m.height !== o.height || m.format !== o.format) {
+					n._nonSquarePixels && (m.sample_aspect_ratio = [n._sar_num, n._sar_den]);
+					let c = this._sws, l = this._swsIn, u = this._swsFrame;
+					(!c || m.width !== l.width || m.height !== l.height || m.format !== l.format) && (c && (yield e.sws_freeContext(c)), l = {
+						width: m.width,
+						height: m.height,
+						format: m.format
+					}, c = yield e.sws_getContext(l.width, l.height, l.format, o.width, o.height, o.format, 2, 0, 0, 0), this._sws = c, this._swsIn = l, u || (this._swsFrame = u = yield e.av_frame_alloc()));
+					let [, d, , , , , , h] = yield Promise.all([
+						e.ff_copyin_frame(a, m),
+						e.sws_scale_frame(c, u, a),
+						this._nonSquarePixels ? e.AVFrame_sample_aspect_ratio_s(u, this._sar_num, this._sar_den) : null,
+						e.AVFrame_pts_s(u, f),
+						e.AVFrame_ptshi_s(u, p),
+						e.AVFrame_key_frame_s(u, +!!t.keyFrame),
+						e.AVFrame_pict_type_s(u, +!!t.keyFrame),
+						e.avcodec_send_frame(r, u)
+					]);
+					if (d < 0 || h < 0) throw Error("Encoding failed!");
+					for (s = [];;) {
+						let t = yield e.avcodec_receive_packet(r, i);
+						if (t === -e.EAGAIN) break;
+						if (t < 0) throw Error("Encoding failed!");
+						s.push(yield e.ff_copyout_packet(i));
+					}
+				} else this._nonSquarePixels && (m.sample_aspect_ratio = [this._sar_num, this._sar_den]), s = yield e.ff_encode_multi(r, a, i, [m]);
+				s.length && !this._extradataSet && (yield this._getExtradata());
+			} catch (e) {
+				this._p = this._p.then(() => {
+					this._closeVideoEncoder(e);
+				});
+				return;
+			}
+			s && this._outputEncodedVideoChunks(s);
+		})).catch(this._error);
+	}
+	_getExtradata() {
+		return z(this, void 0, void 0, function* () {
+			let e = this._libav, t = this._c, n = yield e.AVCodecContext_extradata(t), r = yield e.AVCodecContext_extradata_size(t);
+			n && r && (this._metadata.decoderConfig.description = this._extradata = yield e.copyout_u8(n, r)), this._extradataSet = !0;
+		});
+	}
+	_outputEncodedVideoChunks(e) {
+		let t = this._libav;
+		for (let n of e) {
+			let e = new O({
+				type: n.flags & 1 ? "key" : "delta",
+				timestamp: t.i64tof64(n.pts, n.ptshi) * 1e3,
+				data: n.data
+			});
+			this._extradataSet ? this._output(e, this._metadata || void 0) : this._output(e);
+		}
+	}
+	flush() {
+		if (this.state !== "configured") throw new DOMException("Invalid state", "InvalidStateError");
+		let e = this._p.then(() => z(this, void 0, void 0, function* () {
+			if (!this._c) return;
+			let e = this._libav, t = this._c, n = this._frame, r = this._pkt, i = null;
+			try {
+				i = yield e.ff_encode_multi(t, n, r, [], !0), this._extradataSet || (yield this._getExtradata());
+			} catch (e) {
+				this._p = this._p.then(() => {
+					this._closeVideoEncoder(e);
+				});
+			}
+			i && this._outputEncodedVideoChunks(i);
+		}));
+		return this._p = e, e;
+	}
+	reset() {
+		this._resetVideoEncoder(new DOMException("Reset", "AbortError"));
+	}
+	close() {
+		this._closeVideoEncoder(new DOMException("Close", "AbortError"));
+	}
+	static isConfigSupported(e) {
+		return z(this, void 0, void 0, function* () {
+			let t = b(e.codec, e), n = !1;
+			if (t) {
+				let e = yield h();
+				try {
+					let [, r, i, a] = yield e.ff_init_encoder(t.codec, t);
+					yield e.ff_free_encoder(r, i, a), n = !0;
+				} catch {}
+				yield g(e);
+			}
+			return {
+				supported: n,
+				config: C(e, [
+					"codec",
+					"width",
+					"height",
+					"bitrate",
+					"framerate",
+					"latencyMode"
+				])
+			};
+		});
+	}
+}, V = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+}, H = null, U = null, W = null, G = null, K = null;
+function q(e, t) {
+	return V(this, void 0, void 0, function* () {
+		"importScripts" in globalThis && (c.nolibavworker = !0), H = yield c.LibAV(Object.assign(Object.assign({}, e), {
+			noworker: !0,
+			yesthreads: !1
+		})), U = yield c.LibAV(e), "CanvasRenderingContext2D" in globalThis && (W = CanvasRenderingContext2D.prototype.drawImage, t && (CanvasRenderingContext2D.prototype.drawImage = Y)), "OffscreenCanvasRenderingContext2D" in globalThis && (G = OffscreenCanvasRenderingContext2D.prototype.drawImage, t && (OffscreenCanvasRenderingContext2D.prototype.drawImage = X)), K = globalThis.createImageBitmap, t && (globalThis.createImageBitmap = Z);
+	});
+}
+function J(e, t, n, r, i, a, o, s, c, l) {
+	if (!t._data) return W.apply(e, Array.prototype.slice.call(arguments, 1));
+	i === void 0 ? (o = n, s = r) : o === void 0 && (o = n, s = r, c = i, l = a, i = void 0, a = void 0), c === void 0 && (c = t.displayWidth, l = t.displayHeight);
+	let u = M(H, t.format), d = H.sws_getContext_sync(t.visibleRect.width, t.visibleRect.height, u, c, l, H.AV_PIX_FMT_RGBA, 2, 0, 0, 0), f = H.av_frame_alloc_sync(), p = H.av_frame_alloc_sync(), m, h;
+	t._libavGetData ? (m = t._libavGetData(), h = t._libavGetLayout()) : (m = t._data, h = t._layout), H.ff_copyin_frame_sync(f, {
+		data: m,
+		layout: h,
+		format: u,
+		width: t.codedWidth,
+		height: t.codedHeight,
+		crop: {
+			left: t.visibleRect.left,
+			right: t.visibleRect.right,
+			top: t.visibleRect.top,
+			bottom: t.visibleRect.bottom
+		}
+	}), H.sws_scale_frame_sync(d, p, f);
+	let g = H.ff_copyout_frame_video_imagedata_sync(p);
+	e.putImageData(g, o, s), H.av_frame_free_js_sync(p), H.av_frame_free_js_sync(f), H.sws_freeContext_sync(d);
+}
+function Y(e, t, n, r, i, a, o, s, c) {
+	return e instanceof j ? J(this, e, t, n, r, i, a, o, s, c) : W.apply(this, arguments);
+}
+function X(e, t, n, r, i, a, o, s, c) {
+	return e instanceof j ? J(this, e, t, n, r, i, a, o, s, c) : G.apply(this, arguments);
+}
+function Z(e, t = {}) {
+	if (!e._data) return K.apply(globalThis, arguments);
+	let n = M(U, e.format), r = typeof t.resizeWidth == "number" ? t.resizeWidth : e.displayWidth, i = typeof t.resizeHeight == "number" ? t.resizeHeight : e.displayHeight;
+	return V(this, void 0, void 0, function* () {
+		let [t, a, o] = yield Promise.all([
+			U.sws_getContext(e.visibleRect.width, e.visibleRect.height, n, r, i, U.AV_PIX_FMT_RGBA, 2, 0, 0, 0),
+			U.av_frame_alloc(),
+			U.av_frame_alloc()
+		]), s, c;
+		e._libavGetData ? (s = e._libavGetData(), c = e._libavGetLayout()) : e._data ? (s = e._data, c = e._layout) : (s = new Uint8Array(e.allocationSize()), yield e.copyTo(s)), yield U.ff_copyin_frame(a, {
+			data: s,
+			layout: c,
+			format: n,
+			width: e.codedWidth,
+			height: e.codedHeight,
+			crop: {
+				left: e.visibleRect.left,
+				right: e.visibleRect.right,
+				top: e.visibleRect.top,
+				bottom: e.visibleRect.bottom
+			}
+		}), yield U.sws_scale_frame(t, o, a);
+		let l = yield U.ff_copyout_frame_video_imagedata(o);
+		return yield Promise.all([
+			U.av_frame_free_js(o),
+			U.av_frame_free_js(a),
+			U.sws_freeContext(t)
+		]), yield K(l);
+	});
+}
+//#endregion
+//#region ../../node_modules/@kixelated/libavjs-webcodecs-polyfill/dist/config.js
+var Q = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+}, $ = class extends Error {
+	constructor() {
+		super("The requested configuration is not supported");
+	}
+};
+function ee(n) {
+	return Q(this, void 0, void 0, function* () {
+		try {
+			if (globalThis.AudioDecoder !== void 0 && (yield globalThis.AudioDecoder.isConfigSupported(n)).supported) return {
+				AudioDecoder: globalThis.AudioDecoder,
+				EncodedAudioChunk: globalThis.EncodedAudioChunk,
+				AudioData: globalThis.AudioData
+			};
+		} catch {}
+		if ((yield T.isConfigSupported(n)).supported) return {
+			AudioDecoder: T,
+			EncodedAudioChunk: e,
+			AudioData: t
+		};
+		throw new $();
+	});
+}
+function te(e) {
+	return Q(this, void 0, void 0, function* () {
+		try {
+			if (globalThis.VideoDecoder !== void 0 && (yield globalThis.VideoDecoder.isConfigSupported(e)).supported) return {
+				VideoDecoder: globalThis.VideoDecoder,
+				EncodedVideoChunk: globalThis.EncodedVideoChunk,
+				VideoFrame: globalThis.VideoFrame
+			};
+		} catch {}
+		if ((yield R.isConfigSupported(e)).supported) return {
+			VideoDecoder: R,
+			EncodedVideoChunk: O,
+			VideoFrame: j
+		};
+		throw new $();
+	});
+}
+function ne(n) {
+	return Q(this, void 0, void 0, function* () {
+		try {
+			if (globalThis.AudioEncoder !== void 0 && (yield globalThis.AudioEncoder.isConfigSupported(n)).supported) return {
+				AudioEncoder: globalThis.AudioEncoder,
+				EncodedAudioChunk: globalThis.EncodedAudioChunk,
+				AudioData: globalThis.AudioData
+			};
+		} catch {}
+		if ((yield D.isConfigSupported(n)).supported) return {
+			AudioEncoder: D,
+			EncodedAudioChunk: e,
+			AudioData: t
+		};
+		throw new $();
+	});
+}
+function re(e) {
+	return Q(this, void 0, void 0, function* () {
+		try {
+			if (globalThis.VideoEncoder !== void 0 && (yield globalThis.VideoEncoder.isConfigSupported(e)).supported) return {
+				VideoEncoder: globalThis.VideoEncoder,
+				EncodedVideoChunk: globalThis.EncodedVideoChunk,
+				VideoFrame: globalThis.VideoFrame
+			};
+		} catch {}
+		if ((yield B.isConfigSupported(e)).supported) return {
+			VideoEncoder: B,
+			EncodedVideoChunk: O,
+			VideoFrame: j
+		};
+		throw new $();
+	});
+}
+//#endregion
+//#region ../../node_modules/@kixelated/libavjs-webcodecs-polyfill/dist/main.js
+var ie = function(e, t, n, r) {
+	function i(e) {
+		return e instanceof n ? e : new n(function(t) {
+			t(e);
+		});
+	}
+	return new (n ||= Promise)(function(n, a) {
+		function o(e) {
+			try {
+				c(r.next(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function s(e) {
+			try {
+				c(r.throw(e));
+			} catch (e) {
+				a(e);
+			}
+		}
+		function c(e) {
+			e.done ? n(e.value) : i(e.value).then(o, s);
+		}
+		c((r = r.apply(e, t || [])).next());
+	});
+};
+function ae(n = {}) {
+	return ie(this, void 0, void 0, function* () {
+		let r = {};
+		if (n.libavOptions && Object.assign(r, n.libavOptions), !n.LibAV && globalThis.LibAV === void 0 && (yield new Promise((e, t) => {
+			r.noworker = !0;
+			let n = "https://cdn.jsdelivr.net/npm/@libav.js/variant-webm-vp9@6.7.7/dist";
+			globalThis.LibAV = { base: n };
+			let i = "libav-6.7.7.1.1-webm-vp9.js";
+			if (typeof importScripts < "u") importScripts(`${n}/${i}`), e(void 0);
+			else {
+				let r = document.createElement("script");
+				r.src = `${n}/${i}`, r.onload = e, r.onerror = t, document.body.appendChild(r);
+			}
+		})), n.LibAV && p(n.LibAV), m(r), yield v(), n.polyfill) for (let n of [
+			["EncodedAudioChunk", e],
+			["AudioData", t],
+			["AudioDecoder", T],
+			["AudioEncoder", D],
+			["EncodedVideoChunk", O],
+			["VideoFrame", j],
+			["VideoDecoder", R],
+			["VideoEncoder", B]
+		]) globalThis[n[0]] || (globalThis[n[0]] = n[1]);
+		yield q(r, !!n.polyfill);
+	});
+}
+var oe = e, se = t, ce = T, le = D, ue = O, de = j, fe = R, pe = B, me = J, he = Z, ge = $, _e = ee, ve = te, ye = ne, be = re;
+//#endregion
+export { se as AudioData, ce as AudioDecoder, le as AudioEncoder, oe as EncodedAudioChunk, ue as EncodedVideoChunk, ge as UnsupportedException, fe as VideoDecoder, pe as VideoEncoder, de as VideoFrame, me as canvasDrawImage, he as createImageBitmap, _e as getAudioDecoder, ye as getAudioEncoder, ve as getVideoDecoder, be as getVideoEncoder, ae as load };
+
+//# sourceMappingURL=main-bFFHfuX4.js.map