@norskvideo/moq-watch 0.1.8 → 0.2.0

package/player-C19uf7Dc.js

@@ -0,0 +1,2172 @@
+import { Announce as e, Error as t, Path as n, Time as r } from "@norskvideo/moq-net";
+import { Effect as i, Signal as a, getter as o, readonlys as s } from "@norskvideo/moq-signals";
+import * as c from "@norskvideo/moq-hang/catalog";
+import { u53 as l } from "@norskvideo/moq-hang/catalog";
+import * as u from "@norskvideo/moq-hang/container";
+import * as d from "@norskvideo/moq-hang/util";
+import * as f from "@norskvideo/moq-json";
+import * as p from "@norskvideo/moq-msf";
+import { CaptionsRenderer as ee, VTTCue as m, parseText as h } from "media-captions";
+//#region src/base64.ts
+function g(e) {
+	let t = atob(e), n = new Uint8Array(t.length);
+	for (let e = 0; e < t.length; e++) n[e] = t.charCodeAt(e);
+	return n;
+}
+//#endregion
+//#region src/media.ts
+function _(e, t) {
+	if (e.get(t.broadcast.closed) !== void 0) return;
+	let n = t.broadcast.track(t.track).subscribe({
+		priority: t.priority,
+		maxAge: t.maxAge.peek()
+	});
+	return e.cleanup(() => n.close()), e.run((e) => {
+		n.update({
+			priority: t.priority,
+			maxAge: e.get(t.maxAge)
+		});
+	}), n;
+}
+async function v(e) {
+	try {
+		return await e.next();
+	} catch (e) {
+		if (!(e instanceof t.Stream)) throw e;
+		console.debug("media subscription ended", e);
+		return;
+	}
+}
+//#endregion
+//#region src/audio/shared-ring-buffer.ts
+var y = 0, b = 1, x = 2, S = 3, te = 4, ne = 4294967295n;
+function C(e, t) {
+	return BigInt(e >>> 0) << 32n | BigInt(t >>> 0);
+}
+function w(e) {
+	return Number(e >> 32n) | 0;
+}
+function re(e) {
+	return !!(w(e) & 1);
+}
+function T(e) {
+	return Number(e & ne) | 0;
+}
+function ie(e) {
+	return e <= 1 ? 1 : 1 << 32 - Math.clz32(e - 1);
+}
+function ae(e, t, n, r = !1) {
+	if (e <= 0) throw Error("invalid channels");
+	if (t <= 0 || t > 2 ** 30) throw Error("invalid capacity");
+	if (n <= 0) throw Error("invalid sample rate");
+	t = ie(t);
+	let i = new SharedArrayBuffer(e * t * Float32Array.BYTES_PER_ELEMENT), a = new SharedArrayBuffer(te * Int32Array.BYTES_PER_ELEMENT), o = new SharedArrayBuffer(BigInt64Array.BYTES_PER_ELEMENT), s = new Int32Array(a);
+	return Atomics.store(s, x, 1), {
+		channels: e,
+		capacity: t,
+		rate: n,
+		samples: i,
+		control: a,
+		state: o,
+		buffered: r
+	};
+}
+function E(e, t) {
+	return (e - t | 0) > 0 ? e : t;
+}
+function D(e, t) {
+	return e & t - 1;
+}
+var oe = class e {
+	channels;
+	capacity;
+	rate;
+	buffered;
+	init;
+	#e;
+	#t;
+	#n;
+	#r = !1;
+	#i = 0;
+	#a = 0;
+	#o = 0;
+	constructor(e, t) {
+		this.channels = e.channels, this.capacity = e.capacity, this.rate = e.rate, this.buffered = e.buffered, this.init = e, this.#e = new Int32Array(e.control), this.#t = new BigInt64Array(e.state), this.#n = [];
+		for (let t = 0; t < this.channels; t++) this.#n.push(new Float32Array(e.samples, t * this.capacity * Float32Array.BYTES_PER_ELEMENT, this.capacity));
+		t !== void 0 && this.#s(t);
+	}
+	#s(e) {
+		if (e.channels !== this.channels || e.rate !== this.rate) return;
+		let t = Atomics.load(e.#e, S), n = Atomics.load(e.#t, 0);
+		for (;;) {
+			let e = Atomics.load(this.#t, 0);
+			if (Atomics.load(this.#e, S) !== t || (T(n) - T(e) | 0) <= 0) return;
+			let r = C(w(e), T(n));
+			if (Atomics.compareExchange(this.#t, 0, e, r) === e) return;
+		}
+	}
+	#c(e) {
+		for (;;) {
+			let t = Atomics.load(this.#t, 0);
+			if ((e - T(t) | 0) <= 0) return;
+			let n = C(w(t), e);
+			if (Atomics.compareExchange(this.#t, 0, t, n) === t) return;
+		}
+	}
+	#l(e) {
+		for (;;) {
+			let t = Atomics.load(this.#t, 0), n = C(w(t) + e | 0, T(t));
+			if (Atomics.compareExchange(this.#t, 0, t, n) === t) return;
+		}
+	}
+	insert(e, t) {
+		if (t.length !== this.channels) throw Error("wrong number of channels");
+		let n = Math.round(r.Second.fromMicro(e) * this.rate), i = t[0].length, a = 0;
+		if (!this.#r) {
+			this.#i = n;
+			let e = w(Atomics.load(this.#t, 0));
+			Atomics.add(this.#e, S, 1), Atomics.store(this.#t, 0, C(e + 2 | 0, 0)), Atomics.store(this.#e, y, 0), this.#r = !0, this.#a = 0, this.#o = 0;
+		}
+		n = n - this.#i | 0;
+		let o = n + i | 0, s = T(Atomics.load(this.#t, 0)), c = s - n | 0;
+		if (c > 0) {
+			if (c >= i) return;
+			a = c, n = n + c | 0;
+		}
+		let l = i - a;
+		(o - s | 0) > this.capacity && this.#c(o - this.capacity | 0);
+		let u = Atomics.load(this.#e, y), d = n - u | 0;
+		if (d > 0) {
+			let e = Math.min(d, this.capacity);
+			for (let t = 0; t < this.channels; t++) {
+				let n = this.#n[t];
+				for (let t = 0; t < e; t++) n[D(u + t | 0, this.capacity)] = 0;
+			}
+		}
+		for (let e = 0; e < this.channels; e++) {
+			let r = t[e], i = this.#n[e];
+			for (let e = 0; e < l; e++) i[D(n + e | 0, this.capacity)] = r[a + e];
+		}
+		Atomics.store(this.#e, y, E(Atomics.load(this.#e, y), o)), this.#u();
+	}
+	#u() {
+		let e = T(Atomics.load(this.#t, 0)), t = Atomics.load(this.#e, y), n = Atomics.load(this.#e, b);
+		(t - e | 0) >= n && n > 0 && Atomics.store(this.#e, x, 0);
+	}
+	read(e) {
+		let t = Atomics.load(this.#t, 0);
+		if (Atomics.load(this.#e, x) === 1 || re(t)) return 0;
+		let n = T(t), r = Atomics.load(this.#e, y), i = Atomics.load(this.#e, b), a = r - n | 0;
+		if (!this.buffered && i > 0 && a > i) {
+			let e = r - i | 0;
+			(e - n | 0) > 0 && (n = e);
+		}
+		let o = r - n | 0, s = Math.min(o, e[0].length);
+		if (s <= 0) return (n - T(t) | 0) > 0 && Atomics.compareExchange(this.#t, 0, t, C(w(t), n)), 0;
+		for (let t = 0; t < this.channels; t++) {
+			let r = this.#n[t], i = e[t];
+			for (let e = 0; e < s; e++) i[e] = r[D(n + e | 0, this.capacity)];
+		}
+		let c = C(w(t), n + s | 0);
+		if (Atomics.compareExchange(this.#t, 0, t, c) !== t) {
+			for (let t = 0; t < this.channels; t++) e[t].fill(0, 0, s);
+			return 0;
+		}
+		return s;
+	}
+	setLatency(e) {
+		let t = Atomics.exchange(this.#e, b, e);
+		t > 0 && e > t && (Atomics.store(this.#e, x, 1), this.#l(2)), this.#u();
+	}
+	truncate(e) {
+		let t = Math.round(r.Second.fromMicro(e) * this.rate) - this.#i | 0;
+		if (!((Atomics.load(this.#e, y) - t | 0) <= 0)) {
+			for (this.#l(1);;) {
+				let e = Atomics.load(this.#e, y), n = E(t, T(Atomics.load(this.#t, 0)));
+				if ((e - n | 0) <= 0 || Atomics.compareExchange(this.#e, y, e, n) === e) break;
+			}
+			this.#l(1);
+		}
+	}
+	reset() {
+		this.#r = !1, Atomics.store(this.#e, x, 1);
+		let e = Atomics.load(this.#e, y), t = Atomics.load(this.#t, 0);
+		Atomics.store(this.#t, 0, C(w(t), e));
+	}
+	resize(t) {
+		let n = ae(this.channels, t, this.rate, this.buffered), r = new e(n);
+		r.#r = this.#r, r.#i = this.#i;
+		let i = Atomics.load(this.#t, 0), a = T(i), o = Atomics.load(this.#e, y), s = Atomics.load(this.#e, b), c = Atomics.load(this.#e, x), l = o - a | 0, u = Math.max(0, Math.min(l, r.capacity)), d = o - u | 0;
+		for (let e = 0; e < this.channels; e++) {
+			let t = this.#n[e], n = r.#n[e];
+			for (let e = 0; e < u; e++) {
+				let i = d + e | 0;
+				n[D(i, r.capacity)] = t[D(i, this.capacity)];
+			}
+		}
+		return Atomics.store(r.#e, S, Atomics.load(this.#e, S)), Atomics.store(r.#t, 0, C(w(i), d)), Atomics.store(r.#e, y, o), Atomics.store(r.#e, b, s), Atomics.store(r.#e, x, c), r.#a = this.#d(a) + (d - a | 0), r.#o = d, r;
+	}
+	#d(e) {
+		return this.#a += e - this.#o | 0, this.#o = e, this.#a;
+	}
+	#f() {
+		return this.#d(T(Atomics.load(this.#t, 0)));
+	}
+	get timestamp() {
+		return r.Micro.fromSecond((this.#i + this.#f()) / this.rate);
+	}
+	get stalled() {
+		return Atomics.load(this.#e, x) === 1;
+	}
+	get length() {
+		return Atomics.load(this.#e, y) - T(Atomics.load(this.#t, 0)) | 0;
+	}
+}, se = class {
+	#e;
+	#t;
+	#n = [];
+	constructor(e, t) {
+		this.#e = e, this.#t = t;
+	}
+	setHeadroom(e) {
+		this.#t = e;
+	}
+	wait(e, t) {
+		return !this.#e || t >= (e - this.#t | 0) ? Promise.resolve() : new Promise((t) => this.#n.push({
+			timestamp: e,
+			resolve: t
+		}));
+	}
+	advance(e) {
+		this.#n.length !== 0 && (this.#n = this.#n.filter(({ timestamp: t, resolve: n }) => e < (t - this.#t | 0) || (n(), !1)));
+	}
+	flush() {
+		for (let { resolve: e } of this.#n) e();
+		this.#n = [];
+	}
+};
+function O(e, t) {
+	return r.Micro.fromSecond(e / t);
+}
+function ce() {
+	return !(typeof SharedArrayBuffer > "u" || typeof crossOriginIsolated < "u" && !crossOriginIsolated);
+}
+function le(e, t, n, r, i = !1) {
+	return ce() ? (console.log("[audio] using SharedArrayBuffer audio buffer"), new ue(e, t, n, r, i)) : (console.warn("[audio] SharedArrayBuffer unavailable, falling back to the higher latency postMessage audio buffer. Serve the page cross-origin isolated (Cross-Origin-Opener-Policy: same-origin, Cross-Origin-Embedder-Policy: require-corp) to avoid this."), new de(e, t, n, r, i));
+}
+var ue = class {
+	rate;
+	channels;
+	#e;
+	#t;
+	#n = new a(0);
+	timestamp = this.#n;
+	#r = new a(!0);
+	stalled = this.#r;
+	#i;
+	#a = new i();
+	constructor(e, t, n, r, i) {
+		this.#e = e, this.channels = t, this.rate = n;
+		let a = Math.max(n, r * 2);
+		this.#i = new se(i, O(r, n));
+		let o = ae(t, a, n, i);
+		this.#t = new oe(o), this.#t.setLatency(r);
+		let s = {
+			type: "init-shared",
+			...o
+		};
+		e.port.postMessage(s), this.#a.interval(() => {
+			let e = this.#t.stalled;
+			this.#n.set(this.#t.timestamp), this.#r.set(e), e ? this.#i.flush() : this.#i.advance(this.#t.timestamp);
+		}, 50);
+	}
+	insert(e, t) {
+		this.#t.insert(e, t);
+	}
+	setLatency(e) {
+		if (this.#i.setHeadroom(O(e, this.rate)), this.#t.setLatency(e), this.#t.capacity < e * 1.5) {
+			let t = Math.max(this.rate, e * 2);
+			this.#t = this.#t.resize(t);
+			let n = {
+				type: "init-shared",
+				...this.#t.init
+			};
+			this.#e.port.postMessage(n);
+		}
+	}
+	truncate(e) {
+		this.#t.truncate(e);
+	}
+	reset() {
+		this.#t.reset(), this.#i.flush();
+	}
+	wait(e) {
+		return this.#t.stalled ? Promise.resolve() : this.#i.wait(e, this.#t.timestamp);
+	}
+	close() {
+		this.#i.flush(), this.#a.close();
+	}
+}, de = class {
+	rate;
+	channels;
+	#e;
+	#t = new a(0);
+	timestamp = this.#t;
+	#n = new a(!0);
+	stalled = this.#n;
+	#r;
+	#i = new i();
+	constructor(e, t, n, i, a) {
+		this.#e = e, this.channels = t, this.rate = n, this.#r = new se(a, O(i, n));
+		let o = {
+			type: "init-post",
+			channels: t,
+			rate: n,
+			latency: r.Milli.fromSecond(i / n),
+			buffered: a
+		};
+		e.port.postMessage(o), this.#i.event(e.port, "message", (e) => {
+			let t = e.data;
+			t?.type === "state" && (this.#t.set(t.timestamp), this.#n.set(t.stalled), t.stalled ? this.#r.flush() : this.#r.advance(t.timestamp));
+		}), e.port.start();
+	}
+	insert(e, t) {
+		let n = {
+			type: "data",
+			data: t,
+			timestamp: e
+		};
+		this.#e.port.postMessage(n, t.map((e) => e.buffer));
+	}
+	setLatency(e) {
+		this.#r.setHeadroom(O(e, this.rate));
+		let t = {
+			type: "latency",
+			latency: r.Milli.fromSecond(e / this.rate)
+		};
+		this.#e.port.postMessage(t);
+	}
+	truncate(e) {
+		let t = {
+			type: "truncate",
+			timestamp: e
+		};
+		this.#e.port.postMessage(t);
+	}
+	reset() {
+		this.#e.port.postMessage({ type: "reset" }), this.#r.flush();
+	}
+	wait(e) {
+		return this.#n.peek() ? Promise.resolve() : this.#r.wait(e, this.#t.peek());
+	}
+	close() {
+		this.#r.flush(), this.#i.close();
+	}
+}, fe = 128, pe = 20, me = 1024, he = 1152, ge = 576, _e = 32e3;
+function k(e) {
+	return {
+		codec: e.codec,
+		container: e.container,
+		description: e.description,
+		sampleRate: e.sampleRate,
+		numberOfChannels: e.numberOfChannels
+	};
+}
+function ve(e) {
+	return {
+		broadcast: e.broadcast,
+		decoder: k(e)
+	};
+}
+function ye(e) {
+	let t = (e.jitter || be(e)) ?? 0, n = Math.ceil(fe / e.sampleRate * 1e3);
+	return r.Milli((e.delay ?? 0) + t + n);
+}
+function be(e) {
+	if (e.codec.startsWith("opus")) return pe;
+	if (e.codec.startsWith("mp4a")) return Math.ceil(me / e.sampleRate * 1e3);
+	if (e.codec === "mp3") {
+		let t = e.sampleRate >= _e ? he : ge;
+		return Math.ceil(t / e.sampleRate * 1e3);
+	}
+}
+//#endregion
+//#region src/audio/handover.ts
+var xe = class {
+	#e = !1;
+	#t = !1;
+	opened() {
+		this.#e && (this.#t = !0), this.#e = !0;
+	}
+	takeover() {
+		let e = this.#t;
+		return this.#t = !1, e;
+	}
+}, Se = 128;
+function A(e, t) {
+	return Math.max(Se, Math.ceil(e * r.Second.fromMilli(t)));
+}
+//#endregion
+//#region src/audio/render-worklet.ts?worklet
+var Ce = new Blob(["var __defProp = Object.defineProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\n\n// ../net/src/time.ts\nvar time_exports = {};\n__export(time_exports, {\n  Micro: () => Micro,\n  Milli: () => Milli,\n  Nano: () => Nano,\n  Second: () => Second,\n  Timescale: () => Timescale,\n  Timestamp: () => Timestamp\n});\nvar Nano = Object.assign((value) => value, {\n  zero: 0,\n  fromMicro: (us) => us * 1e3,\n  fromMilli: (ms) => ms * 1e6,\n  fromSecond: (s) => s * 1e9,\n  toMicro: (ns) => ns / 1e3,\n  toMilli: (ns) => ns / 1e6,\n  toSecond: (ns) => ns / 1e9,\n  now: () => performance.now() * 1e6,\n  add: (a, b) => a + b,\n  sub: (a, b) => a - b,\n  mul: (a, b) => a * b,\n  div: (a, b) => a / b,\n  max: (a, b) => Math.max(a, b),\n  min: (a, b) => Math.min(a, b)\n});\nvar Micro = Object.assign((value) => value, {\n  zero: 0,\n  fromNano: (ns) => ns / 1e3,\n  fromMilli: (ms) => ms * 1e3,\n  fromSecond: (s) => s * 1e6,\n  toNano: (us) => us * 1e3,\n  toMilli: (us) => us / 1e3,\n  toSecond: (us) => us / 1e6,\n  now: () => performance.now() * 1e3,\n  add: (a, b) => a + b,\n  sub: (a, b) => a - b,\n  mul: (a, b) => a * b,\n  div: (a, b) => a / b,\n  max: (a, b) => Math.max(a, b),\n  min: (a, b) => Math.min(a, b)\n});\nvar Milli = Object.assign((value) => value, {\n  zero: 0,\n  fromNano: (ns) => ns / 1e6,\n  fromMicro: (us) => us / 1e3,\n  fromSecond: (s) => s * 1e3,\n  toNano: (ms) => ms * 1e6,\n  toMicro: (ms) => ms * 1e3,\n  toSecond: (ms) => ms / 1e3,\n  now: () => performance.now(),\n  add: (a, b) => a + b,\n  sub: (a, b) => a - b,\n  mul: (a, b) => a * b,\n  div: (a, b) => a / b,\n  max: (a, b) => Math.max(a, b),\n  min: (a, b) => Math.min(a, b)\n});\nvar Timescale = Object.assign(\n  (unitsPerSecond) => {\n    if (!Number.isSafeInteger(unitsPerSecond) || unitsPerSecond <= 0) {\n      throw new RangeError(`invalid timescale: ${unitsPerSecond}`);\n    }\n    return unitsPerSecond;\n  },\n  {\n    /** One unit per second. */\n    SECOND: 1,\n    /** 1,000 units per second. */\n    MILLI: 1e3,\n    /** 1,000,000 units per second. */\n    MICRO: 1e6,\n    /** 1,000,000,000 units per second. */\n    NANO: 1e9\n  }\n);\nfunction assertTimestampValue(value) {\n  if (!Number.isFinite(value) || value < 0 || value > Number.MAX_SAFE_INTEGER) {\n    throw new RangeError(`invalid timestamp: ${value}`);\n  }\n}\nvar Timestamp = class _Timestamp {\n  /** The raw value, in `scale` units. */\n  value;\n  /** Units per second the {@link value} is measured in. */\n  scale;\n  /** Build a timestamp of `value` units at `scale`. */\n  constructor(value, scale) {\n    assertTimestampValue(value);\n    this.value = value;\n    this.scale = Timescale(scale);\n  }\n  /** Monotonic now (`performance.now()`, milliseconds since page load), not wall-clock time. */\n  static now() {\n    return new _Timestamp(performance.now(), Timescale.MILLI);\n  }\n  /** A timestamp of `ms` milliseconds. */\n  static fromMillis(ms) {\n    return new _Timestamp(ms, Timescale.MILLI);\n  }\n  /** A timestamp of `us` microseconds. */\n  static fromMicros(us) {\n    return new _Timestamp(us, Timescale.MICRO);\n  }\n  /** This timestamp's value re-expressed at `scale`; throws if the result is not in the safe range. */\n  as(scale) {\n    const dest = Timescale(scale);\n    const converted = dest === this.scale ? this.value : this.value * dest / this.scale;\n    assertTimestampValue(converted);\n    return converted;\n  }\n  /** The value in milliseconds. */\n  asMillis() {\n    return this.as(Timescale.MILLI);\n  }\n  /** The value in microseconds. */\n  asMicros() {\n    return this.as(Timescale.MICRO);\n  }\n};\nvar Second = Object.assign((value) => value, {\n  zero: 0,\n  fromNano: (ns) => ns / 1e9,\n  fromMicro: (us) => us / 1e6,\n  fromMilli: (ms) => ms / 1e3,\n  toNano: (s) => s * 1e9,\n  toMicro: (s) => s * 1e6,\n  toMilli: (s) => s * 1e3,\n  now: () => performance.now() / 1e3,\n  add: (a, b) => a + b,\n  sub: (a, b) => a - b,\n  mul: (a, b) => a * b,\n  div: (a, b) => a / b,\n  max: (a, b) => Math.max(a, b),\n  min: (a, b) => Math.min(a, b)\n});\n\n// src/audio/ring-buffer.ts\nvar AudioRingBuffer = class {\n  #buffer;\n  #writeIndex = 0;\n  #readIndex = 0;\n  rate;\n  channels;\n  #stalled = true;\n  // Buffered mode: play through everything buffered without skipping ahead.\n  #buffered;\n  // Un-stall threshold in samples (how much to buffer before playback starts).\n  #latencySamples;\n  // Whether the read/write indices have been anchored to the first inserted sample.\n  #anchored = false;\n  constructor(props) {\n    if (props.channels <= 0) throw new Error(\"invalid channels\");\n    if (props.rate <= 0) throw new Error(\"invalid sample rate\");\n    if (props.latency <= 0) throw new Error(\"invalid latency\");\n    this.#latencySamples = Math.ceil(props.rate * time_exports.Second.fromMilli(props.latency));\n    if (this.#latencySamples === 0) throw new Error(\"empty buffer\");\n    this.rate = props.rate;\n    this.channels = props.channels;\n    this.#buffered = props.buffered ?? false;\n    const capacity = this.#capacityFor(this.#latencySamples);\n    this.#buffer = [];\n    for (let i = 0; i < this.channels; i++) {\n      this.#buffer[i] = new Float32Array(capacity);\n    }\n  }\n  #capacityFor(latencySamples) {\n    return this.#buffered ? latencySamples * 2 : latencySamples;\n  }\n  get stalled() {\n    return this.#stalled;\n  }\n  get timestamp() {\n    return time_exports.Micro.fromSecond(this.#readIndex / this.rate);\n  }\n  get length() {\n    return this.#writeIndex - this.#readIndex;\n  }\n  get capacity() {\n    return this.#buffer[0]?.length;\n  }\n  resize(latency) {\n    const latencySamples = Math.ceil(this.rate * time_exports.Second.fromMilli(latency));\n    if (latencySamples > this.#latencySamples) this.#stalled = true;\n    this.#latencySamples = latencySamples;\n    const newCapacity = this.#capacityFor(this.#latencySamples);\n    if (newCapacity !== this.capacity) this.#reallocate(newCapacity);\n    if (latencySamples > 0 && this.length >= latencySamples) this.#stalled = false;\n  }\n  #reallocate(newCapacity) {\n    if (newCapacity === 0) throw new Error(\"empty buffer\");\n    const newBuffer = [];\n    for (let i = 0; i < this.channels; i++) {\n      newBuffer[i] = new Float32Array(newCapacity);\n    }\n    const samplesToKeep = Math.min(this.length, newCapacity);\n    if (samplesToKeep > 0) {\n      const copyStart = this.#writeIndex - samplesToKeep;\n      for (let channel = 0; channel < this.channels; channel++) {\n        const src = this.#buffer[channel];\n        const dst = newBuffer[channel];\n        for (let i = 0; i < samplesToKeep; i++) {\n          const srcPos = (copyStart + i) % src.length;\n          const dstPos = (copyStart + i) % dst.length;\n          dst[dstPos] = src[srcPos];\n        }\n      }\n    }\n    this.#buffer = newBuffer;\n    this.#readIndex = this.#writeIndex - samplesToKeep;\n    if (samplesToKeep === 0) this.#stalled = true;\n  }\n  write(timestamp, data) {\n    if (data.length !== this.channels) throw new Error(\"wrong number of channels\");\n    let start = Math.round(time_exports.Second.fromMicro(timestamp) * this.rate);\n    let samples = data[0].length;\n    if (!this.#anchored) {\n      this.#readIndex = start;\n      this.#writeIndex = start;\n      this.#anchored = true;\n    }\n    let offset = this.#readIndex - start;\n    if (offset > samples) {\n      return;\n    } else if (offset > 0) {\n      samples -= offset;\n      start += offset;\n    } else {\n      offset = 0;\n    }\n    const end = start + samples;\n    const overflow = end - this.#readIndex - this.#buffer[0].length;\n    if (overflow >= 0) {\n      this.#stalled = false;\n      this.#readIndex += overflow;\n    }\n    if (start > this.#writeIndex) {\n      const gapSize = Math.min(start - this.#writeIndex, this.#buffer[0].length);\n      if (gapSize === 1) {\n        console.warn(\"floating point inaccuracy detected\");\n      }\n      for (let channel = 0; channel < this.channels; channel++) {\n        const dst = this.#buffer[channel];\n        for (let i = 0; i < gapSize; i++) {\n          const writePos = (this.#writeIndex + i) % dst.length;\n          dst[writePos] = 0;\n        }\n      }\n    }\n    for (let channel = 0; channel < this.channels; channel++) {\n      let src = data[channel];\n      src = src.subarray(src.length - samples);\n      const dst = this.#buffer[channel];\n      if (src.length !== samples) throw new Error(\"mismatching number of samples\");\n      for (let i = 0; i < samples; i++) {\n        const writePos = (start + i) % dst.length;\n        dst[writePos] = src[i];\n      }\n    }\n    if (end > this.#writeIndex) {\n      this.#writeIndex = end;\n    }\n    if (this.#buffered && this.length >= this.#latencySamples) {\n      this.#stalled = false;\n    }\n  }\n  /**\n   * Drop buffered samples at or after `timestamp`, keeping whatever is already due.\n   *\n   * A successor track overwrites the slots its own samples land on, but anything the previous\n   * track wrote beyond them would otherwise still play once the successor runs out.\n   */\n  truncate(timestamp) {\n    const target = Math.round(time_exports.Second.fromMicro(timestamp) * this.rate);\n    if (target >= this.#writeIndex) return;\n    this.#writeIndex = Math.max(target, this.#readIndex);\n  }\n  // Flush all buffered samples and re-stall, ready to anchor the next utterance.\n  reset() {\n    this.#readIndex = 0;\n    this.#writeIndex = 0;\n    this.#stalled = true;\n    this.#anchored = false;\n  }\n  read(output) {\n    if (output.length !== this.channels) throw new Error(\"wrong number of channels\");\n    if (this.#stalled) return 0;\n    const samples = Math.min(this.#writeIndex - this.#readIndex, output[0].length);\n    if (samples === 0) return 0;\n    for (let channel = 0; channel < this.channels; channel++) {\n      const dst = output[channel];\n      const src = this.#buffer[channel];\n      if (dst.length !== output[0].length) throw new Error(\"mismatching number of samples\");\n      for (let i = 0; i < samples; i++) {\n        const readPos = (this.#readIndex + i) % src.length;\n        dst[i] = src[readPos];\n      }\n    }\n    this.#readIndex += samples;\n    return samples;\n  }\n};\n\n// src/audio/shared-ring-buffer.ts\nvar WRITE = 0;\nvar LATENCY = 1;\nvar STALLED = 2;\nvar TIMELINE = 3;\nvar CONTROL_SLOTS = 4;\nvar CURSOR_MASK = 0xffffffffn;\nfunction pack(epoch, read) {\n  return BigInt(epoch >>> 0) << 32n | BigInt(read >>> 0);\n}\nfunction epochOf(state) {\n  return Number(state >> 32n) | 0;\n}\nfunction retreating(state) {\n  return (epochOf(state) & 1) !== 0;\n}\nfunction readOf(state) {\n  return Number(state & CURSOR_MASK) | 0;\n}\nfunction ceilPow2(n) {\n  return n <= 1 ? 1 : 1 << 32 - Math.clz32(n - 1);\n}\nfunction allocSharedRingBuffer(channels, capacity, rate, buffered = false) {\n  if (channels <= 0) throw new Error(\"invalid channels\");\n  if (capacity <= 0 || capacity > 2 ** 30) throw new Error(\"invalid capacity\");\n  if (rate <= 0) throw new Error(\"invalid sample rate\");\n  capacity = ceilPow2(capacity);\n  const samples = new SharedArrayBuffer(channels * capacity * Float32Array.BYTES_PER_ELEMENT);\n  const control = new SharedArrayBuffer(CONTROL_SLOTS * Int32Array.BYTES_PER_ELEMENT);\n  const state = new SharedArrayBuffer(BigInt64Array.BYTES_PER_ELEMENT);\n  const ctrl = new Int32Array(control);\n  Atomics.store(ctrl, STALLED, 1);\n  return { channels, capacity, rate, samples, control, state, buffered };\n}\nfunction i32Max(a, b) {\n  return (a - b | 0) > 0 ? a : b;\n}\nfunction slot(idx, capacity) {\n  return idx & capacity - 1;\n}\nvar SharedRingBuffer = class _SharedRingBuffer {\n  channels;\n  capacity;\n  rate;\n  buffered;\n  init;\n  #control;\n  #state;\n  #samples;\n  // Whether READ/WRITE have been anchored to the first inserted sample.\n  #anchored = false;\n  // Absolute sample index of that first sample. READ/WRITE are stored relative to it, so\n  // `timestamp` adds it back to recover media time. Main-thread only: the worklet reads by\n  // difference and never needs an absolute position.\n  #anchor = 0;\n  // Unwrapped READ, in anchor-relative samples, plus the raw i32 it was last derived from.\n  // READ is Int32 and wraps every ~13.5h at 44.1kHz. That is harmless for the modular\n  // comparisons the ring runs on, but reading the negative half as a magnitude would report\n  // the playhead jumping back 2^32 samples, so accumulate deltas here instead. Main-thread\n  // only, and only accurate while `timestamp` is observed more often than READ can advance\n  // 2^31 samples, which the 50ms poll in `buffer.ts` satisfies by six orders of magnitude.\n  #position = 0;\n  #lastRead = 0;\n  /**\n   * Wrap the shared memory described by `init`.\n   *\n   * Pass `previous` in the worklet when this ring replaces one already being read. `resize`\n   * snapshots the playhead on the main thread and hands the replacement over by message, so the\n   * reader keeps draining the old ring in the meantime. Carrying its cursor across means those\n   * samples are not played twice.\n   */\n  constructor(init, previous) {\n    this.channels = init.channels;\n    this.capacity = init.capacity;\n    this.rate = init.rate;\n    this.buffered = init.buffered;\n    this.init = init;\n    this.#control = new Int32Array(init.control);\n    this.#state = new BigInt64Array(init.state);\n    this.#samples = [];\n    for (let i = 0; i < this.channels; i++) {\n      this.#samples.push(\n        new Float32Array(init.samples, i * this.capacity * Float32Array.BYTES_PER_ELEMENT, this.capacity)\n      );\n    }\n    if (previous !== void 0) this.#handoff(previous);\n  }\n  /**\n   * Carry `source`'s playhead across, if the replacement is still the timeline it belongs to.\n   *\n   * Truncation changes the mutation epoch but preserves timeline identity. Sample state before\n   * identity: a re-anchor publishes identity first, then replaces state. Either the identity\n   * check rejects the old cursor, the exchange fails, or the re-anchor overwrites the carried\n   * cursor. A truncate only forces a retry, preserving audio consumed since the resize.\n   */\n  #handoff(source) {\n    if (source.channels !== this.channels || source.rate !== this.rate) return;\n    const timeline = Atomics.load(source.#control, TIMELINE);\n    const from = Atomics.load(source.#state, 0);\n    for (; ; ) {\n      const state = Atomics.load(this.#state, 0);\n      if (Atomics.load(this.#control, TIMELINE) !== timeline) return;\n      if ((readOf(from) - readOf(state) | 0) <= 0) return;\n      const next = pack(epochOf(state), readOf(from));\n      if (Atomics.compareExchange(this.#state, 0, state, next) === state) return;\n    }\n  }\n  /**\n   * Move the playhead forward to `candidate`, staying on whatever timeline is current.\n   *\n   * Retries while the word changes under it, and never steps backwards. Used by the writer's\n   * overflow path; the reader publishes with its own exchange so it can tell a rebase apart\n   * from losing a race.\n   */\n  #advance(candidate) {\n    for (; ; ) {\n      const state = Atomics.load(this.#state, 0);\n      if ((candidate - readOf(state) | 0) <= 0) return;\n      const next = pack(epochOf(state), candidate);\n      if (Atomics.compareExchange(this.#state, 0, state, next) === state) return;\n    }\n  }\n  /**\n   * Step the epoch by `by`, leaving the playhead wherever the reader has taken it.\n   *\n   * Retries while the word changes under it: only the epoch half is the writer's to move.\n   */\n  #step(by) {\n    for (; ; ) {\n      const state = Atomics.load(this.#state, 0);\n      const next = pack(epochOf(state) + by | 0, readOf(state));\n      if (Atomics.compareExchange(this.#state, 0, state, next) === state) return;\n    }\n  }\n  /**\n   * Insert audio samples at the given timestamp.\n   * Main thread only. Handles out-of-order writes, gap filling, and overflow.\n   */\n  insert(timestamp, data) {\n    if (data.length !== this.channels) throw new Error(\"wrong number of channels\");\n    let start = Math.round(time_exports.Second.fromMicro(timestamp) * this.rate);\n    const originalLength = data[0].length;\n    let offset = 0;\n    if (!this.#anchored) {\n      this.#anchor = start;\n      const epoch = epochOf(Atomics.load(this.#state, 0));\n      Atomics.add(this.#control, TIMELINE, 1);\n      Atomics.store(this.#state, 0, pack(epoch + 2 | 0, 0));\n      Atomics.store(this.#control, WRITE, 0);\n      this.#anchored = true;\n      this.#position = 0;\n      this.#lastRead = 0;\n    }\n    start = start - this.#anchor | 0;\n    const end = start + originalLength | 0;\n    const read = readOf(Atomics.load(this.#state, 0));\n    const behind = read - start | 0;\n    if (behind > 0) {\n      if (behind >= originalLength) {\n        return;\n      }\n      offset = behind;\n      start = start + behind | 0;\n    }\n    const samples = originalLength - offset;\n    if ((end - read | 0) > this.capacity) {\n      this.#advance(end - this.capacity | 0);\n    }\n    const write = Atomics.load(this.#control, WRITE);\n    const gap = start - write | 0;\n    if (gap > 0) {\n      const gapSize = Math.min(gap, this.capacity);\n      for (let channel = 0; channel < this.channels; channel++) {\n        const dst = this.#samples[channel];\n        for (let i = 0; i < gapSize; i++) {\n          dst[slot(write + i | 0, this.capacity)] = 0;\n        }\n      }\n    }\n    for (let channel = 0; channel < this.channels; channel++) {\n      const src = data[channel];\n      const dst = this.#samples[channel];\n      for (let i = 0; i < samples; i++) {\n        dst[slot(start + i | 0, this.capacity)] = src[offset + i];\n      }\n    }\n    Atomics.store(this.#control, WRITE, i32Max(Atomics.load(this.#control, WRITE), end));\n    this.#resume();\n  }\n  // Un-stall once the buffered data covers LATENCY.\n  #resume() {\n    const read = readOf(Atomics.load(this.#state, 0));\n    const write = Atomics.load(this.#control, WRITE);\n    const latency = Atomics.load(this.#control, LATENCY);\n    if ((write - read | 0) >= latency && latency > 0) {\n      Atomics.store(this.#control, STALLED, 0);\n    }\n  }\n  /**\n   * Read audio samples into the output buffers.\n   * AudioWorklet only. Returns the number of samples read.\n   */\n  read(output) {\n    const state = Atomics.load(this.#state, 0);\n    if (Atomics.load(this.#control, STALLED) === 1) return 0;\n    if (retreating(state)) return 0;\n    let read = readOf(state);\n    const write = Atomics.load(this.#control, WRITE);\n    const latency = Atomics.load(this.#control, LATENCY);\n    const buffered = write - read | 0;\n    if (!this.buffered && latency > 0 && buffered > latency) {\n      const skipTo = write - latency | 0;\n      if ((skipTo - read | 0) > 0) read = skipTo;\n    }\n    const available = write - read | 0;\n    const count = Math.min(available, output[0].length);\n    if (count <= 0) {\n      if ((read - readOf(state) | 0) > 0) {\n        Atomics.compareExchange(this.#state, 0, state, pack(epochOf(state), read));\n      }\n      return 0;\n    }\n    for (let channel = 0; channel < this.channels; channel++) {\n      const src = this.#samples[channel];\n      const dst = output[channel];\n      for (let i = 0; i < count; i++) {\n        dst[i] = src[slot(read + i | 0, this.capacity)];\n      }\n    }\n    const next = pack(epochOf(state), read + count | 0);\n    if (Atomics.compareExchange(this.#state, 0, state, next) !== state) {\n      for (let channel = 0; channel < this.channels; channel++) output[channel].fill(0, 0, count);\n      return 0;\n    }\n    return count;\n  }\n  /**\n   * Update the target latency in samples. Main thread only.\n   *\n   * A deeper floor parks playback until it refills. Video holds the extra delay on its own, so\n   * audio that kept draining at the old depth would run ahead by the difference. Parking keeps\n   * what is buffered, so a rise costs only its own size in silence, and none if the buffer\n   * already covers the new floor.\n   */\n  setLatency(samples) {\n    const previous = Atomics.exchange(this.#control, LATENCY, samples);\n    if (previous > 0 && samples > previous) {\n      Atomics.store(this.#control, STALLED, 1);\n      this.#step(2);\n    }\n    this.#resume();\n  }\n  /**\n   * Drop buffered samples at or after `timestamp`, keeping whatever is already due.\n   * Main thread only.\n   *\n   * A successor track overwrites the slots its own samples land on, but anything the previous\n   * track wrote beyond them would otherwise still play once the successor runs out.\n   */\n  truncate(timestamp) {\n    const target = Math.round(time_exports.Second.fromMicro(timestamp) * this.rate) - this.#anchor | 0;\n    if ((Atomics.load(this.#control, WRITE) - target | 0) <= 0) return;\n    this.#step(1);\n    for (; ; ) {\n      const write = Atomics.load(this.#control, WRITE);\n      const clamped = i32Max(target, readOf(Atomics.load(this.#state, 0)));\n      if ((write - clamped | 0) <= 0) break;\n      if (Atomics.compareExchange(this.#control, WRITE, write, clamped) === write) break;\n    }\n    this.#step(1);\n  }\n  /**\n   * Flush buffered samples and re-stall, ready to anchor the next utterance (buffered mode).\n   * Main thread only. The worklet reader sees STALLED and stops until the next insert.\n   */\n  reset() {\n    this.#anchored = false;\n    Atomics.store(this.#control, STALLED, 1);\n    const write = Atomics.load(this.#control, WRITE);\n    const state = Atomics.load(this.#state, 0);\n    Atomics.store(this.#state, 0, pack(epochOf(state), write));\n  }\n  /**\n   * Allocate a new ring with `newCapacity` samples and copy the unread window\n   * [READ, WRITE) plus control state into it. Used when growing capacity so\n   * we don't drop buffered audio. If `newCapacity` is smaller than the unread\n   * span, the oldest samples are truncated.\n   *\n   * Main thread only. `resize()` reads from the source `SharedRingBuffer` and\n   * writes into a freshly allocated buffer from `allocSharedRingBuffer`, so it\n   * relies on the same invariant as `insert()`: no concurrent main-thread\n   * writers. The AudioWorklet reader is tolerated via the CAS discipline used\n   * by READ/WRITE elsewhere.\n   */\n  resize(newCapacity) {\n    const init = allocSharedRingBuffer(this.channels, newCapacity, this.rate, this.buffered);\n    const dst = new _SharedRingBuffer(init);\n    dst.#anchored = this.#anchored;\n    dst.#anchor = this.#anchor;\n    const state = Atomics.load(this.#state, 0);\n    const read = readOf(state);\n    const write = Atomics.load(this.#control, WRITE);\n    const latency = Atomics.load(this.#control, LATENCY);\n    const stalled = Atomics.load(this.#control, STALLED);\n    const available = write - read | 0;\n    const copyCount = Math.max(0, Math.min(available, dst.capacity));\n    const copyStart = write - copyCount | 0;\n    for (let channel = 0; channel < this.channels; channel++) {\n      const src = this.#samples[channel];\n      const out = dst.#samples[channel];\n      for (let i = 0; i < copyCount; i++) {\n        const idx = copyStart + i | 0;\n        out[slot(idx, dst.capacity)] = src[slot(idx, this.capacity)];\n      }\n    }\n    Atomics.store(dst.#control, TIMELINE, Atomics.load(this.#control, TIMELINE));\n    Atomics.store(dst.#state, 0, pack(epochOf(state), copyStart));\n    Atomics.store(dst.#control, WRITE, write);\n    Atomics.store(dst.#control, LATENCY, latency);\n    Atomics.store(dst.#control, STALLED, stalled);\n    dst.#position = this.#foldRead(read) + (copyStart - read | 0);\n    dst.#lastRead = copyStart;\n    return dst;\n  }\n  /**\n   * Fold an observed READ into `#position`, so the returned offset keeps counting up across\n   * the i32 wrap. Idempotent: folding the same value twice adds a zero delta.\n   */\n  #foldRead(read) {\n    this.#position += read - this.#lastRead | 0;\n    this.#lastRead = read;\n    return this.#position;\n  }\n  /** `#foldRead` against the current READ. */\n  #unwrapRead() {\n    return this.#foldRead(readOf(Atomics.load(this.#state, 0)));\n  }\n  /**\n   * Current playback timestamp derived from READ position.\n   *\n   * Main thread only, and stateful: it advances the unwrapped read position, so it has to be\n   * polled rather than sampled once. See `#position`.\n   */\n  get timestamp() {\n    return time_exports.Micro.fromSecond((this.#anchor + this.#unwrapRead()) / this.rate);\n  }\n  /** Whether the buffer is stalled (waiting to fill). */\n  get stalled() {\n    return Atomics.load(this.#control, STALLED) === 1;\n  }\n  /**\n   * Number of buffered samples (WRITE - READ).\n   *\n   * Non-atomic: WRITE and READ are loaded separately, so a concurrent\n   * writer/reader can make the two loads inconsistent. Intended for\n   * tests and diagnostics, not control-flow decisions.\n   */\n  get length() {\n    return Atomics.load(this.#control, WRITE) - readOf(Atomics.load(this.#state, 0)) | 0;\n  }\n};\n\n// src/audio/render-worklet.ts\nvar Render = class extends AudioWorkletProcessor {\n  // Set after init, depending on which path the main thread chose.\n  #backend;\n  #underflow = 0;\n  #stateCounter = 0;\n  constructor() {\n    super();\n    this.port.onmessage = (event) => {\n      const msg = event.data;\n      if (msg.type === \"init-shared\") {\n        console.log(\"[audio-worklet] init-shared: using SharedArrayBuffer path\");\n        const previous = this.#backend instanceof SharedRingBuffer ? this.#backend : void 0;\n        this.#backend = new SharedRingBuffer(msg, previous);\n        this.#underflow = 0;\n      } else if (msg.type === \"init-post\") {\n        console.log(\"[audio-worklet] init-post: using postMessage path\");\n        this.#backend = new AudioRingBuffer(msg);\n        this.#underflow = 0;\n      } else if (msg.type === \"data\") {\n        if (this.#backend instanceof AudioRingBuffer) this.#backend.write(msg.timestamp, msg.data);\n      } else if (msg.type === \"latency\") {\n        if (this.#backend instanceof AudioRingBuffer) this.#backend.resize(msg.latency);\n      } else if (msg.type === \"truncate\") {\n        if (this.#backend instanceof AudioRingBuffer) this.#backend.truncate(msg.timestamp);\n      } else if (msg.type === \"reset\") {\n        if (this.#backend instanceof AudioRingBuffer) this.#backend.reset();\n      }\n    };\n  }\n  process(_inputs, outputs, _parameters) {\n    const output = outputs[0];\n    const backend = this.#backend;\n    const samplesRead = backend?.read(output) ?? 0;\n    if (samplesRead < output[0].length) {\n      this.#underflow += output[0].length - samplesRead;\n    } else if (this.#underflow > 0 && backend) {\n      console.debug(`audio underflow: ${Math.round(1e3 * this.#underflow / backend.rate)}ms`);\n      this.#underflow = 0;\n    }\n    if (backend instanceof AudioRingBuffer) {\n      this.#stateCounter++;\n      if (this.#stateCounter >= 5) {\n        this.#stateCounter = 0;\n        const state = {\n          type: \"state\",\n          timestamp: backend.timestamp,\n          stalled: backend.stalled\n        };\n        this.port.postMessage(state);\n      }\n    }\n    return true;\n  }\n};\nregisterProcessor(\"render\", Render);\n"], { type: "application/javascript" }), we = URL.createObjectURL(Ce), Te = class {
+	#e = 0;
+	#t;
+	#n;
+	#r;
+	#i = 0;
+	#a;
+	get end() {
+		return this.#t;
+	}
+	clear(e = 0) {
+		this.#e = 0, this.#t = void 0, this.#i = e, this.#o();
+	}
+	update(e) {
+		let t = e.discontinuity !== this.#e;
+		return t && (this.#e = e.discontinuity, this.#t = void 0, this.#o()), e.frame && e.group !== this.#n && (this.#t = void 0), e.frame && this.#r === void 0 && (this.#r = e.frame.timestamp), e.end !== void 0 && (this.#t = e.end, this.#n = e.group), t;
+	}
+	span(e) {
+		let t = this.#r ?? e.timestamp;
+		this.#r = t;
+		let n = Math.floor(this.#i * e.sampleRate / 48e3), r = this.#a ?? n, i = Math.min(r, e.numberOfFrames);
+		this.#a = r - i;
+		let a = Math.round(n * 1e6 / e.sampleRate), o = Math.max(t, e.timestamp - a), s = e.numberOfFrames - i;
+		if (this.#t !== void 0) {
+			if (this.#t <= o) s = 0;
+			else {
+				let t = this.#t - o, n = Math.round(t * e.sampleRate / 1e6);
+				s = Math.min(s, n);
+			}
+		}
+		return {
+			timestamp: o,
+			frameOffset: i,
+			frames: s
+		};
+	}
+	#o() {
+		this.#r = void 0, this.#a = void 0;
+	}
+}, Ee = class {
+	#e;
+	constructor(e) {
+		this.#e = e;
+	}
+	drop() {
+		return this.#e !== 0 && (this.#e--, !0);
+	}
+}, De = 3, j = class {
+	in;
+	source;
+	sync;
+	#e = {
+		context: new a(void 0),
+		root: new a(void 0),
+		sampleRate: new a(void 0),
+		stats: new a(void 0),
+		timestamp: new a(void 0),
+		stalled: new a(!0),
+		buffered: new a([])
+	};
+	out = s(this.#e);
+	#t = new a([]);
+	#n;
+	#r = new a(void 0);
+	#i = new Te();
+	#a = new xe();
+	#o = new i();
+	#s;
+	#c;
+	constructor(e) {
+		this.in = { enabled: o(e?.enabled ?? !0) }, this.source = e.source, this.sync = e.sync, this.#o.cleanup(this.sync.register(this.source.out.jitter)), this.#s = this.#o.computed((e) => {
+			let t = e.get(this.source.out.config);
+			return t ? ve(t) : void 0;
+		}), this.#c = this.#o.computed((e) => {
+			let t = e.get(this.source.out.config);
+			return t ? k(t) : void 0;
+		}), this.#o.run(this.#l.bind(this)), this.#o.run(this.#u.bind(this)), this.#o.run(this.#d.bind(this)), this.#o.run(this.#f.bind(this));
+	}
+	#l(e) {
+		let t = e.get(this.#c);
+		if (!t) return;
+		let n = e.get(this.#r) ?? t.sampleRate, i = t.numberOfChannels;
+		e.set(this.#e.sampleRate, n);
+		let a = new AudioContext({
+			latencyHint: "interactive",
+			sampleRate: n
+		});
+		e.set(this.#e.context, a), e.cleanup(() => a.close()), e.spawn(async () => {
+			if (!await e.race(a.audioWorklet.addModule(we).then(() => !0))) return;
+			let t = new AudioWorkletNode(a, "render", {
+				channelCount: i,
+				channelCountMode: "explicit",
+				outputChannelCount: [i]
+			});
+			e.cleanup(() => t.disconnect());
+			let o = this.sync.out.delay.peek(), s = A(n, o), c = this.sync.out.buffered.peek(), l = le(t, i, n, s, c);
+			this.#n = l, e.cleanup(() => {
+				l.close(), this.#n = void 0;
+			}), e.run((e) => {
+				let t = r.Milli.fromMicro(e.get(l.timestamp));
+				this.#e.timestamp.set(t), this.#v(t);
+			}), e.run((e) => {
+				this.#e.stalled.set(e.get(l.stalled));
+			}), e.set(this.#e.root, t);
+		});
+	}
+	#u(e) {
+		if (!e.get(this.in.enabled)) return;
+		if (e.get(this.sync.in.delay) === "instant") {
+			this.reset();
+			return;
+		}
+		let t = e.get(this.#e.context);
+		t && d.Gesture.unlock(e, t);
+	}
+	#d(e) {
+		if (!e.get(this.#e.root)) return;
+		let t = this.#n;
+		if (!t) return;
+		let n = e.get(this.sync.out.delay);
+		t.setLatency(A(t.rate, n));
+	}
+	#f(e) {
+		if (!e.get(this.in.enabled) || e.get(this.sync.in.delay) === "instant") return;
+		let t = e.get(this.source.in.broadcast);
+		if (!t) return;
+		let n = e.get(this.source.out.track);
+		if (!n) return;
+		let r = e.get(this.#s);
+		if (!r) return;
+		let i = r.decoder, a = t.relativeBroadcast(e, r.broadcast);
+		if (!a) return;
+		this.#a.opened();
+		let o = _(e, {
+			broadcast: a,
+			track: n,
+			priority: c.PRIORITY.audio,
+			maxAge: this.sync.out.maxAge
+		});
+		o && (i.container.kind === "cmaf" ? this.#m(e, o, i) : this.#p(e, o, i));
+	}
+	#p(e, t, n) {
+		let i = n.codec === "opus" && n.description ? d.Opus.preSkip(d.Hex.toBytes(n.description)) : 0;
+		this.#i.clear(i);
+		let a = n.container.kind === "loc" ? new u.Loc.Format("audio") : new u.Legacy.Format(n), o = new u.Consumer(t, {
+			format: a,
+			maxAge: this.sync.out.maxAge
+		});
+		e.cleanup(() => o.close()), e.run((e) => {
+			let t = e.get(o.buffered), n = e.get(this.#t);
+			this.#e.buffered.update(() => u.mergeBufferedRanges(t, n));
+		}), e.spawn(async () => {
+			if (!await d.Libav.polyfill()) return;
+			let t = new Ee(De), i = new AudioDecoder({
+				output: (e) => {
+					let n = this.#i.span(e);
+					if (t.drop()) {
+						e.close();
+						return;
+					}
+					this.#h(e, n);
+				},
+				error: (e) => console.error("audio decoder error", e)
+			});
+			e.cleanup(() => {
+				i.state !== "closed" && i.close();
+			});
+			let a = n.codec === "opus" ? void 0 : n.description ? d.Hex.toBytes(n.description) : void 0, s = {
+				codec: n.codec,
+				sampleRate: n.sampleRate,
+				numberOfChannels: n.numberOfChannels,
+				description: a
+			};
+			for (i.configure(s);;) {
+				let e = await v(o);
+				if (!e) break;
+				if (this.#y(e) && (i.reset(), i.configure(s)), e.end !== void 0) continue;
+				let { frame: t } = e;
+				if (!t) continue;
+				let n = r.Milli.fromMicro(t.timestamp);
+				this.sync.received(n, "audio"), this.#e.stats.update((e) => ({ bytesReceived: (e?.bytesReceived ?? 0) + t.payload.byteLength })), await this.#n?.wait(t.timestamp);
+				let a = new EncodedAudioChunk({
+					type: t.keyframe ? "key" : "delta",
+					data: t.payload,
+					timestamp: t.timestamp
+				});
+				if (i.state === "closed") break;
+				i.decode(a);
+			}
+		});
+	}
+	#m(e, t, n) {
+		if (n.container.kind !== "cmaf") return;
+		let i = g(n.container.init), a = u.Cmaf.decodeInitSegment(i), o = n.description ? d.Hex.toBytes(n.description) : a.description, s = n.codec === "opus" && o ? d.Opus.preSkip(o) : 0;
+		this.#i.clear(s);
+		let c = n.codec === "opus" ? void 0 : n.description ? d.Hex.toBytes(n.description) : a.description, l = new u.Consumer(t, {
+			format: new u.Cmaf.Format(a),
+			maxAge: this.sync.out.maxAge
+		});
+		e.cleanup(() => l.close()), e.run((e) => {
+			let t = e.get(l.buffered), n = e.get(this.#t);
+			this.#e.buffered.update(() => u.mergeBufferedRanges(t, n));
+		}), e.spawn(async () => {
+			if (!await d.Libav.polyfill()) return;
+			let t = new AudioDecoder({
+				output: (e) => this.#h(e),
+				error: (e) => console.error("audio decoder error", e)
+			});
+			e.cleanup(() => {
+				t.state !== "closed" && t.close();
+			});
+			let i = {
+				codec: n.codec,
+				sampleRate: n.sampleRate,
+				numberOfChannels: n.numberOfChannels,
+				description: c
+			};
+			for (t.configure(i);;) {
+				let e = await v(l);
+				if (!e) break;
+				this.#y(e) && (t.reset(), t.configure(i));
+				let { frame: n } = e;
+				if (!n) continue;
+				let a = r.Milli.fromMicro(n.timestamp);
+				if (this.sync.received(a, "audio"), this.#e.stats.update((e) => ({ bytesReceived: (e?.bytesReceived ?? 0) + n.payload.byteLength })), await this.#n?.wait(n.timestamp), t.state === "closed") break;
+				t.decode(new EncodedAudioChunk({
+					type: n.keyframe ? "key" : "delta",
+					data: n.payload,
+					timestamp: n.timestamp
+				}));
+			}
+		});
+	}
+	#h(e, t = this.#i.span(e)) {
+		let { timestamp: n, frameOffset: i, frames: a } = t, o = r.Milli.fromMicro(n);
+		if (a === 0) {
+			e.close();
+			return;
+		}
+		let s = this.#n;
+		if (!s) {
+			e.close();
+			return;
+		}
+		if (e.sampleRate !== s.rate) {
+			this.#r.set(e.sampleRate), e.close();
+			return;
+		}
+		let c = a / e.sampleRate * 1e6, l = r.Milli.fromMicro(c), u = r.Milli.add(o, l);
+		this.#a.takeover() && (s.truncate(n), this.#_(o)), this.#g(o, u);
+		let d = Math.min(e.numberOfChannels, s.channels), f = [];
+		for (let t = 0; t < d; t++) {
+			let n = new Float32Array(a);
+			e.copyTo(n, {
+				format: "f32-planar",
+				planeIndex: t,
+				frameOffset: i,
+				frameCount: a
+			}), f.push(n);
+		}
+		s.insert(n, f), e.close();
+	}
+	#g(e, t) {
+		e > t || this.#t.mutate((n) => {
+			for (let i of n) if (e <= i.end + 1 && t >= i.start) {
+				i.start = r.Milli.min(i.start, e), i.end = r.Milli.max(i.end, t);
+				return;
+			}
+			n.push({
+				start: e,
+				end: t
+			}), n.sort((e, t) => e.start - t.start);
+		});
+	}
+	#_(e) {
+		this.#t.mutate((t) => {
+			for (; t.length > 0 && t[t.length - 1].start >= e;) t.pop();
+			let n = t[t.length - 1];
+			n && n.end > e && (n.end = e);
+		});
+	}
+	#v(e) {
+		this.#t.mutate((t) => {
+			for (; t.length > 0;) {
+				if (t[0].end >= e) {
+					t[0].start = r.Milli.max(t[0].start, e);
+					break;
+				}
+				t.shift();
+			}
+		});
+	}
+	reset() {
+		this.#n?.reset();
+	}
+	#y(e) {
+		return this.#i.update(e) ? (this.#n?.reset(), this.sync.reset(), !0) : !1;
+	}
+	close() {
+		this.#o.close();
+	}
+	static supported = Oe;
+};
+async function Oe(e) {
+	if (!c.containerSupported(e.container)) {
+		let t = e.container.kind === "unknown" ? e.container.raw.kind : e.container.kind;
+		return console.warn(`audio: ignoring rendition with unknown container: ${t}`), !1;
+	}
+	e.codec === "opus" && !d.Opus.supportsRate(e.sampleRate) && console.warn(`audio: opus advertised at ${e.sampleRate}Hz, which some browsers cannot decode`);
+	let t;
+	if (e.codec !== "opus") {
+		if (e.description) t = d.Hex.toBytes(e.description);
+		else if (e.container.kind === "cmaf") try {
+			t = u.Cmaf.decodeInitSegment(g(e.container.init)).description;
+		} catch (t) {
+			return console.warn(`audio: malformed CMAF init segment for codec ${e.codec}`, t), !1;
+		}
+	}
+	return (await AudioDecoder.isConfigSupported({
+		...e,
+		description: t
+	})).supported ?? !1;
+}
+//#endregion
+//#region src/audio/emitter.ts
+var ke = .001, M = .2, Ae = class {
+	source;
+	in;
+	#e = { enabled: new a(!1) };
+	out = s(this.#e);
+	#t = new i();
+	#n = new a(void 0);
+	constructor(e) {
+		this.source = e.source, this.in = {
+			volume: o(e?.volume ?? .5),
+			muted: o(e?.muted ?? !1),
+			paused: o(e?.paused ?? !1)
+		}, this.#t.run((e) => {
+			let t = !e.get(this.in.paused) && !e.get(this.in.muted);
+			this.#e.enabled.set(t);
+		}), this.#t.run((e) => {
+			let t = e.get(this.source.out.root);
+			if (!t) return;
+			let n = new GainNode(t.context, { gain: e.get(this.in.volume) });
+			t.connect(n), e.set(this.#n, n), e.run((e) => {
+				e.get(this.#e.enabled) && (n.connect(t.context.destination), e.cleanup(() => n.disconnect()));
+			});
+		}), this.#t.run((e) => {
+			let t = e.get(this.#n);
+			if (!t) return;
+			e.cleanup(() => t.gain.cancelScheduledValues(t.context.currentTime));
+			let n = e.get(this.in.volume);
+			n < ke ? (t.gain.exponentialRampToValueAtTime(ke, t.context.currentTime + M), t.gain.setValueAtTime(0, t.context.currentTime + M + .01)) : t.gain.exponentialRampToValueAtTime(n, t.context.currentTime + M);
+		});
+	}
+	close() {
+		this.#t.close();
+	}
+}, N = class {
+	in;
+	#e = {
+		catalog: new a(void 0),
+		available: new a({}),
+		track: new a(void 0),
+		config: new a(void 0),
+		jitter: new a(void 0)
+	};
+	out = s(this.#e);
+	#t = new i();
+	constructor(e) {
+		this.in = {
+			broadcast: o(e?.broadcast),
+			target: o(e?.target),
+			supported: o(e?.supported)
+		}, this.#t.run(this.#n.bind(this)), this.#t.run(this.#r.bind(this)), this.#t.run(this.#i.bind(this));
+	}
+	#n(e) {
+		let t = e.get(this.in.broadcast);
+		if (!t) return;
+		let n = e.get(t.out.catalog)?.audio;
+		n && e.set(this.#e.catalog, n);
+	}
+	#r(e) {
+		let t = e.get(this.#e.catalog)?.renditions ?? {}, n = e.get(this.in.supported);
+		n && e.spawn(async () => {
+			let r = {};
+			for (let [i, a] of Object.entries(t)) {
+				let t = await e.race(n(a));
+				if (e.abort.aborted) return;
+				t && (r[i] = a);
+			}
+			Object.keys(r).length === 0 && Object.keys(t).length > 0 && console.warn("no supported audio renditions found:", t), this.#e.available.set(r);
+		});
+	}
+	#i(e) {
+		let t = e.get(this.#e.available);
+		if (Object.keys(t).length === 0) return;
+		let n = e.get(this.in.target), r;
+		if (n?.name && n.name in t) r = {
+			track: n.name,
+			config: t[n.name]
+		};
+		else if (r = this.#a(t), !r) return;
+		e.set(this.#e.track, r.track), e.set(this.#e.config, r.config), e.set(this.#e.jitter, ye(r.config));
+	}
+	#a(e) {
+		let t = Object.entries(e);
+		if (t.length !== 0) {
+			for (let [e, n] of t) if (n.container.kind === "legacy") return {
+				track: e,
+				config: n
+			};
+			for (let [e, n] of t) if (n.container.kind === "loc") return {
+				track: e,
+				config: n
+			};
+			for (let [e, n] of t) if (n.container.kind === "cmaf") return {
+				track: e,
+				config: n
+			};
+		}
+	}
+	close() {
+		this.#t.close();
+	}
+}, je = 48e3, P = 2;
+function Me(e) {
+	let t = "";
+	for (let n = 0; n < e.length; n++) t += e[n].toString(16).padStart(2, "0");
+	return t;
+}
+function F(e) {
+	let t;
+	try {
+		t = e.initData ? g(e.initData) : void 0;
+	} catch {
+		t = void 0;
+	}
+	let n = t ? Me(t) : void 0;
+	switch (e.packaging) {
+		case "cmaf": return !e.initData || !t ? void 0 : {
+			container: {
+				kind: "cmaf",
+				init: e.initData
+			},
+			description: void 0
+		};
+		case "loc": return {
+			container: { kind: "loc" },
+			description: n
+		};
+		case "legacy": return {
+			container: { kind: "legacy" },
+			description: n
+		};
+		default: return;
+	}
+}
+function I(e) {
+	if (!(e <= 0)) return l(Math.ceil(e));
+}
+function Ne(e) {
+	if (!e.codec) return;
+	let t = F(e);
+	if (!t) return;
+	let { container: n, description: r } = t;
+	return {
+		codec: e.codec,
+		container: n,
+		description: r,
+		codedWidth: e.width == null ? void 0 : l(e.width),
+		codedHeight: e.height == null ? void 0 : l(e.height),
+		framerate: e.framerate,
+		bitrate: e.bitrate == null ? void 0 : l(e.bitrate),
+		stalled: e.stalled,
+		jitter: e.jitter == null ? void 0 : l(e.jitter),
+		delay: e.delay == null ? void 0 : I(e.delay)
+	};
+}
+function Pe(e) {
+	if (!e.codec) return;
+	let t = (() => {
+		if (!e.channelConfig) return P;
+		let t = Number.parseInt(e.channelConfig, 10);
+		return Number.isFinite(t) ? t : P;
+	})(), n = F(e);
+	if (!n) return;
+	let { container: r, description: i } = n;
+	return {
+		codec: e.codec,
+		container: r,
+		description: i,
+		sampleRate: l(e.samplerate ?? je),
+		numberOfChannels: l(t),
+		bitrate: e.bitrate == null ? void 0 : l(e.bitrate),
+		jitter: e.jitter == null ? void 0 : l(e.jitter),
+		delay: e.delay == null ? void 0 : I(e.delay),
+		language: e.lang
+	};
+}
+function Fe(e) {
+	let t = {}, n = {};
+	for (let r of e.tracks) if (r.role === "video") {
+		let e = Ne(r);
+		e && (t[r.name] = e);
+	} else if (r.role === "audio") {
+		let e = Pe(r);
+		e && (n[r.name] = e);
+	}
+	let r = {};
+	return Object.keys(t).length > 0 && (r.video = { renditions: t }), Object.keys(n).length > 0 && (r.audio = { renditions: n }), r;
+}
+//#endregion
+//#region src/broadcast.ts
+function L(e, t) {
+	return Object.fromEntries(Object.entries(e).filter(([, e]) => t(e.broadcast)));
+}
+function Ie(e, t) {
+	return {
+		...e,
+		video: e.video ? {
+			...e.video,
+			renditions: L(e.video.renditions, t)
+		} : void 0,
+		audio: e.audio ? {
+			...e.audio,
+			renditions: L(e.audio.renditions, t)
+		} : void 0,
+		text: e.text ? {
+			...e.text,
+			renditions: L(e.text.renditions, t)
+		} : void 0,
+		json: e.json ? {
+			...e.json,
+			tracks: L(e.json.tracks, t)
+		} : void 0,
+		binary: e.binary ? {
+			...e.binary,
+			tracks: L(e.binary.tracks, t)
+		} : void 0
+	};
+}
+var Le = [
+	...c.FORMATS,
+	"hangz",
+	"manual"
+], R = class {
+	in;
+	#e = {
+		status: new a("offline"),
+		active: new a(void 0),
+		catalog: new a(void 0)
+	};
+	out = s(this.#e);
+	#t = new a(void 0);
+	#n = new a(!1);
+	#r = new a(void 0);
+	#i;
+	constructor(e) {
+		if (e && "reload" in e) throw Error("Watch.Broadcast: `reload` was renamed to `announced`");
+		this.#i = new i(), this.in = {
+			origin: o(e?.origin),
+			name: o(e?.name ?? n.empty()),
+			enabled: o(e?.enabled ?? !0),
+			announced: o(e?.announced ?? !0),
+			catalogFormat: o(e?.catalogFormat),
+			catalog: o(e?.catalog)
+		}, this.#i.run(this.#a.bind(this)), this.#i.run(this.#l.bind(this)), this.#i.run(this.#u.bind(this)), this.#i.run(this.#o.bind(this));
+	}
+	#a(t) {
+		if (this.#t.set(void 0), !t.get(this.#n) || !t.get(this.in.announced)) return;
+		let n = t.get(this.in.origin);
+		if (!n) return;
+		let r = n.announced();
+		t.cleanup(() => r.close()), this.#t.set(/* @__PURE__ */ new Set()), t.spawn(async () => {
+			for (;;) {
+				let n = await t.race(r.next());
+				if (!n) break;
+				this.#t.mutate((t) => {
+					t && (e.isActive(n.kind) ? t.add(n.prefix) : t.delete(n.prefix));
+				});
+			}
+		});
+	}
+	#o(e) {
+		let t = e.get(this.#r);
+		e.set(this.#e.catalog, t ? Ie(t, (t) => this.#d(e, t) !== void 0) : void 0);
+	}
+	#s(e, t) {
+		this.#n.set(!0);
+		let r = e.get(this.#t);
+		if (!r) return !1;
+		if (r.has(t)) return !0;
+		for (let e of r) if (n.hasPrefix(e, t)) return !0;
+		return !1;
+	}
+	#c(e, t, n) {
+		let r = t.request(n);
+		return e.cleanup(() => r.close()), e.get(r.active);
+	}
+	#l(e) {
+		if (!e.get(this.in.enabled)) return;
+		let t = e.get(this.in.origin);
+		if (!t) return;
+		let n = e.get(this.in.name);
+		if (!e.get(this.in.announced)) {
+			e.set(this.#e.active, this.#c(e, t, n), void 0);
+			return;
+		}
+		let r = t.request(n, { announced: !0 });
+		e.cleanup(() => r.close()), e.run((e) => {
+			e.set(this.#e.active, e.get(r.active), void 0);
+		});
+	}
+	#u(e) {
+		if (!e.get(this.in.enabled)) return;
+		let n = e.get(this.in.catalogFormat), r = e.get(this.in.name), i = n ?? c.detectFormat(r) ?? c.DEFAULT_FORMAT;
+		if (i === "manual") {
+			let t = e.get(this.in.catalog), n;
+			try {
+				n = t && c.checkResolvable(c.checkRenditions(t), r);
+			} catch (e) {
+				console.error("rejecting catalog", r, e);
+			}
+			this.#r.set(n, !0), e.cleanup(() => this.#r.set(void 0, !0)), this.#e.status.set(n ? "live" : "loading");
+			return;
+		}
+		let a = e.get(this.out.active);
+		if (!a || e.get(a.closed) !== void 0) return;
+		this.#e.status.set("loading");
+		let o = i === "hang" ? c.TRACK : i === "hangz" ? c.TRACK_COMPRESSED : "catalog", s = a.track(o).subscribe({ priority: c.PRIORITY.catalog });
+		e.cleanup(() => s.close());
+		let l;
+		if (i === "hang" || i === "hangz") {
+			let e = new f.Snapshot.Consumer({
+				track: s,
+				schema: c.RootSchema,
+				compression: i === "hangz" ? "deflate" : "none"
+			});
+			l = () => e.next();
+		} else {
+			let e = s.ordered();
+			l = async () => {
+				let t = await p.fetch(e);
+				return t ? Fe(t) : void 0;
+			};
+		}
+		e.spawn(async () => {
+			try {
+				for (;;) {
+					let t = await e.race(l());
+					if (!t) break;
+					console.debug("received catalog", i, this.in.name.peek(), t), this.#r.set(c.checkResolvable(c.checkRenditions(t), r), !0), this.#e.status.set("live");
+				}
+			} catch (e) {
+				e instanceof t.Stream ? console.debug("catalog subscription ended", this.in.name.peek(), e) : console.error("error fetching catalog", this.in.name.peek(), e);
+			} finally {
+				this.#r.set(void 0), this.#e.status.set("offline");
+			}
+		});
+	}
+	#d(e, t) {
+		if (!t) return { local: !0 };
+		let r = e.get(this.in.name), i = n.tryResolve(r, t);
+		if (i === void 0) {
+			console.warn("ignoring rendition: broadcast reference escapes the root", r, t);
+			return;
+		}
+		if (i === r) return { local: !0 };
+		let a = e.get(this.in.origin);
+		if (!a || !(e.get(this.in.announced) && e.get(a.discovery) !== !1 && !this.#s(e, i))) return {
+			local: !1,
+			path: i
+		};
+	}
+	relativeBroadcast(e, t) {
+		let n = this.#d(e, t);
+		if (!n) return;
+		if (n.local) return e.get(this.out.active);
+		if (!e.get(this.in.enabled)) return;
+		let r = e.get(this.in.origin);
+		if (r) return this.#c(e, r, n.path);
+	}
+	close() {
+		this.#i.close();
+	}
+}, Re = r.Milli(20), z = r.Milli(100), B = class e {
+	in;
+	#e = {
+		reference: new a(void 0),
+		delay: new a(r.Milli.zero),
+		jitter: new a(z),
+		timestamp: new a(void 0),
+		buffered: new a(!1),
+		maxAge: new a(r.Milli.zero)
+	};
+	out = s(this.#e);
+	#t = /* @__PURE__ */ new Map();
+	#n;
+	#r = new a([]);
+	#i = new i();
+	constructor(e) {
+		this.in = {
+			delay: o(e?.delay ?? "auto"),
+			buffer: o(e?.buffer ?? r.Milli.zero),
+			probe: o(e?.probe)
+		}, this.#i.run(this.#o.bind(this)), this.#i.run(this.#s.bind(this)), this.#i.run(this.#a.bind(this));
+	}
+	register(e) {
+		let t = { jitter: e };
+		return this.#r.update((e) => [...e, t]), () => this.#r.update((e) => e.filter((e) => e !== t));
+	}
+	#a(e) {
+		let t = e.get(this.#e.delay), n = e.get(this.in.delay) === "instant" ? r.Milli.zero : e.get(this.in.buffer);
+		this.#e.buffered.set(n > 0), this.#e.maxAge.set(r.Milli.add(t, n));
+	}
+	#o(e) {
+		let t = e.get(this.in.delay);
+		if (t === "instant") {
+			this.#n = void 0, this.#e.jitter.set(r.Milli.zero);
+			return;
+		}
+		if (typeof t == "number") {
+			this.#n = void 0, this.#e.jitter.set(t);
+			return;
+		}
+		let n = e.get(this.in.probe)?.rtt;
+		if (n !== void 0) {
+			this.#n = this.#n === void 0 ? n : Math.min(this.#n, n);
+			let e = r.Milli(Math.max(Re, this.#n * 1.25));
+			this.#e.jitter.set(e);
+			return;
+		}
+		this.#n = void 0, this.#e.jitter.set(z);
+	}
+	#s(e) {
+		let t = e.get(this.#e.jitter), n = r.Milli.zero;
+		for (let t of e.get(this.#r)) n = r.Milli.max(n, e.get(t.jitter) ?? r.Milli.zero);
+		let i = e.get(this.in.delay) === "instant" ? r.Milli.zero : r.Milli.add(n, t);
+		this.#e.delay.set(i);
+	}
+	received(t, n = "") {
+		this.#e.timestamp.update((e) => e === void 0 || t > e ? t : e);
+		let i = r.Milli.now(), a = r.Milli.sub(i, t), o = this.#e.reference.peek();
+		if (o === void 0) {
+			this.#e.reference.set(a);
+			return;
+		}
+		let s = this.#e.delay.peek(), c = r.Milli.add(r.Milli.sub(o, a), s);
+		if (c < 0) {
+			let e = this.#t.get(n);
+			e ? (e.count++, e.maxMs = Math.max(e.maxMs, -c)) : this.#t.set(n, {
+				count: 1,
+				maxMs: -c
+			});
+		} else {
+			let t = this.#t.get(n);
+			if (t) {
+				let r = n ? `sync[${n}]` : "sync", i = e.#l(t.maxMs);
+				console.debug(`${r}: ${t.count} late frame(s), max ${i} behind`), this.#t.delete(n);
+			}
+		}
+		if (a >= o) return;
+		let l = this.#e.maxAge.peek();
+		c <= l || this.#e.reference.set(r.Milli.add(a, r.Milli.sub(l, s)));
+	}
+	reset() {
+		this.#e.reference.set(void 0), this.#t.clear();
+	}
+	now() {
+		let e = this.#e.reference.peek();
+		if (e !== void 0) return r.Milli.sub(r.Milli.sub(r.Milli.now(), e), this.#e.delay.peek());
+	}
+	async wait(e) {
+		if (this.in.delay.peek() !== "instant") {
+			if (this.#e.reference.peek() === void 0) throw Error("reference not set; call received() first");
+			for (;;) {
+				if (this.in.delay.peek() === "instant") return;
+				let t = r.Milli.now(), n = r.Milli.sub(t, e), i = this.#e.reference.peek();
+				if (i === void 0) return;
+				let a = r.Milli.add(r.Milli.sub(i, n), this.#e.delay.peek());
+				if (a <= 0 || a < 5 || await this.#c(a)) return;
+			}
+		}
+	}
+	#c(e) {
+		return new Promise((t) => {
+			let n = (e) => {
+				clearTimeout(r);
+				for (let e of i) e();
+				t(e);
+			}, r = setTimeout(() => n(!0), e), i = [
+				this.in.delay.changed(() => n(!1)),
+				this.#e.delay.changed(() => n(!1)),
+				this.#e.reference.changed(() => n(!1))
+			];
+		});
+	}
+	static #l(e) {
+		if (e = Math.round(e), e < 1e3) return `${e}ms`;
+		let t = e / 1e3;
+		if (t < 60) return `${Math.round(t * 10) / 10}s`;
+		let n = t / 60;
+		return `${Math.round(n * 10) / 10}m`;
+	}
+	close() {
+		this.#i.close();
+	}
+}, ze = ":where([part=captions]){--overlay-padding:1%;--cue-color:white;--cue-bg-color:#000c;--cue-font-size:calc(var(--overlay-height) / 100 * 5);--cue-line-height:calc(var(--cue-font-size) * 1.2);--cue-padding-x:calc(var(--cue-font-size) * .6);--cue-padding-y:calc(var(--cue-font-size) * .4);z-index:1;contain:content;margin:var(--overlay-padding);font-size:var(--cue-font-size);box-sizing:border-box;pointer-events:none;user-select:none;word-spacing:normal;word-break:break-word;font-family:sans-serif;position:absolute;inset:0}:where([part=captions]>[part=cue-display]){contain:content;top:var(--cue-top);left:var(--cue-left);right:var(--cue-right);bottom:var(--cue-bottom);width:var(--cue-width,auto);height:var(--cue-height,auto);box-sizing:border-box;transform:var(--cue-transform);text-align:var(--cue-text-align);writing-mode:var(--cue-writing-mode,unset);white-space:pre-line;direction:ltr;unicode-bidi:plaintext;min-width:min-content;min-height:min-content;position:absolute;overflow:visible}:where([data-dir=rtl] [part=cue-display]){direction:rtl}:where([part=captions] [part=cue]){padding:var(--cue-padding-y) var(--cue-padding-x);line-height:var(--cue-line-height);background-color:var(--cue-bg-color);box-sizing:border-box;color:var(--cue-color);box-shadow:var(--cue-box-shadow);white-space:var(--cue-white-space,pre-wrap);outline:var(--cue-outline);text-shadow:var(--cue-text-shadow);display:inline-block}:where([part=captions] [part=cue-display][data-vertical] [part=cue]){padding:var(--cue-padding-x) var(--cue-padding-y)}\n:where([part=captions] [part=region]){width:var(--region-width);height:var(--region-height);min-height:0;max-height:var(--region-height);writing-mode:horizontal-tb;top:calc(var(--region-top,var(--overlay-height) * var(--region-viewport-anchor-y) / 100 - var(--region-height) * var(--region-anchor-y) / 100));left:var(--region-left,calc(calc(var(--region-viewport-anchor-x) * 1%) - calc(var(--region-width) * var(--region-anchor-x) / 100)));right:var(--region-right);bottom:var(--region-bottom);overflow-wrap:break-word;box-sizing:border-box;flex-flow:column;justify-content:flex-start;display:inline-flex;position:absolute;overflow:hidden}:where([part=captions] [part=region][data-scroll=up]){justify-content:end}:where([part=captions] [part=region][data-active][data-scroll=up]){transition:top .433s}:where([part=captions] [part=region]>[part=cue-display]){width:auto;left:var(--cue-offset);height:var(--cue-height,auto);text-align:var(--cue-text-align);unicode-bidi:plaintext;margin-top:1px;position:relative}:where([part=captions] [part=region] [part=cue]){padding:calc(var(--cue-padding-y) / 2) var(--cue-padding-x);border-radius:0;position:relative}", Be = r.Milli(3e4), Ve = r.Milli(3e4), He = r.Milli(1e3);
+function V(e) {
+	return e.replaceAll("&", "&amp;amp;").replaceAll("<", "&amp;lt;").replaceAll(">", "&amp;gt;").replaceAll("\"", "&amp;quot;");
+}
+function H(e, t) {
+	let n = e.length;
+	for (; n > 0 && e[n - 1].startTime > t.startTime;) n--;
+	e.splice(n, 0, t);
+}
+function U(e, t) {
+	let { cues: n, clears: r } = e, i = 0;
+	for (let e of r) e >= t && (r[i++] = e);
+	r.length = i;
+	let a = 0;
+	for (let e of n) e.endTime >= t && (n[a++] = e);
+	return a !== n.length && (n.length = a, !0);
+}
+function W(e, t) {
+	let { cues: n, clears: r } = e, i = n.indexOf(t), a = i > 0 ? n[i - 1] : void 0;
+	a && a.endTime > t.startTime && (a.endTime = t.startTime);
+	let o = n[i + 1];
+	o && t.endTime > o.startTime && (t.endTime = o.startTime);
+	let s = r.find((e) => e > t.startTime);
+	s !== void 0 && t.endTime > s && (t.endTime = s);
+}
+function G(e, t) {
+	let { cues: n, clears: r } = e, i = r.length;
+	for (; i > 0 && r[i - 1] > t;) i--;
+	r[i] !== t && r.splice(i, 0, t);
+	for (let e = n.length - 1; e >= 0; e--) {
+		let r = n[e];
+		if (!(r.startTime > t)) {
+			r.endTime > t && (r.endTime = t);
+			return;
+		}
+	}
+}
+var K = class {
+	source;
+	sync;
+	in;
+	#e = new i();
+	#t = !1;
+	constructor(e) {
+		this.source = e.source, this.sync = e.sync, this.in = {
+			container: o(e?.container),
+			enabled: o(e?.enabled ?? !0)
+		}, this.#e.run(this.#n.bind(this));
+	}
+	#n(e) {
+		let n = e.getAll([
+			this.in.enabled,
+			this.in.container,
+			this.source.out.track,
+			this.source.out.config,
+			this.source.in.broadcast
+		]);
+		if (!n) return;
+		let [r, i, a, o, s] = n, l = s.relativeBroadcast(e, o.broadcast);
+		if (!l) return;
+		this.#t = !1;
+		let d;
+		if (o.container.kind === "legacy") d = new u.Legacy.Format("data");
+		else if (o.container.kind === "loc") d = new u.Loc.Format();
+		else {
+			console.warn(`captions: unsupported container "${o.container.kind}" for track ${a}`);
+			return;
+		}
+		let f = document.createElement("style");
+		f.textContent = ze, i.appendChild(f), e.cleanup(() => f.remove());
+		let p = document.createElement("div");
+		p.style.position = "absolute", p.style.inset = "0", p.style.pointerEvents = "none", i.appendChild(p), e.cleanup(() => p.remove());
+		let m = new ee(p);
+		e.cleanup(() => m.destroy());
+		let h = _(e, {
+			broadcast: l,
+			track: a,
+			priority: c.PRIORITY.text,
+			maxAge: this.sync.out.maxAge
+		});
+		if (!h) return;
+		let g = {
+			cues: [],
+			regions: /* @__PURE__ */ new Map(),
+			clears: []
+		}, v = () => m.changeTrack({
+			cues: [...g.cues],
+			regions: [...g.regions.values()]
+		}), y = () => {
+			let t = this.sync.now();
+			t !== void 0 && (m.currentTime = t / 1e3, U(g, (t - Be) / 1e3) && v()), e.animate(y);
+		};
+		e.animate(y), e.spawn(async () => {
+			for (;;) {
+				let n = await h.recvGroup().catch((e) => {
+					if (!(e instanceof t.Stream)) throw e;
+					console.debug("captions subscription ended", e);
+				});
+				if (!n) break;
+				e.spawn(async () => {
+					try {
+						for (;;) {
+							let e = await n.readFrame();
+							if (!e) break;
+							for (let t of d.decode(e)) await this.#r(o.format, t, g);
+						}
+					} catch (e) {
+						if (!(e instanceof t.Stream)) throw e;
+					} finally {
+						n.close();
+					}
+					v();
+				});
+			}
+		});
+	}
+	async #r(e, t, n) {
+		let r = new TextDecoder().decode(t.payload), i = t.timestamp / 1e6;
+		if (e === "utf8") {
+			if (r.length === 0) {
+				G(n, i);
+				return;
+			}
+			let e = new m(i, i + Ve / 1e3, V(r));
+			H(n.cues, e), W(n, e);
+			return;
+		}
+		if (r.length === 0) return;
+		let a;
+		try {
+			a = await h(r, { type: "vtt" });
+		} catch (e) {
+			console.warn("captions: failed to parse VTT cue", e);
+			return;
+		}
+		let o = a.cues.at(0);
+		!this.#t && o && Math.abs(o.startTime - i) > He / 1e3 && (this.#t = !0, console.warn(`captions: cue timing is ${(o.startTime - i).toFixed(3)}s off its frame timestamp; the payload must carry absolute times on the media clock`));
+		for (let e of a.regions) n.regions.set(e.id, e);
+		for (let e of a.cues) e.text = V(e.text), H(n.cues, e);
+	}
+	close() {
+		this.#e.close();
+	}
+}, Ue = /* @__PURE__ */ new Set(["vtt", "utf8"]);
+function q(e) {
+	return Ue.has(e.format);
+}
+var J = class {
+	in;
+	#e = {
+		catalog: new a(void 0),
+		available: new a({}),
+		track: new a(void 0),
+		config: new a(void 0)
+	};
+	out = s(this.#e);
+	#t = new i();
+	constructor(e) {
+		this.in = {
+			broadcast: o(e?.broadcast),
+			target: o(e?.target)
+		}, this.#t.run(this.#n.bind(this)), this.#t.run(this.#r.bind(this));
+	}
+	#n(e) {
+		let t = e.get(this.in.broadcast), n = t ? e.get(t.out.catalog)?.text : void 0;
+		e.set(this.#e.catalog, n), this.#e.available.set(n?.renditions ?? {});
+	}
+	#r(e) {
+		let t = e.get(this.#e.available), n = e.get(this.in.target), r = n ? t[n] : void 0;
+		if (!n || !r) {
+			e.set(this.#e.track, void 0), e.set(this.#e.config, void 0);
+			return;
+		}
+		q(r) || console.warn(`captions: unsupported format ${JSON.stringify(r.format)} for track ${n}`), e.set(this.#e.track, n), e.set(this.#e.config, r);
+	}
+	close() {
+		this.#t.close();
+	}
+}, Y = Symbol("supportCacheKey");
+function X(e) {
+	return {
+		broadcast: e.broadcast,
+		decoder: {
+			codec: e.codec,
+			container: e.container,
+			description: e.description,
+			displayAspectWidth: e.displayAspectWidth,
+			displayAspectHeight: e.displayAspectHeight,
+			optimizeForLatency: e.optimizeForLatency ?? !0
+		}
+	};
+}
+function We(e) {
+	return JSON.stringify(X(e).decoder);
+}
+//#endregion
+//#region src/video/playhead.ts
+var Ge = r.Milli(100);
+function Ke(e) {
+	let t;
+	return e.jitter === void 0 ? e.framerate && (t = r.Milli(Math.ceil(1e3 / e.framerate))) : t = r.Milli(e.jitter), e.delay === void 0 ? t : r.Milli.add(r.Milli(e.delay), t ?? r.Milli.zero);
+}
+function qe(e) {
+	return e.active === void 0 || r.Milli.add(e.playhead, Ge) >= e.active;
+}
+function Je(e) {
+	return e.active === void 0 ? e.pending : e.pending === void 0 ? e.active : r.Milli.max(e.active, e.pending);
+}
+//#endregion
+//#region src/video/presentation.ts
+function Ye(e = 0) {
+	let t = (e % 360 + 360) % 360;
+	return Math.round(t / 90) % 4 * 90;
+}
+function Xe(e, t = 0) {
+	let n = Ye(t);
+	return n === 90 || n === 270 ? {
+		width: e.height,
+		height: e.width
+	} : {
+		width: e.width,
+		height: e.height
+	};
+}
+function Z(e) {
+	return Object.is(e, -0) ? 0 : e;
+}
+function Ze(e, t) {
+	let [n, r, i, a, o, s] = e;
+	return [
+		Z(-n),
+		Z(r),
+		Z(-i),
+		Z(a),
+		Z(t - o),
+		Z(s)
+	];
+}
+function Qe(e, t) {
+	let n = Ye(t?.rotation), r = Xe(e, n), i;
+	switch (n) {
+		case 90:
+			i = [
+				0,
+				1,
+				-1,
+				0,
+				e.width,
+				0
+			];
+			break;
+		case 180:
+			i = [
+				-1,
+				0,
+				0,
+				-1,
+				e.width,
+				e.height
+			];
+			break;
+		case 270:
+			i = [
+				0,
+				-1,
+				1,
+				0,
+				0,
+				e.height
+			];
+			break;
+		default: i = [
+			1,
+			0,
+			0,
+			1,
+			0,
+			0
+		];
+	}
+	return t?.flip && (i = Ze(i, e.width)), {
+		matrix: i,
+		source: r
+	};
+}
+//#endregion
+//#region src/video/decoder.ts
+var $e = r.Milli(500), Q = class {
+	in;
+	source;
+	sync;
+	#e = {
+		frame: new a(void 0),
+		timestamp: new a(void 0),
+		display: new a(void 0),
+		stalled: new a(!1),
+		stats: new a(void 0),
+		jitter: new a(void 0),
+		buffered: new a([])
+	};
+	out = s(this.#e);
+	#t = new a(void 0);
+	#n = new a(void 0);
+	#r;
+	#i = new i();
+	#a() {
+		this.#e.frame.update((e) => {
+			e?.close();
+		}), this.#e.timestamp.set(void 0);
+	}
+	constructor(e) {
+		this.in = { enabled: o(e?.enabled ?? !0) }, this.source = e.source, this.sync = e.sync, this.#i.cleanup(this.sync.register(this.out.jitter)), this.#r = this.#i.computed((e) => {
+			let t = e.get(this.source.out.config);
+			return t ? X(t) : void 0;
+		}), this.#i.run(this.#o.bind(this)), this.#i.run(this.#s.bind(this)), this.#i.run(this.#c.bind(this)), this.#i.run(this.#l.bind(this)), this.#i.run(this.#u.bind(this));
+	}
+	#o(e) {
+		let t = (t, n) => {
+			if (t === void 0 || n === void 0) return;
+			let r = e.get(n)?.video?.renditions?.[t];
+			return r && Ke(r);
+		}, n = e.get(this.#t), r = t(n?.track, n?.catalog), i = e.get(this.#n), a = t(i?.track, i?.catalog);
+		e.set(this.#e.jitter, Je({
+			active: r,
+			pending: a
+		}));
+	}
+	#s(e) {
+		let t = e.getAll([
+			this.in.enabled,
+			this.source.in.broadcast,
+			this.source.out.track,
+			this.#r
+		]);
+		if (!t) {
+			this.#t.set(void 0);
+			return;
+		}
+		let [n, r, i, a] = t, o = r.relativeBroadcast(e, a.broadcast);
+		if (!o) {
+			this.#t.set(void 0), this.#a(), this.#e.buffered.set([]);
+			return;
+		}
+		let s = new et({
+			sync: this.sync,
+			broadcast: o,
+			track: i,
+			config: a.decoder,
+			stats: this.#e.stats,
+			catalog: r.out.catalog
+		});
+		e.set(this.#n, {
+			track: i,
+			catalog: r.out.catalog
+		}), e.cleanup(() => s?.close()), e.run((e) => {
+			if (!s) return;
+			let t = e.get(this.#t);
+			if (t) {
+				let n = e.get(s.timestamp);
+				if (n === void 0 || !qe({
+					playhead: n,
+					active: e.get(t.timestamp)
+				})) return;
+			}
+			this.#t.set(s), this.#n.set(void 0), s = void 0, e.close();
+		});
+	}
+	#c(e) {
+		let t = e.get(this.#t);
+		if (!t) {
+			this.#e.buffered.set([]);
+			return;
+		}
+		e.cleanup(() => t.close()), e.run((e) => {
+			let n = e.get(t.frame);
+			n && (this.#e.timestamp.set(r.Milli.fromMicro(n.timestamp)), this.#e.frame.update((e) => (e?.close(), n.clone())));
+		}), e.proxy(this.#e.buffered, t.buffered);
+	}
+	#l(e) {
+		let t = e.get(this.source.out.catalog);
+		if (!t) return;
+		let n = t.display;
+		if (n) {
+			e.set(this.#e.display, {
+				width: n.width,
+				height: n.height
+			});
+			return;
+		}
+		let r = e.get(this.#e.frame);
+		r && e.set(this.#e.display, Xe({
+			width: r.displayWidth,
+			height: r.displayHeight
+		}, t.rotation));
+	}
+	#u(e) {
+		if (e.get(this.in.enabled)) {
+			if (!e.get(this.#e.frame)) {
+				this.#e.stalled.set(!0);
+				return;
+			}
+			this.#e.stalled.set(!1), e.timer(() => {
+				this.#e.stalled.set(!0);
+			}, $e);
+		}
+	}
+	close() {
+		this.#a(), this.#i.close();
+	}
+	static supported = tt;
+}, et = class {
+	sync;
+	broadcast;
+	track;
+	config;
+	catalog;
+	stats;
+	timestamp = new a(void 0);
+	frame = new a(void 0);
+	buffered = new a([]);
+	#e = new a([]);
+	#t = 0;
+	#n = new i();
+	constructor(e) {
+		this.sync = e.sync, this.broadcast = e.broadcast, this.track = e.track, this.config = e.config, this.catalog = e.catalog, this.stats = e.stats, this.#n.run(this.#r.bind(this));
+	}
+	#r(e) {
+		let t = _(e, {
+			broadcast: this.broadcast,
+			track: this.track,
+			priority: c.PRIORITY.video,
+			maxAge: this.sync.out.maxAge
+		});
+		if (!t) return;
+		let n = new VideoDecoder({
+			output: async (t) => {
+				try {
+					let n = this.#t, i = r.Milli.fromMicro(t.timestamp);
+					if (i < (this.timestamp.peek() ?? 0) || this.sync.out.reference.peek() === void 0 || (this.frame.peek() === void 0 && this.frame.set(t.clone()), !await e.race(this.sync.wait(i).then(() => !0))) || n !== this.#t || i < (this.timestamp.peek() ?? 0)) return;
+					this.timestamp.set(i), this.#c(i), this.frame.update((e) => (e?.close(), t.clone()));
+				} finally {
+					t.close();
+				}
+			},
+			error: (t) => {
+				console.error("video decoder error", t), e.close();
+			}
+		});
+		e.cleanup(() => {
+			n.state !== "closed" && n.close();
+		}), this.config.container.kind === "cmaf" ? this.#a(e, t, n) : this.#i(e, t, n);
+	}
+	#i(e, t, n) {
+		let i = this.config.container.kind === "loc" ? new u.Loc.Format("video") : new u.Legacy.Format(this.config), a = new u.Consumer(t, {
+			format: i,
+			maxAge: this.sync.out.maxAge
+		});
+		e.cleanup(() => a.close()), e.run((e) => {
+			let t = e.get(a.buffered), n = e.get(this.#e);
+			this.buffered.update(() => u.mergeBufferedRanges(t, n));
+		}), n.configure({
+			codec: this.config.codec,
+			description: this.config.description ? d.Hex.toBytes(this.config.description) : void 0,
+			displayAspectWidth: this.config.displayAspectWidth,
+			displayAspectHeight: this.config.displayAspectHeight,
+			optimizeForLatency: this.config.optimizeForLatency,
+			flip: !1
+		});
+		let o, s;
+		e.spawn(async () => {
+			for (;;) {
+				let e = await v(a);
+				if (!e) break;
+				this.#o(e.discontinuity) && (o = void 0);
+				let { frame: t } = e;
+				if (!t) continue;
+				let i = s !== void 0 && e.group < s;
+				if (this.stats.update((e) => ({
+					frameCount: (e?.frameCount ?? 0) + +!i,
+					bytesReceived: (e?.bytesReceived ?? 0) + t.payload.byteLength
+				})), i) continue;
+				let c = r.Milli.fromMicro(t.timestamp);
+				this.sync.received(c, "video");
+				let l = new EncodedVideoChunk({
+					type: t.keyframe ? "key" : "delta",
+					data: t.payload,
+					timestamp: t.timestamp
+				});
+				o !== void 0 && e.continuous && this.#s(r.Milli.fromMicro(o), r.Milli.fromMicro(t.timestamp)), o = t.timestamp, s = e.group, n.decode(l);
+			}
+		});
+	}
+	#a(e, t, n) {
+		let i = this.config.container;
+		if (i.kind !== "cmaf") return;
+		let a = g(i.init), o = u.Cmaf.decodeInitSegment(a), s = this.config.description ? d.Hex.toBytes(this.config.description) : o.description, c = new u.Consumer(t, {
+			format: new u.Cmaf.Format(o),
+			maxAge: this.sync.out.maxAge
+		});
+		e.cleanup(() => c.close()), e.run((e) => {
+			let t = e.get(c.buffered), n = e.get(this.#e);
+			this.buffered.update(() => u.mergeBufferedRanges(t, n));
+		}), n.configure({
+			codec: this.config.codec,
+			description: s,
+			displayAspectWidth: this.config.displayAspectWidth,
+			displayAspectHeight: this.config.displayAspectHeight,
+			optimizeForLatency: this.config.optimizeForLatency,
+			flip: !1
+		});
+		let l, f;
+		e.spawn(async () => {
+			for (;;) {
+				let e = await v(c);
+				if (!e) break;
+				this.#o(e.discontinuity) && (l = void 0);
+				let { frame: t } = e;
+				if (!t) continue;
+				let i = f !== void 0 && e.group < f;
+				if (this.stats.update((e) => ({
+					frameCount: (e?.frameCount ?? 0) + +!i,
+					bytesReceived: (e?.bytesReceived ?? 0) + t.payload.byteLength
+				})), i) continue;
+				let a = r.Milli.fromMicro(t.timestamp);
+				if (this.sync.received(a, "video"), l !== void 0 && e.continuous && this.#s(r.Milli.fromMicro(l), r.Milli.fromMicro(t.timestamp)), l = t.timestamp, n.state === "closed") break;
+				f = e.group, n.decode(new EncodedVideoChunk({
+					type: t.keyframe ? "key" : "delta",
+					data: t.payload,
+					timestamp: t.timestamp
+				}));
+			}
+		});
+	}
+	#o(e) {
+		return e !== this.#t && (this.#t = e, this.timestamp.set(void 0), this.#e.set([]), this.sync.reset(), !0);
+	}
+	#s(e, t) {
+		e > t || this.#e.mutate((n) => {
+			for (let i of n) if (i.start <= t && i.end >= e) {
+				i.start = r.Milli.min(i.start, e), i.end = r.Milli.max(i.end, t);
+				return;
+			}
+			n.push({
+				start: e,
+				end: t
+			}), n.sort((e, t) => e.start - t.start);
+		});
+	}
+	#c(e) {
+		this.#e.mutate((t) => {
+			for (; t.length > 0;) {
+				if (t[0].end >= e) {
+					t[0].start = r.Milli.max(t[0].start, e);
+					break;
+				}
+				t.shift();
+			}
+		});
+	}
+	close() {
+		this.#n.close(), this.frame.update((e) => {
+			e?.close();
+		});
+	}
+};
+async function tt(e) {
+	if (!c.containerSupported(e.container)) {
+		let t = e.container.kind === "unknown" ? e.container.raw.kind : e.container.kind;
+		return console.warn(`video: ignoring rendition with unknown container: ${t}`), !1;
+	}
+	let t;
+	if (e.description) t = d.Hex.toBytes(e.description);
+	else if (e.container.kind === "cmaf") try {
+		t = u.Cmaf.decodeInitSegment(g(e.container.init)).description;
+	} catch (t) {
+		return console.warn(`video: malformed CMAF init segment for codec ${e.codec}`, t), !1;
+	}
+	let { supported: n } = await VideoDecoder.isConfigSupported({
+		codec: e.codec,
+		description: t,
+		displayAspectWidth: e.displayAspectWidth,
+		displayAspectHeight: e.displayAspectHeight,
+		optimizeForLatency: e.optimizeForLatency ?? !0
+	});
+	if (n) return !0;
+	if (e.codec.startsWith("avc3.")) {
+		let n = `avc1.${e.codec.slice(5)}`;
+		if ((await VideoDecoder.isConfigSupported({
+			codec: n,
+			description: t,
+			displayAspectWidth: e.displayAspectWidth,
+			displayAspectHeight: e.displayAspectHeight,
+			optimizeForLatency: e.optimizeForLatency ?? !0
+		})).supported) return e.codec = n, !0;
+	}
+	return !1;
+}
+Object.assign(tt, { [Y]: We });
+//#endregion
+//#region src/video/renderer.ts
+var nt = .01, rt = class {
+	decoder;
+	in;
+	#e = {
+		frame: new a(void 0),
+		timestamp: new a(void 0),
+		visible: new a(!1)
+	};
+	out = s(this.#e);
+	#t = new a(void 0);
+	#n = new i();
+	constructor(e) {
+		this.decoder = e.decoder, this.in = {
+			canvas: o(e?.canvas),
+			visible: o(e?.visible ?? "20%")
+		}, this.#n.run((e) => {
+			let t = e.get(this.in.canvas);
+			this.#t.set(t?.getContext("2d") ?? void 0);
+		}), this.#n.run(this.#i.bind(this)), this.#n.run(this.#a.bind(this)), this.#n.run(this.#r.bind(this));
+	}
+	#r(e) {
+		let t = e.getAll([this.in.canvas, this.decoder.out.display]);
+		if (!t) return;
+		let [n, r] = t;
+		(n.width !== r.width || n.height !== r.height) && (n.width = r.width, n.height = r.height);
+	}
+	#i(e) {
+		let t = e.get(this.in.visible);
+		if (t === "never") {
+			this.#e.visible.set(!1);
+			return;
+		}
+		if (t === "always") {
+			this.#e.visible.set(!0), e.cleanup(() => this.#e.visible.set(!1));
+			return;
+		}
+		let n = e.get(this.in.canvas);
+		if (!n) {
+			this.#e.visible.set(!1);
+			return;
+		}
+		let r = !1, i = () => {
+			this.#e.visible.set(r && !document.hidden);
+		}, a = (e) => {
+			for (let t of e) r = t.isIntersecting, i();
+		}, o;
+		try {
+			o = new IntersectionObserver(a, {
+				threshold: nt,
+				rootMargin: t
+			});
+		} catch {
+			console.warn(`moq-watch: invalid visible margin "${t}", using "0px"`), o = new IntersectionObserver(a, { threshold: nt });
+		}
+		i(), e.event(document, "visibilitychange", i), o.observe(n), e.cleanup(() => o.disconnect()), e.cleanup(() => this.#e.visible.set(!1));
+	}
+	#a(e) {
+		let t = e.get(this.#t);
+		if (!t) return;
+		let n = e.get(this.decoder.out.frame), i = e.get(this.decoder.source.out.catalog), a = requestAnimationFrame(() => {
+			this.#o(t, n, i), n ? (this.#e.frame.update((e) => (e?.close(), n.clone())), this.#e.timestamp.set(r.Milli.fromMicro(n.timestamp))) : (this.#e.frame.update((e) => {
+				e?.close();
+			}), this.#e.timestamp.set(void 0)), a = void 0;
+		});
+		e.cleanup(() => {
+			a !== void 0 && cancelAnimationFrame(a);
+		});
+	}
+	#o(e, t, n) {
+		if (!t) {
+			e.fillStyle = "#000", e.fillRect(0, 0, e.canvas.width, e.canvas.height);
+			return;
+		}
+		if (e.save(), e.fillStyle = "#000", e.fillRect(0, 0, e.canvas.width, e.canvas.height), !n?.rotation) n?.flip && (e.scale(-1, 1), e.translate(-e.canvas.width, 0)), e.drawImage(t, 0, 0, e.canvas.width, e.canvas.height);
+		else {
+			let r = Qe(e.canvas, n);
+			e.setTransform(...r.matrix), e.drawImage(t, 0, 0, r.source.width, r.source.height);
+		}
+		e.restore();
+	}
+	close() {
+		this.#e.frame.update((e) => {
+			e?.close();
+		}), this.#e.timestamp.set(void 0), this.#n.close();
+	}
+};
+//#endregion
+//#region src/video/source.ts
+function it(e) {
+	return (t) => {
+		let n = [], r = [];
+		for (let [i, a] of t) if (a.codedWidth && a.codedHeight) {
+			let t = a.codedWidth * a.codedHeight;
+			t <= e ? n.push({
+				name: i,
+				size: t
+			}) : r.push({
+				name: i,
+				size: t
+			});
+		}
+		return n.sort((e, t) => t.size - e.size), n.length > 0 ? n.map((e) => e.name) : r.length > 0 ? (r.sort((e, t) => e.size - t.size), [r[0].name]) : t.map(([e]) => e);
+	};
+}
+function at(e, t) {
+	return (n) => {
+		let r = [], i = [];
+		for (let [a, o] of n) {
+			if (!o.codedWidth || !o.codedHeight) continue;
+			let n = o.codedWidth * o.codedHeight, s = e == null || o.codedWidth <= e, c = t == null || o.codedHeight <= t;
+			s && c ? r.push({
+				name: a,
+				size: n
+			}) : i.push({
+				name: a,
+				size: n
+			});
+		}
+		return r.sort((e, t) => t.size - e.size), r.length > 0 ? r.map((e) => e.name) : i.length > 0 ? (i.sort((e, t) => e.size - t.size), [i[0].name]) : n.map(([e]) => e);
+	};
+}
+function $(e) {
+	return (t) => {
+		let n = [], r = [];
+		for (let [i, a] of t) a.bitrate != null && a.bitrate <= e ? n.push({
+			name: i,
+			bitrate: a.bitrate
+		}) : a.bitrate != null && r.push({
+			name: i,
+			bitrate: a.bitrate
+		});
+		return n.sort((e, t) => t.bitrate - e.bitrate), n.length > 0 ? n.map((e) => e.name) : r.length > 0 ? (r.sort((e, t) => e.bitrate - t.bitrate), [r[0].name]) : t.map(([e]) => e);
+	};
+}
+function ot(e) {
+	let t = e[0];
+	for (let n of e) {
+		let [, e] = n, [, r] = t, i = (e.codedWidth ?? 0) * (e.codedHeight ?? 0), a = (r.codedWidth ?? 0) * (r.codedHeight ?? 0);
+		if (i !== a) {
+			i > a && (t = n);
+			continue;
+		}
+		(e.bitrate ?? 0) > (r.bitrate ?? 0) && (t = n);
+	}
+	return t[0];
+}
+function st(e) {
+	let t = Object.entries(e).filter(([, e]) => !e.stalled);
+	if (t.length > 0) return Object.fromEntries(t);
+	let n = Object.entries(e);
+	if (n.length === 0) return {};
+	let r = $(0)(n), i = r.length === 1 ? r[0] : at(0, 0)(n)[0];
+	return { [i]: e[i] };
+}
+var ct = class {
+	in;
+	#e = {
+		catalog: new a(void 0),
+		available: new a({}),
+		error: new a(void 0),
+		track: new a(void 0),
+		config: new a(void 0)
+	};
+	out = s(this.#e);
+	#t = new i();
+	#n = /* @__PURE__ */ new WeakMap();
+	constructor(e) {
+		this.in = {
+			broadcast: o(e?.broadcast),
+			target: o(e?.target),
+			supported: o(e?.supported),
+			probe: o(e?.probe)
+		}, this.#t.run(this.#r.bind(this)), this.#t.run(this.#i.bind(this)), this.#t.run(this.#a.bind(this));
+	}
+	#r(e) {
+		let t = e.get(this.in.broadcast);
+		if (!t) return;
+		let n = e.get(t.out.catalog)?.video;
+		n && e.set(this.#e.catalog, n);
+	}
+	#i(e) {
+		let t = e.get(this.in.supported);
+		if (!t) {
+			this.#e.error.set(void 0);
+			return;
+		}
+		let n = e.get(this.#e.catalog)?.renditions ?? {};
+		this.#e.error.set(void 0);
+		let r = this.#n.get(t);
+		r || (r = /* @__PURE__ */ new Map(), this.#n.set(t, r));
+		let i = new Set(Object.keys(n));
+		for (let e of r.keys()) i.has(e) || r.delete(e);
+		e.spawn(async () => {
+			let i = {};
+			for (let [a, o] of Object.entries(n)) {
+				let n = t[Y], s = n ? n(o) : JSON.stringify(o), c = r.get(a), l = !1;
+				if (c?.key === s) l = c.supported;
+				else {
+					let i = !1;
+					try {
+						l = await e.race(t(o));
+					} catch (e) {
+						i = !0, console.warn(`[Source] video rendition ${a} (${o.codec}) support probe failed; treating as unsupported`, e);
+					}
+					!i && l !== void 0 && r.set(a, {
+						key: n ? n(o) : JSON.stringify(o),
+						supported: l
+					});
+				}
+				if (e.abort.aborted) return;
+				l && (i[a] = o);
+			}
+			let a = Object.keys(i).length === 0 && Object.keys(n).length > 0 ? "unsupported" : void 0;
+			a === "unsupported" && console.warn("[Source] No supported video renditions found:", n), this.#e.error.set(a), this.#e.available.set(i);
+		});
+	}
+	#a(e) {
+		let t = e.get(this.#e.available), n = e.get(this.in.target);
+		if (n?.name && n.name in t) {
+			let r = t[n.name];
+			e.set(this.#e.track, n.name), e.set(this.#e.config, r);
+			return;
+		}
+		let r = st(t);
+		if (Object.keys(r).length === 0) return;
+		let i = n;
+		if (!n?.bitrate) {
+			let t = e.get(this.in.probe)?.estimatedRecvRate;
+			if (t != null) {
+				let e = Math.round(t * .8);
+				i = {
+					...n,
+					bitrate: e
+				};
+			}
+		}
+		let a = this.#o(r, i);
+		if (!a) return;
+		let o = r[a];
+		e.set(this.#e.track, a), e.set(this.#e.config, o);
+	}
+	#o(e, t) {
+		let n = Object.entries(e);
+		if (n.length === 0) return;
+		if (n.length === 1) return n[0][0];
+		let r = [];
+		if (t?.pixels != null && r.push(it(t.pixels)), (t?.width != null || t?.height != null) && r.push(at(t.width, t.height)), t?.bitrate != null && r.push($(t.bitrate)), r.length === 0) return ot(n);
+		let i = r.map((e) => e(n)), a = i.map((e) => new Set(e));
+		for (let e of i[0]) if (a.every((t) => t.has(e))) return e;
+		console.warn("conflicting rendition filters, no rendition satisfies all criteria");
+	}
+	close() {
+		this.#t.close();
+	}
+}, lt = class {
+	in;
+	broadcast;
+	sync;
+	text;
+	video;
+	audio;
+	renderer;
+	emitter;
+	textRenderer;
+	#e = new a(!1);
+	#t = new a(!1);
+	#n = new a(!1);
+	#r = new i();
+	constructor(e = {}) {
+		this.in = s({
+			origin: o(e.origin),
+			name: o(e.name ?? n.empty()),
+			enabled: o(e.enabled ?? !0),
+			announced: o(e.announced ?? !0),
+			catalogFormat: o(e.catalogFormat),
+			catalog: o(e.catalog),
+			probe: o(e.probe),
+			canvas: o(e.canvas),
+			container: o(e.container),
+			paused: o(e.paused ?? !1),
+			volume: o(e.volume ?? .5),
+			muted: o(e.muted ?? !1),
+			visible: o(e.visible ?? "20%"),
+			delay: o(e.delay ?? "auto"),
+			buffer: o(e.buffer ?? r.Milli.zero),
+			target: o(e.target),
+			audioTarget: o(e.audioTarget),
+			captions: o(e.captions)
+		}), this.broadcast = new R(this.in), this.#r.cleanup(() => this.broadcast.close());
+		let t = new ct({
+			broadcast: this.broadcast,
+			target: this.in.target,
+			supported: Q.supported,
+			probe: this.in.probe
+		}), i = new N({
+			broadcast: this.broadcast,
+			target: this.in.audioTarget,
+			supported: j.supported
+		});
+		this.#r.cleanup(() => {
+			t.close(), i.close();
+		}), this.text = new J({
+			broadcast: this.broadcast,
+			target: this.in.captions
+		}), this.#r.cleanup(() => this.text.close()), this.sync = new B({
+			delay: this.in.delay,
+			buffer: this.in.buffer,
+			probe: this.in.probe
+		}), this.#r.cleanup(() => this.sync.close()), this.video = new Q({
+			source: t,
+			sync: this.sync,
+			enabled: this.#e
+		}), this.audio = new j({
+			source: i,
+			sync: this.sync,
+			enabled: this.#t
+		}), this.#r.cleanup(() => {
+			this.video.close(), this.audio.close();
+		}), this.emitter = new Ae({
+			source: this.audio,
+			volume: this.in.volume,
+			muted: this.in.muted,
+			paused: this.in.paused
+		}), this.renderer = new rt({
+			decoder: this.video,
+			canvas: this.in.canvas,
+			visible: this.in.visible
+		}), this.#r.cleanup(() => {
+			this.emitter.close(), this.renderer.close();
+		}), this.textRenderer = new K({
+			source: this.text,
+			sync: this.sync,
+			container: this.in.container,
+			enabled: this.#n
+		}), this.#r.cleanup(() => this.textRenderer.close()), this.#r.run((e) => {
+			this.#n.set(e.get(this.in.enabled) && !e.get(this.in.paused));
+		}), this.#r.run((e) => {
+			this.#t.set(e.get(this.in.enabled) && e.get(this.emitter.out.enabled));
+		}), this.#r.run((e) => {
+			let t = e.get(this.renderer.out.visible);
+			e.get(this.in.enabled) ? e.get(this.in.paused) ? this.#e.set(t && !e.get(this.renderer.out.frame)) : this.#e.set(t) : this.#e.set(!1);
+		});
+	}
+	reset() {
+		this.sync.reset(), this.audio.reset();
+	}
+	close() {
+		this.#r.close();
+	}
+};
+//#endregion
+export { Ae as _, J as a, G as c, W as d, V as f, N as g, Le as h, Q as i, H as l, R as m, ct as n, q as o, B as p, rt as r, K as s, lt as t, U as u, j as v };
+
+//# sourceMappingURL=player-C19uf7Dc.js.map