@vindral/web-sdk 3.4.3 → 4.0.0-100-g47797f66

package/Cpe0b7AQ.js

@@ -0,0 +1,4894 @@
+var Ic = Object.create;
+var Qn = Object.defineProperty, vc = Object.defineProperties, Sc = Object.getOwnPropertyDescriptor, Uc = Object.getOwnPropertyDescriptors;
+var Lr = Object.getOwnPropertySymbols;
+var Xa = Object.prototype.hasOwnProperty, Ya = Object.prototype.propertyIsEnumerable;
+var It = (r, t) => (t = Symbol[r]) ? t : Symbol.for("Symbol." + r), Bt = (r) => {
+  throw TypeError(r);
+};
+var Fr = (r, t, e) => t in r ? Qn(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e, Mt = (r, t) => {
+  for (var e in t || (t = {}))
+    Xa.call(t, e) && Fr(r, e, t[e]);
+  if (Lr)
+    for (var e of Lr(t))
+      Ya.call(t, e) && Fr(r, e, t[e]);
+  return r;
+}, Wr = (r, t) => vc(r, Uc(t)), Ha = (r, t) => Qn(r, "name", { value: t, configurable: !0 });
+var Za = (r, t) => {
+  var e = {};
+  for (var i in r)
+    Xa.call(r, i) && t.indexOf(i) < 0 && (e[i] = r[i]);
+  if (r != null && Lr)
+    for (var i of Lr(r))
+      t.indexOf(i) < 0 && Ya.call(r, i) && (e[i] = r[i]);
+  return e;
+};
+var he = (r) => {
+  var t;
+  return [, , , Ic((t = r == null ? void 0 : r[It("metadata")]) != null ? t : null)];
+}, Ka = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"], ri = (r) => r !== void 0 && typeof r != "function" ? Bt("Function expected") : r, Ec = (r, t, e, i, n) => ({ kind: Ka[r], name: t, metadata: i, addInitializer: (a) => e._ ? Bt("Already initialized") : n.push(ri(a || null)) }), zt = (r, t) => Fr(t, It("metadata"), r[3]), de = (r, t, e, i) => {
+  for (var n = 0, a = r[t >> 1], c = a && a.length; n < c; n++) t & 1 ? a[n].call(e) : i = a[n].call(e, i);
+  return i;
+}, H = (r, t, e, i, n, a) => {
+  var c, d, w, p, m, b = t & 7, I = !!(t & 8), g = !!(t & 16), E = b > 3 ? r.length + 1 : b ? I ? 1 : 2 : 0, z = Ka[b + 5], _ = b > 3 && (r[E - 1] = []), A = r[E] || (r[E] = []), S = b && (!g && !I && (n = n.prototype), b < 5 && (b > 3 || !g) && Sc(b < 4 ? n : { get [e]() {
+    return s(this, a);
+  }, set [e](v) {
+    return u(this, a, v);
+  } }, e));
+  b ? g && b < 4 && Ha(a, (b > 2 ? "set " : b > 1 ? "get " : "") + e) : Ha(n, e);
+  for (var W = i.length - 1; W >= 0; W--)
+    p = Ec(b, e, w = {}, r[3], A), b && (p.static = I, p.private = g, m = p.access = { has: g ? (v) => Tc(n, v) : (v) => e in v }, b ^ 3 && (m.get = g ? (v) => (b ^ 1 ? s : f)(v, n, b ^ 4 ? a : S.get) : (v) => v[e]), b > 2 && (m.set = g ? (v, R) => u(v, n, R, b ^ 4 ? a : S.set) : (v, R) => v[e] = R)), d = (0, i[W])(b ? b < 4 ? g ? a : S[z] : b > 4 ? void 0 : { get: S.get, set: S.set } : n, p), w._ = 1, b ^ 4 || d === void 0 ? ri(d) && (b > 4 ? _.unshift(d) : b ? g ? a = d : S[z] = d : n = d) : typeof d != "object" || d === null ? Bt("Object expected") : (ri(c = d.get) && (S.get = c), ri(c = d.set) && (S.set = c), ri(c = d.init) && _.unshift(c));
+  return b || zt(r, n), S && Qn(n, e, S), g ? b ^ 4 ? a : S : n;
+}, l = (r, t, e) => Fr(r, typeof t != "symbol" ? t + "" : t, e), qn = (r, t, e) => t.has(r) || Bt("Cannot " + e), Tc = (r, t) => Object(t) !== t ? Bt('Cannot use the "in" operator on this value') : r.has(t), s = (r, t, e) => (qn(r, t, "read from private field"), e ? e.call(r) : t.get(r)), o = (r, t, e) => t.has(r) ? Bt("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(r) : t.set(r, e), u = (r, t, e, i) => (qn(r, t, "write to private field"), i ? i.call(r, e) : t.set(r, e), e), f = (r, t, e) => (qn(r, t, "access private method"), e);
+var _n = (r, t, e, i) => ({
+  set _(n) {
+    u(r, t, n, e);
+  },
+  get _() {
+    return s(r, t, i);
+  }
+});
+var h = (r, t, e) => new Promise((i, n) => {
+  var a = (w) => {
+    try {
+      d(e.next(w));
+    } catch (p) {
+      n(p);
+    }
+  }, c = (w) => {
+    try {
+      d(e.throw(w));
+    } catch (p) {
+      n(p);
+    }
+  }, d = (w) => w.done ? i(w.value) : Promise.resolve(w.value).then(a, c);
+  d((e = e.apply(r, t)).next());
+}), O = function(r, t) {
+  this[0] = r, this[1] = t;
+}, xt = (r, t, e) => {
+  var i = (c, d, w, p) => {
+    try {
+      var m = e[c](d), b = (d = m.value) instanceof O, I = m.done;
+      Promise.resolve(b ? d[0] : d).then((g) => b ? i(c === "return" ? c : "next", d[1] ? { done: g.done, value: g.value } : g, w, p) : w({ value: g, done: I })).catch((g) => i("throw", g, w, p));
+    } catch (g) {
+      p(g);
+    }
+  }, n = (c) => a[c] = (d) => new Promise((w, p) => i(c, d, w, p)), a = {};
+  return e = e.apply(r, t), a[It("asyncIterator")] = () => a, n("next"), n("throw"), n("return"), a;
+}, ta = (r) => {
+  var t = r[It("asyncIterator")], e = !1, i, n = {};
+  return t == null ? (t = r[It("iterator")](), i = (a) => n[a] = (c) => t[a](c)) : (t = t.call(r), i = (a) => n[a] = (c) => {
+    if (e) {
+      if (e = !1, a === "throw") throw c;
+      return c;
+    }
+    return e = !0, {
+      done: !1,
+      value: new O(new Promise((d) => {
+        var w = t[a](c);
+        w instanceof Object || Bt("Object expected"), d(w);
+      }), 1)
+    };
+  }), n[It("iterator")] = () => n, i("next"), "throw" in t ? i("throw") : n.throw = (a) => {
+    throw a;
+  }, "return" in t && i("return"), n;
+}, C = (r, t, e) => (t = r[It("asyncIterator")]) ? t.call(r) : (r = r[It("iterator")](), t = {}, e = (i, n) => (n = r[i]) && (t[i] = (a) => new Promise((c, d, w) => (a = n.call(r, a), w = a.done, Promise.resolve(a.value).then((p) => c({ value: p, done: w }), d)))), e("next"), e("return"), t);
+var rt = (r, t, e) => {
+  if (t != null) {
+    typeof t != "object" && typeof t != "function" && Bt("Object expected");
+    var i;
+    e && (i = t[It("asyncDispose")]), i === void 0 && (i = t[It("dispose")]), typeof i != "function" && Bt("Object not disposable"), r.push([e, i, t]);
+  } else e && r.push([e]);
+  return t;
+}, nt = (r, t, e) => {
+  var i = typeof SuppressedError == "function" ? SuppressedError : function(c, d, w, p) {
+    return p = Error(w), p.name = "SuppressedError", p.error = c, p.suppressed = d, p;
+  }, n = (c) => t = e ? new i(c, t, "An error was suppressed during disposal") : (e = !0, c), a = (c) => {
+    for (; c = r.pop(); )
+      try {
+        var d = c[1] && c[1].call(c[2]);
+        if (c[0]) return Promise.resolve(d).then(a, (w) => (n(w), a()));
+      } catch (w) {
+        n(w);
+      }
+    if (e) throw t;
+  };
+  return a();
+};
+import { D as V, F as Va, n as D, B as Xn, L as gt, b as Ac, w as Yn, i as q, a as Dc, W as Oc, t as yo, m as Vc, c as Cc, e as Bc } from "./Bozsjl6j.js";
+import { a as go, p as xc, i as Pc, c as Rc } from "./C80BN8Qb.js";
+function Ca(r) {
+  const t = new Zn(r);
+  return [t, t];
+}
+var Pt, as, ht, Vi;
+class Zn {
+  constructor(t) {
+    /// The internal queue
+    o(this, Pt);
+    /// Slows down push when the queue is full
+    o(this, as, new V());
+    /// Slows down pop when the queue is empty
+    o(this, ht);
+    /// The channel is closed
+    o(this, Vi, !1);
+    u(this, Pt, new Va(t));
+  }
+  isFull() {
+    return s(this, Pt).isFull();
+  }
+  close() {
+    var t;
+    (t = s(this, ht)) == null || t.resolve(), u(this, Vi, !0);
+  }
+  abort(t) {
+    var e, i;
+    (e = s(this, ht)) == null || e.promise.catch(D), (i = s(this, ht)) == null || i.reject(t);
+  }
+  push(t) {
+    return h(this, null, function* () {
+      var e;
+      s(this, Pt).isFull() && (yield s(this, as).promise), s(this, Pt).push(t), (e = s(this, ht)) == null || e.resolve(), u(this, ht, new V());
+    });
+  }
+  pop() {
+    return h(this, null, function* () {
+      var t;
+      for (; !(s(this, Vi) && s(this, Pt).isEmpty()); ) {
+        const e = s(this, Pt).pop();
+        if (e)
+          return s(this, as).resolve(), u(this, as, new V()), e;
+        s(this, ht) || u(this, ht, new V()), yield (t = s(this, ht)) == null ? void 0 : t.promise;
+      }
+    });
+  }
+  start(t) {
+  }
+  pull(t) {
+    return h(this, null, function* () {
+      const e = yield this.pop();
+      e ? t.enqueue(e) : t.close();
+    });
+  }
+  cancel(t) {
+    this.abort(new Error(t));
+  }
+  next() {
+    return h(this, null, function* () {
+      const t = yield this.pop().catch(() => {
+      });
+      return t ? { done: !1, value: t } : { done: !0, value: void 0 };
+    });
+  }
+  return() {
+    return this.close(), Promise.resolve({ done: !0, value: void 0 });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+}
+Pt = new WeakMap(), as = new WeakMap(), ht = new WeakMap(), Vi = new WeakMap();
+function ko(r) {
+  const t = atob(r), e = new Uint8Array(t.length);
+  for (let i = 0; i < t.length; i++)
+    e[i] = t.charCodeAt(i);
+  return e.buffer;
+}
+function k(r) {
+  return typeof BigInt == "function" ? BigInt(r) : r;
+}
+function Ct() {
+  return typeof Symbol.asyncDispose != "symbol" && Object.defineProperty(Symbol, "asyncDispose", { value: Symbol.for("asyncDispose") }), Symbol.asyncDispose;
+}
+function Io() {
+  return typeof Symbol.dispose != "symbol" && Object.defineProperty(Symbol, "dispose", { value: Symbol.for("dispose") }), Symbol.dispose;
+}
+var Ci, ca;
+class jc {
+  constructor(t, e) {
+    o(this, Ci);
+    l(this, "value");
+    l(this, "unlocker");
+    this.value = t, this.unlocker = e;
+  }
+  unlocked() {
+    var t;
+    return (t = this.unlocker) == null ? void 0 : t.promise;
+  }
+  [Io()]() {
+    f(this, Ci, ca).call(this);
+  }
+  [Symbol.dispose]() {
+    f(this, Ci, ca).call(this);
+  }
+}
+Ci = new WeakSet(), ca = function() {
+  this.unlocker.resolve(this.value);
+};
+var be, me;
+class Nc {
+  constructor(t) {
+    o(this, be);
+    o(this, me, new V());
+    u(this, be, t), s(this, me).resolve(t);
+  }
+  unsafeValue() {
+    return s(this, be);
+  }
+  isLocked() {
+    return s(this, me).pending;
+  }
+  lock() {
+    return h(this, null, function* () {
+      const t = new V();
+      t.promise.then((i) => {
+        u(this, be, i);
+      }).catch(D);
+      const e = s(this, me).promise.then(() => t);
+      return u(this, me, t), yield e, new jc(s(this, be), t);
+    });
+  }
+}
+be = new WeakMap(), me = new WeakMap();
+var at, dt;
+class Y {
+  constructor(t) {
+    o(this, at);
+    o(this, dt);
+    u(this, at, t), u(this, dt, new V());
+  }
+  isClosed() {
+    var t;
+    return !((t = s(this, dt)) != null && t.pending);
+  }
+  /**
+   * Return only the current value
+   */
+  current() {
+    return s(this, at);
+  }
+  /**
+   * Return the current value and a promise for the next value
+   */
+  value() {
+    var t;
+    return [s(this, at), (t = s(this, dt)) == null ? void 0 : t.promise];
+  }
+  update(t) {
+    var e;
+    if (!((e = s(this, dt)) != null && e.pending))
+      throw new Error("ObservableValue is closed");
+    u(this, at, t instanceof Function ? t(s(this, at)) : t), s(this, dt).resolve(s(this, at)), u(this, dt, new V());
+  }
+  close() {
+    var t;
+    (t = s(this, dt)) == null || t.resolve(s(this, at)), u(this, dt, void 0);
+  }
+  waitFor(t) {
+    return h(this, null, function* () {
+      if (t(s(this, at)))
+        return s(this, at);
+      for (; ; ) {
+        const [e, i] = this.value();
+        if (!i)
+          throw new Error("ObservableValue was closed while waiting for condition");
+        const n = yield i;
+        if (t(n))
+          return n;
+      }
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return xt(this, null, function* () {
+      for (; ; ) {
+        const [t, e] = this.value();
+        if (yield t, !e)
+          return;
+        yield new O(e);
+      }
+    });
+  }
+}
+at = new WeakMap(), dt = new WeakMap();
+function vo(r) {
+  try {
+    return r();
+  } catch (t) {
+    return t;
+  }
+}
+function So(r) {
+  let t = r.readUint32();
+  const e = [r.readUint8(), r.readUint8(), r.readUint8(), r.readUint8()], i = String.fromCharCode.apply(null, e);
+  return t === 1 && (t = r.readUint64() - 8), {
+    size: t - 8,
+    // Subtract header size
+    type: i
+  };
+}
+function Gc(r, t) {
+  const e = So(t), i = new Xn(t.readBytes(e.size));
+  if (e.type !== r.type)
+    throw new Error(`invalid error type: ${e.type}, expected ${r.type}`);
+  const n = r.decodeData(i);
+  return i.readRemaining(), n;
+}
+function ue(r) {
+  const t = r.readUint8(), e = r.readUint24();
+  return {
+    version: t,
+    flags: e
+  };
+}
+const _e = class _e {
+  constructor({
+    timescale: t,
+    presentationTime: e,
+    presentationTimeDelta: i,
+    schemeIdUri: n,
+    value: a,
+    eventDuration: c,
+    id: d,
+    data: w
+  }) {
+    l(this, "type", _e.type);
+    l(this, "timescale");
+    l(this, "presentationTime");
+    l(this, "presentationTimeDelta");
+    l(this, "schemeIdUri");
+    l(this, "value");
+    l(this, "eventDuration");
+    l(this, "id");
+    l(this, "data");
+    this.timescale = t, this.presentationTime = e, this.presentationTimeDelta = i, this.schemeIdUri = n, this.value = a, this.eventDuration = c, this.id = d, this.data = w;
+  }
+  static decodeData(t) {
+    const { version: e } = ue(t);
+    switch (e) {
+      case 1: {
+        const i = t.readUint32(), n = t.readUint64(), a = t.readUint32(), c = t.readUint32(), d = t.readUtf8String(), w = t.readUtf8String(), p = t.remaining(), m = t.readBytes(p);
+        return new _e({
+          timescale: i,
+          presentationTime: n,
+          eventDuration: a,
+          id: c,
+          schemeIdUri: d,
+          value: w,
+          data: m
+        });
+      }
+      case 0: {
+        const i = t.readUtf8String(), n = t.readUtf8String(), a = t.readUint32(), c = t.readUint32(), d = t.readUint32(), w = t.readUint32(), p = t.remaining(), m = t.readBytes(p);
+        return new _e({ timescale: a, presentationTimeDelta: c, schemeIdUri: i, value: n, eventDuration: d, id: w, data: m });
+      }
+      default:
+        throw new Error(`unsupported version ${e}`);
+    }
+  }
+};
+l(_e, "type", "emsg");
+let qr = _e;
+const hi = class hi {
+  constructor(t) {
+    l(this, "type", hi.type);
+    l(this, "data");
+    this.data = t;
+  }
+  static decodeData(t) {
+    const e = t.readRemaining();
+    return new hi(e);
+  }
+};
+l(hi, "type", "mdat");
+let _r = hi;
+const di = class di {
+  constructor(t, e, i) {
+    l(this, "type", di.type);
+    l(this, "extra");
+    /**
+     * The byte offset of the baseMediaDecodeTime field
+     */
+    l(this, "byteOffset");
+    l(this, "baseMediaDecodeTime");
+    this.extra = t, this.byteOffset = e, this.baseMediaDecodeTime = i;
+  }
+  static decodeData(t) {
+    const e = ue(t), i = t.byteOffset();
+    let n = 0;
+    return e.version === 1 ? n = t.readUint64() : n = t.readUint32(), new di(e, i, n);
+  }
+};
+l(di, "type", "tfdt");
+let tn = di;
+const x = class x {
+  constructor(t, e, i) {
+    l(this, "type", x.type);
+    l(this, "dataOffset");
+    l(this, "firstSampleFlags");
+    l(this, "samplesCount");
+    l(this, "sampleDurations", []);
+    l(this, "sampleSizes", []);
+    l(this, "sampleFlags", []);
+    l(this, "sampleCts", []);
+    this.dataOffset = e, this.firstSampleFlags = i, this.samplesCount = t;
+  }
+  is_sync_sample(t) {
+    const e = x.FLAG_SAMPLE_FLAG_IS_NON_SYNC | x.FLAG_SAMPLE_DEPENDS_YES, i = this.sampleFlags[t];
+    if (typeof i != "undefined")
+      return (i & e) === 0;
+    if (t === 0 && this.firstSampleFlags)
+      return (this.firstSampleFlags & e) === 0;
+  }
+  static decodeData(t) {
+    const { flags: e } = ue(t), i = t.readUint32();
+    let n, a;
+    e & x.TRUN_DATA_OFFSET && (n = t.readUint32()), e & x.TRUN_FIRST_SAMPLE_FLAGS && (a = t.readUint32());
+    const c = new x(i, n, a);
+    for (let d = 0; d < i; d++)
+      e & x.SAMPLE_DURATION && c.sampleDurations.push(t.readUint32()), e & x.SAMPLE_SIZE && c.sampleSizes.push(t.readUint32()), e & x.SAMPLE_FLAGS && c.sampleFlags.push(t.readUint32()), e & x.SAMPLE_CTS && c.sampleCts.push(t.readUint32());
+    return c;
+  }
+};
+l(x, "TRUN_DATA_OFFSET", 1), l(x, "TRUN_FIRST_SAMPLE_FLAGS", 4), l(x, "SAMPLE_DURATION", 256), l(x, "SAMPLE_SIZE", 512), l(x, "SAMPLE_FLAGS", 1024), l(x, "SAMPLE_CTS", 2048), l(x, "FLAG_SAMPLE_FLAG_IS_NON_SYNC", 65536), l(x, "FLAG_SAMPLE_DEPENDS_NO", 33554432), l(x, "FLAG_SAMPLE_DEPENDS_YES", 16777216), l(x, "type", "trun");
+let Di = x;
+const li = class li {
+  constructor(t, e) {
+    l(this, "type", li.type);
+    l(this, "tfdt");
+    l(this, "trun");
+    this.tfdt = t, this.trun = e;
+  }
+  static decodeData(t) {
+    let e, i;
+    for (; t.remaining() > 0; ) {
+      const n = kt(t);
+      n instanceof tn && (e = n), n instanceof Di && (i = n);
+    }
+    return new li(e, i);
+  }
+};
+l(li, "type", "traf");
+let en = li;
+const wi = class wi {
+  constructor(t) {
+    l(this, "type", wi.type);
+    l(this, "traf");
+    this.traf = t;
+  }
+  static decodeData(t) {
+    let e;
+    for (; t.remaining() > 0; ) {
+      const i = kt(t);
+      i instanceof en && (e = i);
+    }
+    if (!e)
+      throw new Error("No traf found");
+    return new wi(e);
+  }
+};
+l(wi, "type", "moof");
+let sn = wi;
+const fi = class fi {
+  constructor() {
+    l(this, "type", fi.type);
+  }
+  static decodeData(t) {
+    return new fi();
+  }
+};
+l(fi, "type", "mvhd");
+let rn = fi;
+const pi = class pi {
+  constructor(t) {
+    l(this, "type", pi.type);
+    l(this, "fourCC");
+    this.fourCC = t;
+  }
+  mediaType() {
+    switch (this.fourCC) {
+      case "vide":
+        return "video";
+      case "soun":
+        return "audio";
+      case "sbtl":
+        return "text";
+      default:
+        throw new Error("Unknown media type");
+    }
+  }
+  static decodeData(t) {
+    ue(t), t.readUint32();
+    const e = String.fromCharCode(...t.readBytes(4));
+    return new pi(e);
+  }
+};
+l(pi, "type", "hdlr");
+let nn = pi;
+const ts = class ts {
+  constructor(t, e, i, n) {
+    l(this, "type", ts.type);
+    l(this, "creationTime");
+    l(this, "modificationTime");
+    l(this, "timescale");
+    l(this, "duration");
+    this.creationTime = t, this.modificationTime = e, this.timescale = i, this.duration = n;
+  }
+  static decodeData(t) {
+    const { version: e } = ue(t);
+    if (e === 1) {
+      const d = t.readUint64(), w = t.readUint64(), p = t.readUint32(), m = t.readUint64();
+      return new ts(d, w, p, m);
+    }
+    const i = t.readUint32(), n = t.readUint32(), a = t.readUint32(), c = t.readUint32();
+    return new ts(i, n, a, c);
+  }
+};
+l(ts, "type", "mdhd");
+let an = ts;
+const bi = class bi {
+  constructor(t, e, i, n) {
+    l(this, "type", bi.type);
+    l(this, "av01");
+    l(this, "avc1");
+    l(this, "opus");
+    l(this, "codec");
+    this.avc1 = t, this.av01 = e, this.opus = i, this.codec = n;
+  }
+  mediaType() {
+    return this.avc1 || this.av01 ? "video" : "audio";
+  }
+  width() {
+    var t;
+    return (t = this.avc1) == null ? void 0 : t.width;
+  }
+  height() {
+    var t;
+    return (t = this.avc1) == null ? void 0 : t.height;
+  }
+  static decodeData(t) {
+    ue(t);
+    const e = t.readUint32();
+    let i, n, a, c;
+    for (let d = 0; d < e; d++)
+      for (; t.remaining() > 0; ) {
+        const w = kt(t);
+        switch (w.type) {
+          case "avc1":
+            i = "h264", n = w;
+            break;
+          case "av01":
+            i = "av1", c = w;
+            break;
+          case "mp4a":
+            i = "aac";
+            break;
+          case "Opus":
+            i = "opus", a = w;
+            break;
+        }
+      }
+    return new bi(n, c, a, i);
+  }
+};
+l(bi, "type", "stsd");
+let on = bi;
+const mi = class mi {
+  constructor(t) {
+    l(this, "type", mi.type);
+    l(this, "stsd");
+    this.stsd = t;
+  }
+  static decodeData(t) {
+    let e;
+    for (; t.remaining() > 0; ) {
+      const i = kt(t);
+      i instanceof on && (e = i);
+    }
+    if (!e)
+      throw new Error("No stsd found");
+    return new mi(e);
+  }
+};
+l(mi, "type", "stbl");
+let cn = mi;
+const yi = class yi {
+  constructor(t) {
+    l(this, "type", yi.type);
+    l(this, "stbl");
+    this.stbl = t;
+  }
+  static decodeData(t) {
+    let e;
+    for (; t.remaining() > 0; ) {
+      const i = kt(t);
+      i instanceof cn && (e = i);
+    }
+    if (!e)
+      throw new Error("No stbl found");
+    return new yi(e);
+  }
+};
+l(yi, "type", "minf");
+let un = yi;
+const gi = class gi {
+  constructor(t, e, i) {
+    l(this, "type", gi.type);
+    l(this, "hdlr");
+    l(this, "minf");
+    l(this, "mdhd");
+    this.hdlr = t, this.minf = e, this.mdhd = i;
+  }
+  static decodeData(t) {
+    let e, i, n;
+    for (; t.remaining() > 0; ) {
+      const a = kt(t);
+      a instanceof nn && (e = a), a instanceof un && (i = a), a instanceof an && (n = a);
+    }
+    if (!e)
+      throw new Error("No hdlr found");
+    if (!i)
+      throw new Error("No minf found");
+    if (!n)
+      throw new Error("No mdhd found");
+    return new gi(e, i, n);
+  }
+};
+l(gi, "type", "mdia");
+let hn = gi;
+const ki = class ki {
+  constructor(t, e, i, n, a, c, d, w) {
+    l(this, "type", ki.type);
+    l(this, "modificationTime");
+    l(this, "creationTime");
+    l(this, "trackId");
+    l(this, "duration");
+    l(this, "alternateGroup");
+    l(this, "volume");
+    l(this, "width");
+    l(this, "height");
+    this.modificationTime = t, this.creationTime = e, this.trackId = i, this.duration = n, this.alternateGroup = a, this.volume = c, this.width = d, this.height = w;
+  }
+  static decodeData(t) {
+    const e = ue(t);
+    let i = 0, n = 0;
+    e.version === 1 ? (i = t.readUint64(), n = t.readUint64()) : (i = t.readUint32(), n = t.readUint32());
+    const a = t.readUint32();
+    t.readUint32();
+    const c = t.readUint32();
+    t.readUint32(), t.readUint32(), t.readUint16();
+    const d = t.readUint16(), w = t.readUint16();
+    t.readUint16(), new Array(9).fill(0).map(() => t.readUint32());
+    const p = t.readUint16();
+    t.readUint16();
+    const m = t.readUint16();
+    return t.readUint16(), new ki(i, n, a, c, d, w, p, m);
+  }
+};
+l(ki, "type", "tkhd");
+let dn = ki;
+const Ii = class Ii {
+  constructor(t, e) {
+    l(this, "type", Ii.type);
+    l(this, "tkhd");
+    l(this, "mdia");
+    this.tkhd = t, this.mdia = e;
+  }
+  static decodeData(t) {
+    let e, i;
+    for (; t.remaining() > 0; ) {
+      const n = kt(t);
+      n instanceof dn && (e = n), n instanceof hn && (i = n);
+    }
+    if (!e)
+      throw new Error("No tkhd found");
+    if (!i)
+      throw new Error("No mdia found");
+    return new Ii(e, i);
+  }
+};
+l(Ii, "type", "trak");
+let ln = Ii;
+const vi = class vi {
+  constructor(t, e) {
+    l(this, "type", vi.type);
+    l(this, "mvhd");
+    l(this, "traks");
+    this.mvhd = t, this.traks = e;
+  }
+  static decodeData(t) {
+    let e;
+    const i = [];
+    for (; t.remaining() > 0; ) {
+      const n = kt(t);
+      n instanceof ln && i.push(n), n instanceof rn && (e = n);
+    }
+    if (!e)
+      throw new Error("No mvhd found");
+    return new vi(e, i);
+  }
+};
+l(vi, "type", "moov");
+let wn = vi;
+const Si = class Si {
+  constructor(t, e, i, n, a, c, d, w) {
+    l(this, "type", Si.type);
+    l(this, "configurationVersion");
+    l(this, "avcProfileIndication");
+    l(this, "profileCompatibility");
+    l(this, "avcLevelIndication");
+    l(this, "lengthSizeMinusOne");
+    l(this, "sequenceParameterSets");
+    l(this, "pictureParameterSets");
+    l(this, "bytes");
+    this.configurationVersion = t, this.avcProfileIndication = e, this.profileCompatibility = i, this.avcLevelIndication = n, this.lengthSizeMinusOne = a, this.sequenceParameterSets = c, this.pictureParameterSets = d, this.bytes = w;
+  }
+  static decodeData(t) {
+    const e = t.buffer(), i = t.readUint8(), n = t.readUint8(), a = t.readUint8(), c = t.readUint8(), d = t.readUint8() & 3, w = t.readUint8() & 31, p = [];
+    for (let I = 0; I < w; I++) {
+      const g = t.readBytes(t.readUint16());
+      p.push(g);
+    }
+    const m = t.readUint8(), b = [];
+    for (let I = 0; I < m; I++) {
+      const g = t.readBytes(t.readUint16());
+      b.push(g);
+    }
+    return new Si(
+      i,
+      n,
+      a,
+      c,
+      d,
+      p,
+      b,
+      e
+    );
+  }
+};
+l(Si, "type", "avcC");
+let ua = Si;
+const Ui = class Ui {
+  constructor(t, e, i, n, a) {
+    l(this, "type", Ui.type);
+    l(this, "avcC");
+    l(this, "width");
+    l(this, "height");
+    l(this, "horizontalResolution");
+    l(this, "verticalResolution");
+    this.avcC = t, this.width = e, this.height = i, this.horizontalResolution = n, this.verticalResolution = a;
+  }
+  static decodeData(t) {
+    t.readUint32(), t.readUint16(), t.readUint16(), t.readUint32(), t.readUint64(), t.readUint32();
+    const e = t.readUint16(), i = t.readUint16(), n = t.readUint32(), a = t.readUint32();
+    t.readUint32(), t.readUint16(), t.readBytes(32), t.readUint16(), t.readUint16();
+    let c;
+    for (; t.remaining() > 0; ) {
+      const d = kt(t);
+      switch (d.type) {
+        case "avcC":
+          c = d;
+          break;
+      }
+    }
+    if (!c)
+      throw new Error("no avcC");
+    return new Ui(c, e, i, n, a);
+  }
+};
+l(Ui, "type", "avc1");
+let ha = Ui;
+const Ei = class Ei {
+  constructor() {
+    l(this, "type", Ei.type);
+  }
+  static decodeData(t) {
+    return new Ei();
+  }
+};
+l(Ei, "type", "dOps");
+let da = Ei;
+const Ti = class Ti {
+  constructor(t, e, i) {
+    l(this, "type", Ti.type);
+    l(this, "dops");
+    l(this, "channelCount");
+    l(this, "sampleRate");
+    this.dops = t, this.channelCount = e, this.sampleRate = i;
+  }
+  static decodeData(t) {
+    t.readUint32(), t.readUint16(), t.readUint16();
+    const e = t.readUint16();
+    t.readUint16(), t.readUint32();
+    const i = t.readUint16();
+    t.readUint16(), t.readUint32();
+    const n = t.readUint16();
+    t.readUint16(), e === 1 && (t.readUint64(), t.readUint64());
+    const a = Gc(da, t);
+    return new Ti(a, i, n);
+  }
+};
+l(Ti, "type", "Opus");
+let la = Ti;
+const es = class es {
+  constructor(t, e) {
+    l(this, "type", es.type);
+    l(this, "ntpTimestamp");
+    l(this, "mediaTime");
+    this.ntpTimestamp = t, this.mediaTime = e;
+  }
+  static decodeData(t) {
+    const { version: e } = ue(t);
+    t.readUint32();
+    const i = t.readUint32(), n = t.readUint32();
+    if (e === 1) {
+      const c = t.readUint64();
+      return new es([i, n], c);
+    }
+    const a = t.readUint32();
+    return new es([i, n], a);
+  }
+};
+l(es, "type", "prft");
+let fn = es;
+var Bi, xi;
+class Lc {
+  constructor(t, e) {
+    o(this, Bi);
+    o(this, xi);
+    u(this, Bi, t), u(this, xi, e.readBytes(t.size));
+  }
+  data() {
+    return s(this, xi);
+  }
+  get type() {
+    return s(this, Bi).type;
+  }
+}
+Bi = new WeakMap(), xi = new WeakMap();
+const Fc = {
+  moov: wn,
+  trak: ln,
+  tkhd: dn,
+  mvhd: rn,
+  moof: sn,
+  traf: en,
+  tfdt: tn,
+  trun: Di,
+  mdat: _r,
+  mdia: hn,
+  hdlr: nn,
+  minf: un,
+  stbl: cn,
+  mdhd: an,
+  stsd: on,
+  prft: fn,
+  avc1: ha,
+  avcC: ua,
+  Opus: la,
+  emsg: qr
+};
+function kt(r) {
+  const t = So(r), e = Fc[t.type], i = new Xn(r.readBytes(t.size));
+  if (!e) {
+    const a = new Lc(t, i);
+    return i.readRemaining(), a;
+  }
+  const n = e.decodeData(i);
+  return i.readRemaining(), n;
+}
+function Wc(r) {
+  if (r.byteLength < 8)
+    throw new Error("Buffer too small");
+  const t = new Xn(r), e = /* @__PURE__ */ new Map();
+  for (; t.remaining() > 0; ) {
+    const a = kt(t);
+    e.set(a.type, a);
+  }
+  const i = e.get("ftyp"), n = e.get("moov");
+  if (!i)
+    throw new Error("ftyp atom not found");
+  if (!n || !(n instanceof wn))
+    throw new Error("moov atom not found");
+  return {
+    ftyp: i,
+    moov: n
+  };
+}
+function $c(r) {
+  if (r.byteLength < 8)
+    throw new Error("Buffer too small");
+  const t = new Xn(r), e = /* @__PURE__ */ new Map(), i = [];
+  for (; t.remaining() > 0; ) {
+    const d = kt(t);
+    d instanceof qr && i.push(d), e.set(d.type, d);
+  }
+  const n = e.get("moof"), a = e.get("mdat"), c = e.get("prft");
+  if (!n || !(n instanceof sn))
+    throw new Error("moof atom not found");
+  if (!a || !(a instanceof _r))
+    throw new Error("mdat atom not found");
+  if (c && !(c instanceof fn))
+    throw new Error("invalid prft found");
+  return {
+    moof: n,
+    mdat: a,
+    prft: c,
+    emsgs: i
+  };
+}
+var Pi, Ri;
+class Mc {
+  constructor(t) {
+    o(this, Pi);
+    o(this, Ri);
+    u(this, Pi, t), u(this, Ri, Wc(t));
+  }
+  rawBytes() {
+    return s(this, Pi);
+  }
+  init() {
+    return s(this, Ri);
+  }
+}
+Pi = new WeakMap(), Ri = new WeakMap();
+var lt, tt, T;
+class zc {
+  constructor(t, e) {
+    o(this, lt);
+    o(this, tt);
+    o(this, T);
+    u(this, lt, e), u(this, tt, t), u(this, T, $c(e));
+  }
+  /**
+   * Update the raw bytes of the fragment with the new baseMediaDecodeTime
+   * @param baseMediaDecodeTime
+   */
+  updateBaseMediaDecodeTime(t) {
+    const e = new DataView(s(this, lt).buffer, s(this, lt).byteOffset, s(this, lt).byteLength);
+    if (s(this, T).moof.traf.tfdt)
+      if (s(this, T).moof.traf.tfdt.baseMediaDecodeTime = t, s(this, T).moof.traf.tfdt.extra.version === 1) {
+        const i = Math.floor(t / 4294967296), n = (t & 4294967295) >>> 0;
+        e.setUint32(s(this, T).moof.traf.tfdt.byteOffset - s(this, lt).byteOffset, i), e.setUint32(s(this, T).moof.traf.tfdt.byteOffset - s(this, lt).byteOffset + 4, n);
+      } else
+        e.setUint32(s(this, T).moof.traf.tfdt.byteOffset - s(this, lt).byteOffset, t);
+  }
+  producerReferenceTime() {
+    if (!s(this, T).prft)
+      return;
+    const [t, e] = s(this, T).prft.ntpTimestamp, i = t * 1e3 + e / 2 ** 32 * 1e3, n = new Date(Date.UTC(1900, 0, 1, 0, 0, 0));
+    return new Date(n.getTime() + i);
+  }
+  duration() {
+    var t;
+    return ((t = s(this, T).moof.traf.trun) == null ? void 0 : t.sampleDurations.reduce((e, i) => e + i, 0)) || 0;
+  }
+  baseMediaDecodeTime() {
+    var e;
+    const t = (e = s(this, T).moof.traf.tfdt) == null ? void 0 : e.baseMediaDecodeTime;
+    if (!t)
+      throw new Error("no baseMediaDecodeTime");
+    return t;
+  }
+  startsWithKeyframe() {
+    const t = s(this, T).moof.traf.trun, e = (t == null ? void 0 : t.firstSampleFlags) || (t == null ? void 0 : t.sampleFlags[0]);
+    return e ? (e & Di.FLAG_SAMPLE_DEPENDS_NO) !== 0 : !1;
+  }
+  timescale() {
+    const t = s(this, tt).init().moov.traks[0];
+    if (!t)
+      throw new Error("no tracks");
+    return t.mdia.mdhd.timescale;
+  }
+  mediaType() {
+    var e;
+    const t = (e = s(this, tt).init().moov.traks[0]) == null ? void 0 : e.mdia.hdlr.mediaType();
+    if (!t)
+      throw new Error("no media type");
+    return t;
+  }
+  header() {
+    return s(this, tt);
+  }
+  fragment() {
+    return s(this, T);
+  }
+  samplesCount() {
+    var t;
+    return ((t = s(this, T).moof.traf.trun) == null ? void 0 : t.samplesCount) || 0;
+  }
+  sample(t) {
+    var g, E, z, _, A, S, W, v, R, ei, Nr, Gr, $a, Ma, za;
+    const e = (g = s(this, tt).init().moov.traks[0]) == null ? void 0 : g.mdia.minf.stbl.stsd.codec, i = ((E = s(this, T).moof.traf.trun) == null ? void 0 : E.samplesCount) || 0, n = (z = s(this, T).moof.traf.tfdt) == null ? void 0 : z.baseMediaDecodeTime;
+    if (t >= i || typeof n == "undefined" || !e)
+      return;
+    const a = ((_ = s(this, T).moof.traf.trun) == null ? void 0 : _.sampleDurations[t]) || 0, c = ((A = s(this, T).moof.traf.trun) == null ? void 0 : A.sampleDurations.slice(0, t).reduce((si, ii) => si + ii, 0)) || 0, d = n + c, w = ((S = s(this, tt).init().moov.traks[0]) == null ? void 0 : S.mdia.mdhd.timescale) || 1e3, p = ((W = s(this, T).moof.traf.trun) == null ? void 0 : W.sampleSizes[t]) || s(this, T).mdat.data.byteLength, m = ((v = s(this, T).moof.traf.trun) == null ? void 0 : v.sampleSizes.slice(0, t).reduce((si, ii) => si + ii, 0)) || 0, b = s(this, T).mdat.data.subarray(m, m + p), I = ((R = s(this, T).moof.traf.trun) == null ? void 0 : R.is_sync_sample(t)) || !1;
+    if (this.mediaType() === "video") {
+      const si = ((ei = s(this, tt).init().moov.traks[0]) == null ? void 0 : ei.tkhd.width) || 0, ii = ((Nr = s(this, tt).init().moov.traks[0]) == null ? void 0 : Nr.tkhd.height) || 0;
+      return {
+        type: "video",
+        codec: e,
+        width: si,
+        height: ii,
+        duration: a,
+        isSync: I,
+        timescale: w,
+        timestamp: d,
+        data: b
+      };
+    }
+    return {
+      type: "audio",
+      codec: e,
+      channels: (($a = (Gr = s(this, tt).init().moov.traks[0]) == null ? void 0 : Gr.mdia.minf.stbl.stsd.opus) == null ? void 0 : $a.channelCount) || 0,
+      sampleRate: ((za = (Ma = s(this, tt).init().moov.traks[0]) == null ? void 0 : Ma.mdia.minf.stbl.stsd.opus) == null ? void 0 : za.sampleRate) || 0,
+      duration: a,
+      isSync: I,
+      timestamp: d,
+      data: b,
+      timescale: w
+    };
+  }
+  /**
+   * @returns the raw bytes of the cmaf fragment
+   */
+  rawBytes() {
+    return s(this, lt);
+  }
+}
+lt = new WeakMap(), tt = new WeakMap(), T = new WeakMap();
+var os;
+class Ja {
+  constructor(t) {
+    o(this, os);
+    u(this, os, new Mc(t));
+  }
+  header() {
+    return s(this, os);
+  }
+  createFragment(t) {
+    return new zc(s(this, os), t);
+  }
+}
+os = new WeakMap();
+var pn = /* @__PURE__ */ ((r) => (r[r.StreamHeaderGroup = 4] = "StreamHeaderGroup", r[r.FetchHeader = 5] = "FetchHeader", r[r.StreamHeaderTrack = 60] = "StreamHeaderTrack", r))(pn || {});
+const X = {
+  Normal: 0,
+  ObjectDoesNotExist: 1,
+  GroupDoesNotExist: 2,
+  EndOfGroup: 3,
+  EndOfTrackAndGroup: 4
+};
+function Uo(r) {
+  switch (r) {
+    case X.Normal:
+    case X.ObjectDoesNotExist:
+    case X.GroupDoesNotExist:
+    case X.EndOfGroup:
+    case X.EndOfTrackAndGroup:
+      return;
+  }
+  throw new Error("Unknown object status " + r);
+}
+var vt, cs, us, ji, Ni, hs, Gi, Li;
+class Hc {
+  constructor(t, e, i, n, a, c) {
+    o(this, vt);
+    o(this, cs);
+    o(this, us);
+    o(this, ji);
+    o(this, Ni);
+    o(this, hs, new V());
+    o(this, Gi, 0);
+    o(this, Li);
+    u(this, vt, t), u(this, cs, e), u(this, us, i), u(this, ji, n), u(this, Ni, a), u(this, Li, c);
+  }
+  endStatus() {
+    return s(this, hs).promise;
+  }
+  groupId() {
+    return s(this, cs);
+  }
+  subscribeId() {
+    return s(this, us);
+  }
+  next() {
+    return h(this, null, function* () {
+      if (!s(this, hs).pending)
+        return { done: !0, value: void 0 };
+      if (yield s(this, vt).isDone())
+        return { done: !0, value: void 0 };
+      const t = s(this, Gi) === 0 ? s(this, cs) : yield s(this, vt).readBigVarInt(), e = yield s(this, vt).readBigVarInt(), i = yield s(this, vt).readVarInt();
+      let n = 0, a = new Uint8Array();
+      return i > 0 ? a = yield s(this, vt).read(i) : n = yield s(this, vt).readVarInt(), Uo(n), (n === X.EndOfTrackAndGroup || n === X.EndOfGroup) && s(this, hs).resolve(n), _n(this, Gi)._++, {
+        done: !1,
+        value: {
+          subscribeId: s(this, us),
+          trackAlias: s(this, ji),
+          groupId: t,
+          subGroupId: k(0),
+          objectId: e,
+          subscriberPriority: s(this, Ni),
+          streamId: s(this, Li),
+          objectStatus: n,
+          payload: a
+        }
+      };
+    });
+  }
+  return() {
+    return h(this, null, function* () {
+      for (; !(yield this.next()).done; )
+        ;
+      return { done: !0, value: void 0 };
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  [Ct()]() {
+    return Promise.resolve();
+  }
+  [Symbol.asyncDispose]() {
+    return Promise.resolve();
+  }
+}
+vt = new WeakMap(), cs = new WeakMap(), us = new WeakMap(), ji = new WeakMap(), Ni = new WeakMap(), hs = new WeakMap(), Gi = new WeakMap(), Li = new WeakMap();
+var St, ds, Fi, Wi, ls, Xe, Eo, wa;
+class Xc {
+  constructor(t, e, i, n, a) {
+    o(this, Xe);
+    o(this, St);
+    o(this, ds);
+    o(this, Fi);
+    o(this, Wi);
+    o(this, ls);
+    u(this, St, t), u(this, ds, e), u(this, Fi, i), u(this, Wi, n), u(this, ls, a);
+  }
+  /**
+   * @returns The underlying stream id that provided this object group
+   */
+  streamId() {
+    return s(this, ls);
+  }
+  groups() {
+    return f(this, Xe, Eo).call(this);
+  }
+  subscribeId() {
+    return s(this, ds);
+  }
+  return() {
+    return h(this, null, function* () {
+      return yield s(this, St).close(), { done: !0, value: void 0 };
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  [Ct()]() {
+    return f(this, Xe, wa).call(this);
+  }
+  [Symbol.asyncDispose]() {
+    return f(this, Xe, wa).call(this);
+  }
+}
+St = new WeakMap(), ds = new WeakMap(), Fi = new WeakMap(), Wi = new WeakMap(), ls = new WeakMap(), Xe = new WeakSet(), Eo = function() {
+  return xt(this, null, function* () {
+    for (; !(yield new O(s(this, St).isDone())); ) {
+      const t = yield new O(s(this, St).readBigVarInt()), e = new Hc(
+        s(this, St),
+        t,
+        s(this, ds),
+        s(this, Fi),
+        s(this, Wi),
+        s(this, ls)
+      );
+      if (yield e, (yield new O(Promise.race([e.endStatus(), s(this, St).closed()]))) === X.EndOfTrackAndGroup)
+        return;
+    }
+  });
+}, wa = function() {
+  return s(this, St).close().catch(() => {
+  });
+};
+var wt, ws, $i, fs, Mi, zi, Hi, ps, Sn, Ye, To, fa;
+class Yc {
+  constructor(t, e, i, n, a, c, d) {
+    o(this, Ye);
+    o(this, wt);
+    o(this, ws);
+    o(this, $i);
+    o(this, fs);
+    o(this, Mi);
+    o(this, zi);
+    o(this, Hi, !1);
+    o(this, ps);
+    o(this, Sn, gt.get().createContext("GroupReader"));
+    u(this, wt, t), u(this, ws, e), u(this, $i, i), u(this, fs, n), u(this, Mi, a), u(this, zi, c), u(this, ps, d);
+  }
+  /**
+   * @returns The underlying stream id that provided this object group
+   */
+  streamId() {
+    return s(this, ps);
+  }
+  groupId() {
+    return s(this, fs);
+  }
+  subscribeId() {
+    return s(this, ws);
+  }
+  next() {
+    return h(this, null, function* () {
+      try {
+        if ((yield s(this, wt).isDone()) || s(this, Hi))
+          return { done: !0, value: void 0 };
+        const t = yield s(this, wt).readBigVarInt(), e = yield s(this, wt).readVarInt();
+        let i = 0, n = new Uint8Array();
+        return e > 0 ? n = yield s(this, wt).read(e) : i = yield s(this, wt).readVarInt(), Uo(i), i === X.EndOfGroup && u(this, Hi, !0), {
+          done: !1,
+          value: {
+            subscribeId: s(this, ws),
+            trackAlias: s(this, $i),
+            groupId: s(this, fs),
+            subGroupId: s(this, Mi),
+            subscriberPriority: s(this, zi),
+            streamId: s(this, ps),
+            objectId: t,
+            objectStatus: i,
+            payload: n
+          }
+        };
+      } catch (t) {
+        return s(this, Sn).info("Error reading object", { error: t }), { done: !0, value: void 0 };
+      }
+    });
+  }
+  return() {
+    return h(this, null, function* () {
+      return yield s(this, wt).close().catch(() => {
+      }), { done: !0, value: void 0 };
+    });
+  }
+  groups() {
+    return f(this, Ye, To).call(this);
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  [Ct()]() {
+    return f(this, Ye, fa).call(this);
+  }
+  [Symbol.asyncDispose]() {
+    return f(this, Ye, fa).call(this);
+  }
+}
+wt = new WeakMap(), ws = new WeakMap(), $i = new WeakMap(), fs = new WeakMap(), Mi = new WeakMap(), zi = new WeakMap(), Hi = new WeakMap(), ps = new WeakMap(), Sn = new WeakMap(), Ye = new WeakSet(), To = function() {
+  return xt(this, null, function* () {
+    yield this;
+  });
+}, fa = function() {
+  return s(this, wt).close().catch(() => {
+  });
+};
+function Ao(r, t) {
+  return h(this, null, function* () {
+    const e = yield r.readVarInt();
+    switch (e) {
+      case pn.StreamHeaderGroup: {
+        const i = yield r.readBigVarInt(), n = yield r.readBigVarInt(), a = yield r.readBigVarInt(), c = yield r.readBigVarInt(), d = yield r.readUnsigned8();
+        return new Yc(r, i, n, a, c, d, t);
+      }
+      case pn.StreamHeaderTrack: {
+        const i = yield r.readBigVarInt(), n = yield r.readBigVarInt(), a = yield r.readUnsigned8();
+        return new Xc(r, i, n, a, t);
+      }
+      default:
+        throw new Error("Unexpected message type " + e);
+    }
+  });
+}
+var Xt, Xi;
+class Zc {
+  constructor(t, e) {
+    o(this, Xt);
+    o(this, Xi);
+    u(this, Xt, t), u(this, Xi, e);
+  }
+  start(t) {
+    s(this, Xt).addEventListener("message", (e) => {
+      if (typeof e.data == "object" && e.data instanceof ArrayBuffer) {
+        const i = new Uint8Array(e.data);
+        i[0] == s(this, Xi) && t.enqueue(i.subarray(1));
+      }
+    }), s(this, Xt).addEventListener("error", (e) => t.error(e)), s(this, Xt).addEventListener("close", () => vo(() => t.close()));
+  }
+  cancel(t) {
+    s(this, Xt).close(void 0, t);
+  }
+}
+Xt = new WeakMap(), Xi = new WeakMap();
+var Ut, ye, ge, ke;
+class Kc {
+  constructor(t) {
+    o(this, Ut);
+    o(this, ye, null);
+    o(this, ge, null);
+    o(this, ke, null);
+    u(this, Ut, t);
+  }
+  start(t) {
+    u(this, ye, (e) => {
+      if (typeof e.data == "object" && e.data instanceof ArrayBuffer) {
+        const i = new Uint8Array(e.data), n = i[0] || 0, a = n & 127, c = (n >> 7 & 1) > 0;
+        if (a && a !== 0) {
+          const d = i.subarray(1);
+          t.enqueue([c, a, d]);
+        }
+      }
+    }), u(this, ge, () => vo(() => t.close())), u(this, ke, (e) => t.error(e)), s(this, Ut).addEventListener("message", s(this, ye)), s(this, Ut).addEventListener("error", s(this, ke)), s(this, Ut).addEventListener("close", s(this, ge));
+  }
+  cancel(t) {
+    s(this, ye) && s(this, Ut).removeEventListener("message", s(this, ye)), s(this, ke) && s(this, Ut).removeEventListener("error", s(this, ke)), s(this, ge) && s(this, Ut).removeEventListener("close", s(this, ge));
+  }
+}
+Ut = new WeakMap(), ye = new WeakMap(), ge = new WeakMap(), ke = new WeakMap();
+var Et, Yi, Ie, Tt, Un, U, ai, Mr, we, zr, Ht;
+class bn {
+  constructor(t, e) {
+    o(this, U);
+    o(this, Et);
+    o(this, Yi);
+    o(this, Ie);
+    o(this, Tt, 0);
+    o(this, Un, new TextDecoder());
+    u(this, Et, t), u(this, Yi, e), u(this, Ie, e.getReader());
+  }
+  readUnsigned8() {
+    return h(this, null, function* () {
+      return yield f(this, U, we).call(this, 1), f(this, U, Ht).call(this, 1)[0];
+    });
+  }
+  readString() {
+    return h(this, null, function* () {
+      const t = yield this.readVarInt(), e = yield this.read(t);
+      return s(this, Un).decode(e);
+    });
+  }
+  readVarInt() {
+    return h(this, null, function* () {
+      const t = yield this.readBigVarInt();
+      if (t > Number.MAX_SAFE_INTEGER)
+        throw new Error("VarInt is too large");
+      return Number(t);
+    });
+  }
+  readBigVarInt() {
+    return h(this, null, function* () {
+      yield f(this, U, we).call(this, 1);
+      const t = (f(this, U, zr).call(this, 1)[0] & 192) >> 6;
+      switch (s(this, Et)[s(this, Tt)] = f(this, U, zr).call(this, 1)[0] & 63, t) {
+        case 0:
+          return k(f(this, U, Ht).call(this, 1)[0]);
+        case 1: {
+          yield f(this, U, we).call(this, 2);
+          const e = f(this, U, Ht).call(this, 2), i = new DataView(e.buffer, e.byteOffset, e.byteLength);
+          return k(i.getUint16(0));
+        }
+        case 2: {
+          yield f(this, U, we).call(this, 4);
+          const e = f(this, U, Ht).call(this, 4), i = new DataView(e.buffer, e.byteOffset, e.byteLength);
+          return k(i.getUint32(0));
+        }
+        case 3: {
+          yield f(this, U, we).call(this, 8);
+          const e = f(this, U, Ht).call(this, 8), i = new DataView(e.buffer, e.byteOffset, e.byteLength);
+          if (typeof i.getBigUint64 != "undefined")
+            return k(i.getBigUint64(0));
+          const n = Ac(e, 0, 7);
+          return k(n);
+        }
+        default:
+          throw new Error("Invalid VarInt size");
+      }
+    });
+  }
+  read(t) {
+    return h(this, null, function* () {
+      return yield f(this, U, we).call(this, t), f(this, U, Ht).call(this, t);
+    });
+  }
+  readAll() {
+    return h(this, null, function* () {
+      for (; yield f(this, U, Mr).call(this); )
+        ;
+      return f(this, U, Ht).call(this, f(this, U, ai).call(this));
+    });
+  }
+  isDone() {
+    return h(this, null, function* () {
+      return f(this, U, ai).call(this) > 0 ? !1 : (yield f(this, U, Mr).call(this)) == 0;
+    });
+  }
+  closed() {
+    return h(this, null, function* () {
+      return s(this, Ie).closed;
+    });
+  }
+  close() {
+    return h(this, null, function* () {
+      return s(this, Ie).releaseLock(), s(this, Yi).cancel();
+    });
+  }
+}
+Et = new WeakMap(), Yi = new WeakMap(), Ie = new WeakMap(), Tt = new WeakMap(), Un = new WeakMap(), U = new WeakSet(), ai = function() {
+  return s(this, Et).length - s(this, Tt);
+}, Mr = function() {
+  return h(this, null, function* () {
+    const { value: t, done: e } = yield s(this, Ie).read();
+    if (e)
+      return Promise.resolve(0);
+    if (f(this, U, ai).call(this) === 0)
+      u(this, Et, t);
+    else {
+      const n = s(this, Et).subarray(s(this, Tt)), a = new Uint8Array(n.length + t.length);
+      a.set(n), a.set(t, n.byteLength), u(this, Et, a);
+    }
+    return u(this, Tt, 0), Promise.resolve(t.length);
+  });
+}, we = function(t) {
+  return h(this, null, function* () {
+    for (; f(this, U, ai).call(this) < t; )
+      if ((yield f(this, U, Mr).call(this)) === 0)
+        throw new Error("Read failed");
+  });
+}, zr = function(t) {
+  return s(this, Et).subarray(s(this, Tt), s(this, Tt) + t);
+}, Ht = function(t) {
+  const e = f(this, U, zr).call(this, t);
+  return u(this, Tt, s(this, Tt) + e.length), e;
+};
+var bs, ms, Rt, En;
+class Do {
+  constructor(t) {
+    o(this, bs, new Uint8Array(8));
+    o(this, ms);
+    o(this, Rt);
+    o(this, En, new TextEncoder());
+    u(this, ms, t), u(this, Rt, s(this, ms).getWriter());
+  }
+  writeString(t) {
+    return h(this, null, function* () {
+      const e = s(this, En).encode(t);
+      return yield this.writeVarInt(e.length), this.write(e);
+    });
+  }
+  write(t) {
+    return s(this, Rt).write(t);
+  }
+  writeUnsigned8(t) {
+    return s(this, Rt).write(Kn(t, s(this, bs)));
+  }
+  writeVarInt(t) {
+    return s(this, Rt).write(No(t, s(this, bs)));
+  }
+  writeBigVarInt(t) {
+    return s(this, Rt).write(Go(t, s(this, bs)));
+  }
+  flush() {
+    return h(this, null, function* () {
+    });
+  }
+  close() {
+    return h(this, null, function* () {
+      s(this, Rt).releaseLock(), yield s(this, ms).close();
+    });
+  }
+}
+bs = new WeakMap(), ms = new WeakMap(), Rt = new WeakMap(), En = new WeakMap();
+const Oo = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+};
+var J, et, ve, Tn;
+const Ai = class Ai {
+  constructor(t) {
+    o(this, J, 0);
+    o(this, et, new Uint8Array(Ai.DEFAULT_BUFFER_SIZE));
+    o(this, ve);
+    o(this, Tn, new TextEncoder());
+    u(this, ve, t);
+  }
+  writeString(t) {
+    return h(this, null, function* () {
+      const e = s(this, Tn).encode(t);
+      return yield this.writeVarInt(e.length), this.write(e);
+    });
+  }
+  ensureBufferSpace(t) {
+    if (s(this, et).length - s(this, J) >= t)
+      return;
+    const e = new Uint8Array(s(this, et).length * 2);
+    e.set(s(this, et)), u(this, et, e);
+  }
+  write(t) {
+    return this.ensureBufferSpace(t.length), s(this, et).set(t, s(this, J)), u(this, J, s(this, J) + t.byteLength), Promise.resolve();
+  }
+  writeUnsigned8(t) {
+    return this.ensureBufferSpace(1), Kn(t, s(this, et).subarray(s(this, J))), u(this, J, s(this, J) + 1), Promise.resolve();
+  }
+  writeVarInt(t) {
+    if (t < 0)
+      throw new Error(`VarInt can not be negative: ${t}`);
+    return this.ensureBufferSpace(8), u(this, J, s(this, J) + No(t, s(this, et).subarray(s(this, J))).byteLength), Promise.resolve();
+  }
+  writeBigVarInt(t) {
+    if (t < 0)
+      throw new Error(`VarInt can not be negative: ${t}`);
+    return this.ensureBufferSpace(8), u(this, J, s(this, J) + Go(t, s(this, et).subarray(s(this, J))).byteLength), Promise.resolve();
+  }
+  flush() {
+    if (s(this, ve).readyState !== Oo.OPEN)
+      throw new Error("Writer is not open");
+    return s(this, ve).send(s(this, et).subarray(0, s(this, J))), u(this, J, 0), u(this, et, new Uint8Array(Ai.DEFAULT_BUFFER_SIZE)), Promise.resolve();
+  }
+  close() {
+    return s(this, ve).close(), Promise.resolve();
+  }
+};
+J = new WeakMap(), et = new WeakMap(), ve = new WeakMap(), Tn = new WeakMap(), l(Ai, "DEFAULT_BUFFER_SIZE", 1024);
+let Oi = Ai;
+const Vo = Math.pow(2, 6) - 1, Co = Math.pow(2, 14) - 1, Bo = Math.pow(2, 30) - 1, Jc = Number.MAX_SAFE_INTEGER, Qc = typeof BigInt == "function" ? k(2) ** k(62) - k(1) : k(Number.MAX_SAFE_INTEGER);
+function Kn(r, t) {
+  return t[0] = r, t.subarray(0, 1);
+}
+function xo(r, t) {
+  const e = new DataView(t.buffer, t.byteOffset, 2);
+  return e.setUint16(0, r), new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+}
+function Po(r, t) {
+  const e = new DataView(t.buffer, t.byteOffset, 4);
+  return e.setUint32(0, r), new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+}
+function Ro(r, t) {
+  const e = new DataView(t.buffer, t.byteOffset, 8);
+  return e.setBigUint64(0, r), new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+}
+function jo(r, t) {
+  const e = new DataView(t.buffer, t.byteOffset, 8);
+  return e.setUint32(0, r / 4294967296), e.setUint32(4, r & 4294967295), t.set([192], 0), new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+}
+function No(r, t) {
+  if (r <= Vo)
+    return Kn(r, t);
+  if (r <= Co)
+    return xo(r | 16384, t);
+  if (r <= Bo)
+    return Po(r | 2147483648, t);
+  if (r <= Jc)
+    return typeof BigInt == "function" ? Ro(BigInt(r) | BigInt(3221225472) << BigInt(32), t) : jo(Number(r), t);
+  throw new Error(`overflow, value larger than 53-bits: ${r}`);
+}
+function Go(r, t) {
+  if (r < Vo)
+    return Kn(Number(r), t);
+  if (r < Co)
+    return xo(Number(r) | 16384, t);
+  if (r <= Bo)
+    return Po(Number(r) | 2147483648, t);
+  if (r <= Qc)
+    return typeof BigInt == "function" ? Ro(BigInt(r) | BigInt(3221225472) << BigInt(32), t) : jo(Number(r), t);
+  throw new Error(`overflow, value larger than 62-bits: ${r}`);
+}
+var y = /* @__PURE__ */ ((r) => (r[r.SubscribeUpdate = 2] = "SubscribeUpdate", r[r.Subscribe = 3] = "Subscribe", r[r.SubscribeOk = 4] = "SubscribeOk", r[r.SubscribeError = 5] = "SubscribeError", r[r.Announce = 6] = "Announce", r[r.AnnounceOk = 7] = "AnnounceOk", r[r.AnnounceError = 8] = "AnnounceError", r[r.Unannounce = 9] = "Unannounce", r[r.Unsubscribe = 10] = "Unsubscribe", r[r.SubscribeDone = 11] = "SubscribeDone", r[r.AnnounceCancel = 12] = "AnnounceCancel", r[r.TrackStatusRequest = 13] = "TrackStatusRequest", r[r.TrackStatus = 14] = "TrackStatus", r[r.Goaway = 16] = "Goaway", r[r.ClientSetup = 64] = "ClientSetup", r[r.ServerSetup = 65] = "ServerSetup", r[r.Unknown = 255] = "Unknown", r))(y || {});
+function Jn(r) {
+  return h(this, null, function* () {
+    const t = yield r.readVarInt();
+    if (t < 1 || t > 32)
+      throw new Error(`namespace must be between 1 and 32, got ${t}`);
+    const e = [];
+    for (let i = 0; i < t; i++)
+      e.push(yield r.readString());
+    return e;
+  });
+}
+function Ba(r, t) {
+  return h(this, null, function* () {
+    yield r.writeVarInt(t.length);
+    for (const e of t)
+      yield r.writeString(e);
+  });
+}
+const mn = k(2);
+function _s(r) {
+  return h(this, null, function* () {
+    const t = yield r.readVarInt(), e = /* @__PURE__ */ new Map();
+    for (let i = 0; i < t; i++) {
+      const n = yield r.readBigVarInt(), a = yield r.read(yield r.readVarInt());
+      e.set(n, { type: n, payload: a });
+    }
+    return e;
+  });
+}
+function ti(r, t) {
+  return h(this, null, function* () {
+    yield r.writeVarInt(t.size);
+    for (const [e, i] of t)
+      yield r.writeBigVarInt(e), yield r.writeVarInt(i.payload.length), yield r.write(i.payload);
+  });
+}
+function qc(r) {
+  return h(this, null, function* () {
+    return {
+      type: y.Announce,
+      namespace: yield Jn(r),
+      params: yield _s(r)
+    };
+  });
+}
+function _c(r, t) {
+  return h(this, null, function* () {
+    yield Ba(r, t.namespace), yield ti(r, t.params);
+  });
+}
+function tu(r) {
+  return h(this, null, function* () {
+    return {
+      type: y.AnnounceOk,
+      namespace: yield Jn(r)
+    };
+  });
+}
+function eu(r, t) {
+  return h(this, null, function* () {
+    yield Ba(r, t.namespace);
+  });
+}
+const su = {
+  Publisher: 1,
+  Subscriber: 2,
+  Both: 3
+}, yn = {
+  Role: k(0)
+}, Lo = {
+  Draft07: 4278190087
+};
+function Fo(r) {
+  return h(this, null, function* () {
+    const t = yield r.readVarInt();
+    switch (t) {
+      case Lo.Draft07:
+        return { type: "known", value: t };
+      default:
+        return { type: "unknown", value: t };
+    }
+  });
+}
+function iu(r, t) {
+  return h(this, null, function* () {
+    yield r.writeVarInt(t.supportedVersions.length);
+    for (const e of t.supportedVersions)
+      yield r.writeVarInt(e.value);
+    yield ti(r, t.parameters);
+  });
+}
+function ru(r) {
+  return h(this, null, function* () {
+    const t = [], e = yield r.readVarInt();
+    for (let n = 0; n < e; n++)
+      t.push(yield Fo(r));
+    const i = yield _s(r);
+    if (!i.has(yn.Role))
+      throw new Error("Role parameter is required");
+    return {
+      type: y.ClientSetup,
+      supportedVersions: t,
+      parameters: i
+    };
+  });
+}
+function nu(r, t) {
+  return h(this, null, function* () {
+    yield r.writeVarInt(t.selectedVersion.value), yield ti(r, t.parameters);
+  });
+}
+function au(r) {
+  return h(this, null, function* () {
+    const t = yield Fo(r);
+    if (t.type !== "known")
+      throw new Error("Expected known version");
+    const e = yield _s(r);
+    if (!e.has(yn.Role))
+      throw new Error("Role parameter is required");
+    return {
+      type: y.ServerSetup,
+      selectedVersion: t,
+      parameters: e
+    };
+  });
+}
+const ou = {
+  "latest-group": 1,
+  "latest-object": 2,
+  "absolute-start": 3,
+  "absolute-range": 4
+};
+function cu(r) {
+  return h(this, null, function* () {
+    const t = yield r.readVarInt();
+    switch (t) {
+      case 1:
+        return { type: "latest-group" };
+      case 2:
+        return { type: "latest-object" };
+      case 3:
+        return {
+          type: "absolute-start",
+          start: {
+            group: yield r.readBigVarInt(),
+            object: yield r.readBigVarInt()
+          }
+        };
+      case 4:
+        return {
+          type: "absolute-range",
+          start: {
+            group: yield r.readBigVarInt(),
+            object: yield r.readBigVarInt()
+          },
+          end: {
+            group: yield r.readBigVarInt(),
+            object: yield r.readBigVarInt()
+          }
+        };
+      default:
+        throw new Error(`Invalid location type ${t}`);
+    }
+  });
+}
+function uu(r, t) {
+  return h(this, null, function* () {
+    const e = ou[t.type];
+    switch (yield r.writeVarInt(e), t.type) {
+      case "absolute-range":
+        yield r.writeBigVarInt(t.start.group), yield r.writeBigVarInt(t.start.object), yield r.writeBigVarInt(t.end.group), yield r.writeBigVarInt(t.end.object);
+        break;
+      case "absolute-start":
+        yield r.writeBigVarInt(t.start.group), yield r.writeBigVarInt(t.start.object);
+        break;
+      case "latest-object":
+      case "latest-group":
+        break;
+      default:
+        throw new Error(`Invalid location type ${e}`);
+    }
+  });
+}
+function Wo(r) {
+  return h(this, null, function* () {
+    const t = yield r.readUnsigned8();
+    switch (t) {
+      case 0:
+        return "inherit-publisher";
+      case 1:
+        return "ascending";
+      case 2:
+        return "descending";
+      default:
+        throw new Error(`Invalid location type ${t}`);
+    }
+  });
+}
+function $o(r, t) {
+  return h(this, null, function* () {
+    switch (t) {
+      case "inherit-publisher":
+        yield r.writeUnsigned8(0);
+        break;
+      case "ascending":
+        yield r.writeUnsigned8(1);
+        break;
+      case "descending":
+        yield r.writeUnsigned8(2);
+        break;
+    }
+  });
+}
+function hu(r) {
+  return h(this, null, function* () {
+    const t = yield r.readBigVarInt(), e = yield r.readBigVarInt(), i = yield Jn(r), n = yield r.readString(), a = yield r.readUnsigned8(), c = yield Wo(r), d = yield cu(r), w = yield _s(r);
+    if (d.type === "absolute-range") {
+      const p = d.start.group > d.end.group, m = d.start.group === d.end.group && d.start.object > d.end.object;
+      if (p || m)
+        throw new Error("Invalid filter range");
+    }
+    return {
+      type: y.Subscribe,
+      id: t,
+      trackAlias: e,
+      namespace: i,
+      name: n,
+      subscriberPriority: a,
+      groupOrder: c,
+      filterType: d,
+      params: w
+    };
+  });
+}
+function du(r, t) {
+  return h(this, null, function* () {
+    yield r.writeBigVarInt(t.id), yield r.writeBigVarInt(t.trackAlias), yield Ba(r, t.namespace), yield r.writeString(t.name), yield r.writeUnsigned8(t.subscriberPriority), yield $o(r, t.groupOrder), yield uu(r, t.filterType), yield ti(r, t.params);
+  });
+}
+const pa = {
+  Unsubscribed: 0,
+  InternalError: 1,
+  Unauthorized: 2,
+  TrackEnded: 3,
+  SubscriptionEnded: 4,
+  GoingAway: 5,
+  Expired: 6
+};
+function lu(r) {
+  return h(this, null, function* () {
+    const t = yield r.readBigVarInt(), e = yield r.readVarInt(), i = yield r.readString(), n = (yield r.readUnsigned8()) == 1;
+    let a;
+    return n && (a = {
+      group: yield r.readBigVarInt(),
+      object: yield r.readBigVarInt()
+    }), {
+      type: y.SubscribeDone,
+      id: t,
+      errorCode: e,
+      reason: i,
+      finalInfo: a
+    };
+  });
+}
+function wu(r, t) {
+  return h(this, null, function* () {
+    yield r.writeBigVarInt(t.id), yield r.writeVarInt(t.errorCode), yield r.writeString(t.reason), yield r.writeUnsigned8(t.finalInfo ? 1 : 0), t.finalInfo && (yield r.writeBigVarInt(t.finalInfo.group), yield r.writeBigVarInt(t.finalInfo.object));
+  });
+}
+function fu(r) {
+  return h(this, null, function* () {
+    return {
+      type: y.SubscribeError,
+      id: yield r.readBigVarInt(),
+      errorCode: yield r.readBigVarInt(),
+      reason: yield r.readString(),
+      trackAlias: yield r.readBigVarInt()
+    };
+  });
+}
+function pu(r, t) {
+  return h(this, null, function* () {
+    yield r.writeBigVarInt(t.id), yield r.writeBigVarInt(t.errorCode), yield r.writeString(t.reason), yield r.writeBigVarInt(t.trackAlias);
+  });
+}
+function bu(r) {
+  return h(this, null, function* () {
+    const t = yield r.readBigVarInt(), e = yield r.readBigVarInt(), i = yield Wo(r), n = (yield r.readUnsigned8()) == 1;
+    let a;
+    if (i == "inherit-publisher")
+      throw new Error("SusbcribeOk cannot have inherit publisher group order");
+    n && (a = {
+      group: yield r.readBigVarInt(),
+      object: yield r.readBigVarInt()
+    });
+    const c = yield _s(r);
+    return {
+      type: y.SubscribeOk,
+      id: t,
+      groupOrder: i,
+      expires: e,
+      largestInfo: a,
+      params: c
+    };
+  });
+}
+function mu(r, t) {
+  return h(this, null, function* () {
+    yield r.writeBigVarInt(t.id), yield r.writeBigVarInt(t.expires), yield $o(r, t.groupOrder), yield r.writeUnsigned8(t.largestInfo ? 1 : 0), t.largestInfo && (yield r.writeBigVarInt(t.largestInfo.group), yield r.writeBigVarInt(t.largestInfo.object)), yield ti(r, t.params);
+  });
+}
+function yu(r) {
+  return h(this, null, function* () {
+    const t = yield r.readBigVarInt(), e = yield r.readBigVarInt(), i = yield r.readBigVarInt(), n = yield r.readBigVarInt(), a = yield r.readBigVarInt(), c = yield r.readUnsigned8(), d = yield _s(r), w = e > n, p = e === n && i > a;
+    if (w || p)
+      throw new Error("Invalid filter range");
+    return {
+      type: y.SubscribeUpdate,
+      id: t,
+      start: { group: e, object: i },
+      end: { group: n, object: a },
+      subscriberPriority: c,
+      params: d
+    };
+  });
+}
+function gu(r, t) {
+  return h(this, null, function* () {
+    yield r.writeBigVarInt(t.id), yield r.writeBigVarInt(t.start.group), yield r.writeBigVarInt(t.start.object), yield r.writeBigVarInt(t.end.group), yield r.writeBigVarInt(t.end.object), yield r.writeUnsigned8(t.subscriberPriority), yield ti(r, t.params);
+  });
+}
+function ku(r) {
+  return h(this, null, function* () {
+    return {
+      type: y.Unsubscribe,
+      id: yield r.readBigVarInt()
+    };
+  });
+}
+function Iu(r, t) {
+  return h(this, null, function* () {
+    yield r.writeBigVarInt(t.id);
+  });
+}
+var jt, ys, P, zo, Ho, Xo, Yo, Zo, Ko, Jo, Qo, qo, _o;
+class Mo {
+  constructor(t) {
+    o(this, P);
+    o(this, jt);
+    // Temporary buffer that holds the message before it is written to the stream
+    // This way we can calculate the byte length of the message before writing it
+    o(this, ys, new Uint8Array());
+    u(this, jt, t);
+  }
+  write(t) {
+    return h(this, null, function* () {
+      yield s(this, jt).writeVarInt(t.type);
+      const e = new Oi({
+        close: () => {
+        },
+        readyState: Oo.OPEN,
+        send: (i) => {
+          u(this, ys, new Uint8Array(i));
+        }
+      });
+      switch (t.type) {
+        case y.Subscribe:
+          yield f(this, P, Xo).call(this, e, t);
+          break;
+        case y.Announce:
+          yield f(this, P, qo).call(this, e, t);
+          break;
+        case y.SubscribeOk:
+          yield f(this, P, Yo).call(this, e, t);
+          break;
+        case y.SubscribeUpdate:
+          yield f(this, P, Ko).call(this, e, t);
+          break;
+        case y.SubscribeError:
+          yield f(this, P, Zo).call(this, e, t);
+          break;
+        case y.SubscribeDone:
+          yield f(this, P, Jo).call(this, e, t);
+          break;
+        case y.Unsubscribe:
+          yield f(this, P, Qo).call(this, e, t);
+          break;
+        case y.ClientSetup:
+          yield f(this, P, zo).call(this, e, t);
+          break;
+        case y.ServerSetup:
+          yield f(this, P, Ho).call(this, e, t);
+          break;
+        case y.AnnounceOk:
+          yield f(this, P, _o).call(this, e, t);
+          break;
+        default:
+          throw new Error(`Unknown message type: ${t.type}`);
+      }
+      yield e.flush(), yield s(this, jt).writeVarInt(s(this, ys).byteLength), yield s(this, jt).write(s(this, ys)), yield s(this, jt).flush();
+    });
+  }
+  close() {
+    return h(this, null, function* () {
+      return s(this, jt).close();
+    });
+  }
+}
+jt = new WeakMap(), ys = new WeakMap(), P = new WeakSet(), zo = function(t, e) {
+  return h(this, null, function* () {
+    yield iu(t, e);
+  });
+}, Ho = function(t, e) {
+  return h(this, null, function* () {
+    yield nu(t, e);
+  });
+}, Xo = function(t, e) {
+  return h(this, null, function* () {
+    yield du(t, e);
+  });
+}, Yo = function(t, e) {
+  return h(this, null, function* () {
+    yield mu(t, e);
+  });
+}, Zo = function(t, e) {
+  return h(this, null, function* () {
+    yield pu(t, e);
+  });
+}, Ko = function(t, e) {
+  return h(this, null, function* () {
+    yield gu(t, e);
+  });
+}, Jo = function(t, e) {
+  return h(this, null, function* () {
+    yield wu(t, e);
+  });
+}, Qo = function(t, e) {
+  return h(this, null, function* () {
+    yield Iu(t, e);
+  });
+}, qo = function(t, e) {
+  return h(this, null, function* () {
+    yield _c(t, e);
+  });
+}, _o = function(t, e) {
+  return h(this, null, function* () {
+    yield eu(t, e);
+  });
+};
+var gs, Zi, Ki;
+class vu {
+  constructor(t, e) {
+    o(this, gs);
+    o(this, Zi);
+    o(this, Ki);
+    u(this, gs, t), u(this, Zi, new Mo(t)), u(this, Ki, e);
+  }
+  write(t) {
+    return h(this, null, function* () {
+      yield s(this, gs).write(s(this, Ki)), yield s(this, Zi).write(t);
+    });
+  }
+  close() {
+    return s(this, gs).close();
+  }
+}
+gs = new WeakMap(), Zi = new WeakMap(), Ki = new WeakMap();
+function Su(r) {
+  return h(this, null, function* () {
+    return {
+      type: y.AnnounceError,
+      namespace: yield Jn(r),
+      errorCode: yield r.readBigVarInt(),
+      reason: yield r.readString()
+    };
+  });
+}
+function Uu(r, t, e) {
+  return h(this, null, function* () {
+    return {
+      type: y.Unknown,
+      messageType: t,
+      payload: yield r.read(e)
+    };
+  });
+}
+var j;
+class Qa {
+  constructor(t) {
+    o(this, j);
+    u(this, j, t);
+  }
+  cancel() {
+    return s(this, j).close();
+  }
+  read() {
+    return h(this, null, function* () {
+      const t = yield s(this, j).readVarInt(), e = yield s(this, j).readVarInt();
+      switch (t) {
+        case y.ServerSetup:
+          return au(s(this, j));
+        case y.ClientSetup:
+          return ru(s(this, j));
+        case y.Subscribe:
+          return hu(s(this, j));
+        case y.SubscribeOk:
+          return bu(s(this, j));
+        case y.SubscribeDone:
+          return lu(s(this, j));
+        case y.SubscribeError:
+          return fu(s(this, j));
+        case y.SubscribeUpdate:
+          return yu(s(this, j));
+        case y.Unsubscribe:
+          return ku(s(this, j));
+        case y.Announce:
+          return qc(s(this, j));
+        case y.AnnounceOk:
+          return tu(s(this, j));
+        case y.AnnounceError:
+          return Su(s(this, j));
+      }
+      return Uu(s(this, j), k(t), e);
+    });
+  }
+}
+j = new WeakMap();
+var Ji, ks, Is, Qi, An, tc, Dn;
+const ss = class ss {
+  constructor(t, e) {
+    o(this, An);
+    o(this, Ji);
+    o(this, ks);
+    o(this, Is, new V());
+    o(this, Qi, new V());
+    u(this, Ji, t), u(this, ks, e), s(this, Is).resolve();
+  }
+  write(t) {
+    return h(this, null, function* () {
+      const e = yield f(this, An, tc).call(this);
+      try {
+        yield s(this, Ji).write(t);
+      } finally {
+        e.resolve();
+      }
+    });
+  }
+  markPostHandshake() {
+    s(this, Qi).resolve();
+  }
+  postHandshake() {
+    return s(this, Qi).promise;
+  }
+  // Not "thread" safe (:
+  read() {
+    return h(this, null, function* () {
+      return s(this, ks).read();
+    });
+  }
+  cancel() {
+    return s(this, ks).cancel();
+  }
+  static wrapWebsocket(t) {
+    const e = new ReadableStream(new Zc(t, s(ss, Dn))), i = new Qa(new bn(new Uint8Array([]), e)), n = new vu(new Oi(t), new Uint8Array([0]));
+    return new ss(n, i);
+  }
+  static wrapWebTransport(t) {
+    const e = t.writable, i = t.readable;
+    return new ss(
+      new Mo(new Do(e)),
+      new Qa(new bn(new Uint8Array(), i))
+    );
+  }
+};
+Ji = new WeakMap(), ks = new WeakMap(), Is = new WeakMap(), Qi = new WeakMap(), An = new WeakSet(), tc = function() {
+  const t = new V(), e = s(this, Is).promise.then(() => t);
+  return u(this, Is, t), e;
+}, Dn = new WeakMap(), o(ss, Dn, 0);
+let gn = ss;
+function ec(r, t) {
+  return h(this, null, function* () {
+    yield r.write({
+      type: y.ClientSetup,
+      supportedVersions: [{ type: "known", value: Lo.Draft07 }],
+      parameters: /* @__PURE__ */ new Map([[yn.Role, { type: yn.Role, payload: new Uint8Array([t]) }]])
+    });
+    const e = yield r.read();
+    if (r.markPostHandshake(), e.type !== y.ServerSetup)
+      throw new Error("Expected server setup message");
+    if (e.selectedVersion.type !== "known")
+      throw new Error("Expected known version");
+  });
+}
+var vs;
+class Eu {
+  constructor(t) {
+    l(this, "announce");
+    o(this, vs, new V());
+    this.announce = t;
+  }
+  onOk(t) {
+    s(this, vs).resolve(t);
+  }
+  onError(t) {
+    const e = new Error(t.reason);
+    return s(this, vs).reject(e), e;
+  }
+  ok() {
+    return s(this, vs).promise;
+  }
+}
+vs = new WeakMap();
+function Tu(r) {
+  const t = new Eu(r);
+  return new Au(t);
+}
+class Au {
+  constructor(t) {
+    l(this, "state");
+    this.state = t;
+  }
+}
+var Ss, Yt, Se, On, Ue, ft;
+const Vn = class Vn {
+  constructor(t) {
+    l(this, "subscribe");
+    o(this, Ss, new V());
+    o(this, Yt, new V());
+    o(this, Se, new V());
+    o(this, On, Date.now());
+    o(this, Ue, new V());
+    o(this, ft);
+    switch (this.subscribe = t, t.filterType.type) {
+      case "absolute-start":
+        u(this, ft, { startGroup: t.filterType.start.group });
+        break;
+      case "absolute-range":
+        u(this, ft, { startGroup: t.filterType.start.group, endGroup: t.filterType.end.group });
+        break;
+    }
+  }
+  onUpdate(t) {
+    u(this, ft, { startGroup: t.start.group }), t.end.group > k(0) && (s(this, ft).endGroup = t.end.group - k(1));
+  }
+  onError(t) {
+    const e = new Error(t.reason);
+    return s(this, Ss).reject(e), s(this, Yt).reject(e), e;
+  }
+  onDone(t) {
+    t.finalInfo && (s(this, ft) || u(this, ft, { startGroup: k(0) }), s(this, ft).endGroup = t.finalInfo.group), s(this, Yt).resolve(t);
+  }
+  onUnsubscribe(t) {
+    s(this, Se).resolve(t);
+  }
+  onOk(t) {
+    const e = Math.max(0, Date.now() - s(this, On)), i = Number(t.expires);
+    if (i > 0) {
+      const n = Math.min(i / 10, Vn.maxGraceTime);
+      Promise.race([Yn(i - n - e), this.done().catch(D)]).then(() => s(this, Ue).resolve(this.expiryState())).catch(D);
+    }
+    s(this, Ss).resolve(t);
+  }
+  done() {
+    return s(this, Yt).promise;
+  }
+  ok() {
+    return s(this, Ss).promise;
+  }
+  range() {
+    return s(this, ft);
+  }
+  close() {
+    s(this, Ue).promise.catch(D), s(this, Ue).reject(new Error("Subscription closed"));
+  }
+  // Returns whether the subscription is still active - i.e. hasn't received a done or unsubscribe
+  expiryState() {
+    return s(this, Yt).resolved && s(this, Yt).resolved.errorCode !== pa.Expired ? "done" : s(this, Se).pending ? "active" : "unsubscribed";
+  }
+  unsubscribed() {
+    return s(this, Se).promise;
+  }
+  isUnsubscribed() {
+    return s(this, Se).resolved;
+  }
+  /**
+     * Returns a promise that resolves when the subscription is about to expire (15 seconds before expiry).
+  
+     */
+  expiryNotification() {
+    return s(this, Ue).promise;
+  }
+};
+Ss = new WeakMap(), Yt = new WeakMap(), Se = new WeakMap(), On = new WeakMap(), Ue = new WeakMap(), ft = new WeakMap(), l(Vn, "maxGraceTime", 15e3);
+let kn = Vn;
+var $, qi;
+class Du {
+  constructor(t) {
+    o(this, $);
+    o(this, qi, !1);
+    u(this, $, t);
+  }
+  write(t) {
+    return h(this, null, function* () {
+      s(this, qi) || (yield s(this, $).writeVarInt(pn.StreamHeaderGroup), yield s(this, $).writeBigVarInt(t.subscribeId), yield s(this, $).writeBigVarInt(t.trackAlias), yield s(this, $).writeBigVarInt(t.groupId), yield s(this, $).writeBigVarInt(t.subGroupId), yield s(this, $).writeUnsigned8(t.subscriberPriority), u(this, qi, !0)), yield s(this, $).writeBigVarInt(t.objectId), yield s(this, $).writeVarInt(t.payload.length), t.payload.length > 0 ? yield s(this, $).write(t.payload) : yield s(this, $).writeVarInt(t.objectStatus), yield s(this, $).flush();
+    });
+  }
+  close() {
+    return h(this, null, function* () {
+      yield s(this, $).close();
+    });
+  }
+}
+$ = new WeakMap(), qi = new WeakMap();
+var _i, ot, tr, er, Us, Cn, sc;
+class Ou {
+  constructor(t, e, i, n) {
+    o(this, Cn);
+    o(this, _i);
+    o(this, ot);
+    o(this, tr);
+    o(this, er);
+    o(this, Us);
+    u(this, _i, e), u(this, ot, t), u(this, tr, i), u(this, er, n);
+  }
+  finalInfo() {
+    return s(this, Us);
+  }
+  run() {
+    return h(this, null, function* () {
+      yield Promise.race([
+        f(this, Cn, sc).call(this).catch(D),
+        s(this, ot).unsubscribed(),
+        s(this, ot).done(),
+        s(this, ot).expiryNotification().catch(D)
+      ]);
+    });
+  }
+  done(t, e) {
+    return h(this, null, function* () {
+      if (s(this, ot).isUnsubscribed())
+        return;
+      const i = {
+        type: y.SubscribeDone,
+        id: s(this, ot).subscribe.id,
+        errorCode: t,
+        reason: e,
+        finalInfo: s(this, Us)
+      };
+      s(this, ot).onDone(i), yield s(this, er).push(i);
+    });
+  }
+  [Ct()]() {
+    return this.done(pa.TrackEnded, "Track ended");
+  }
+  [Symbol.asyncDispose]() {
+    return this.done(pa.TrackEnded, "Track ended");
+  }
+}
+_i = new WeakMap(), ot = new WeakMap(), tr = new WeakMap(), er = new WeakMap(), Us = new WeakMap(), Cn = new WeakSet(), sc = function() {
+  return h(this, null, function* () {
+    try {
+      for (var c = C(s(this, _i)), d, w, p; d = !(w = yield c.next()).done; d = !1) {
+        const m = w.value;
+        var t = [];
+        try {
+          const b = s(this, ot).range();
+          if (b && (b.startGroup > m.id || b.endGroup && b.endGroup < m.id))
+            break;
+          const I = yield s(this, tr).openSendStream();
+          const g = new Du(I);
+          const E = rt(t, new Vu(g, m.consume(), s(this, ot)), !0);
+          yield E.run();
+          u(this, Us, E.finalGroup());
+        } catch (e) {
+          var i = e, n = !0;
+        } finally {
+          var a = nt(t, i, n);
+          a && (yield a);
+        }
+      }
+    } catch (w) {
+      p = [w];
+    } finally {
+      try {
+        d && (w = c.return) && (yield w.call(c));
+      } finally {
+        if (p)
+          throw p[0];
+      }
+    }
+  });
+};
+var Zt, sr, Es, ir;
+class Vu {
+  constructor(t, e, i) {
+    o(this, Zt);
+    o(this, sr);
+    o(this, Es);
+    o(this, ir);
+    u(this, Zt, t), u(this, sr, e), u(this, Es, i);
+  }
+  finalGroup() {
+    return s(this, ir);
+  }
+  run() {
+    return h(this, null, function* () {
+      try {
+        for (var t = C(s(this, sr)), e, i, n; e = !(i = yield t.next()).done; e = !1) {
+          const a = i.value;
+          yield s(this, Zt).write({
+            subscribeId: s(this, Es).subscribe.id,
+            trackAlias: s(this, Es).subscribe.trackAlias,
+            subGroupId: k(0),
+            subscriberPriority: 0,
+            groupId: a.groupId,
+            objectId: a.objectId,
+            objectStatus: a.objectStatus,
+            payload: a.payload
+          }), u(this, ir, { group: a.groupId, object: a.objectId });
+        }
+      } catch (i) {
+        n = [i];
+      } finally {
+        try {
+          e && (i = t.return) && (yield i.call(t));
+        } finally {
+          if (n)
+            throw n[0];
+        }
+      }
+      yield s(this, Zt).close();
+    });
+  }
+  [Ct()]() {
+    return s(this, Zt).close();
+  }
+  [Symbol.asyncDispose]() {
+    return s(this, Zt).close();
+  }
+}
+Zt = new WeakMap(), sr = new WeakMap(), Es = new WeakMap(), ir = new WeakMap();
+var rr, Ee, Kt, Qe;
+class Cu {
+  constructor(t, e, i) {
+    o(this, Kt);
+    l(this, "state");
+    o(this, rr);
+    o(this, Ee);
+    this.state = t, u(this, rr, e), u(this, Ee, i);
+  }
+  /**
+   * Accept the subscription and provide a track cache for the subscription
+   * @param cache - The cache to use for the subscription
+   * @returns A writer for the subscription - `run()` must be called to start sending data
+   */
+  ok(t) {
+    return h(this, null, function* () {
+      var w, p, m;
+      const e = (w = this.state.range()) == null ? void 0 : w.startGroup, i = t.latest(), n = i == null ? void 0 : i.id, a = (m = (p = i == null ? void 0 : i.latest()) == null ? void 0 : p.objectId) != null ? m : k(0), c = t.consume(e != null ? e : n), d = {
+        type: y.SubscribeOk,
+        id: this.state.subscribe.id,
+        expires: k(0),
+        groupOrder: "ascending",
+        params: /* @__PURE__ */ new Map(),
+        largestInfo: n ? { group: n, object: a } : void 0
+      };
+      return yield s(this, Ee).push(d), new Ou(this.state, c, s(this, rr), s(this, Ee));
+    });
+  }
+  invalidRange() {
+    return f(this, Kt, Qe).call(this, k(1), "Invalid range");
+  }
+  retryTrackAlias() {
+    return f(this, Kt, Qe).call(this, k(2), "Retry track alias");
+  }
+  trackDoesNotExist() {
+    return f(this, Kt, Qe).call(this, k(3), "Track does not exist");
+  }
+  unauthorized() {
+    return f(this, Kt, Qe).call(this, k(4), "Unauthorized");
+  }
+  timeout() {
+    return f(this, Kt, Qe).call(this, k(5), "Timeout");
+  }
+  [Ct()]() {
+    return this.trackDoesNotExist();
+  }
+  [Symbol.asyncDispose]() {
+    return this.trackDoesNotExist();
+  }
+}
+rr = new WeakMap(), Ee = new WeakMap(), Kt = new WeakSet(), Qe = function(t, e) {
+  const i = {
+    type: y.SubscribeError,
+    id: this.state.subscribe.id,
+    errorCode: t,
+    reason: e,
+    trackAlias: this.state.subscribe.trackAlias
+  };
+  return s(this, Ee).push(i);
+};
+var io, Ts, nr, As, Te, Jt, Qt, qt, na;
+io = [q({ context: "Session", enter: "info", error: "error" })];
+class ba {
+  constructor(t, e, i) {
+    de(na, 5, this);
+    o(this, Ts);
+    o(this, nr);
+    o(this, As);
+    o(this, Te, gt.get().createContext("Publisher"));
+    o(this, Jt, new Y(/* @__PURE__ */ new Map()));
+    o(this, Qt, new Y(/* @__PURE__ */ new Map()));
+    o(this, qt, new Zn(10));
+    u(this, Ts, t), u(this, nr, e), u(this, As, i);
+  }
+  announce(t) {
+    return h(this, null, function* () {
+      if (s(this, Jt).current().has(t.join("/")))
+        throw new Error("Duplicate announcement");
+      const e = /* @__PURE__ */ new Map(), i = s(this, Ts).authToken();
+      i && e.set(mn, { type: mn, payload: new TextEncoder().encode(i) });
+      const n = {
+        type: y.Announce,
+        namespace: t,
+        params: e
+      }, a = Tu(n);
+      if (s(this, Jt).update((d) => d.set(n.namespace.join("/"), a)), yield s(this, As).push(n), !(yield Promise.race([a.state.ok(), s(this, Ts).closed()])))
+        throw new Error("Session closed");
+    });
+  }
+  close() {
+    s(this, Qt).current().forEach((t) => t.close()), s(this, Qt).close(), s(this, Jt).close(), s(this, qt).close();
+  }
+  incomingSubscriptions() {
+    return s(this, qt);
+  }
+  onMessage(t) {
+    return h(this, null, function* () {
+      switch (t.type) {
+        case y.Subscribe:
+          {
+            const e = new kn(t);
+            if (s(this, Qt).update((i) => (i.set(t.id, e), i)), s(this, qt).isFull()) {
+              const i = yield s(this, qt).pop();
+              yield i == null ? void 0 : i.timeout();
+            }
+            yield s(this, qt).push(
+              new Cu(e, s(this, nr), s(this, As))
+            );
+          }
+          break;
+        case y.SubscribeUpdate:
+          {
+            const e = s(this, Qt).current().get(t.id);
+            e || s(this, Te).debug("No subscription found", t), e == null || e.onUpdate(t);
+          }
+          break;
+        case y.Unsubscribe:
+          {
+            const e = s(this, Qt).current().get(t.id);
+            e || s(this, Te).debug("No subscription found", t), e == null || e.onUnsubscribe(t);
+          }
+          break;
+        case y.AnnounceOk:
+          {
+            const e = s(this, Jt).current().get(t.namespace.join("/"));
+            e || s(this, Te).debug("No announcement found", t), e == null || e.state.onOk(t);
+          }
+          break;
+        case y.AnnounceError:
+          {
+            const e = s(this, Jt).current().get(t.namespace.join("/"));
+            e || s(this, Te).debug("No announcement found", t), e == null || e.state.onError(t);
+          }
+          break;
+      }
+    });
+  }
+}
+na = he(null), Ts = new WeakMap(), nr = new WeakMap(), As = new WeakMap(), Te = new WeakMap(), Jt = new WeakMap(), Qt = new WeakMap(), qt = new WeakMap(), H(na, 1, "announce", io, ba), zt(na, ba);
+function Bu(r, t) {
+  const e = new kn(t), [i, n] = Ca(100), a = new xu(e, i), c = new ic(r, e, n);
+  return [a, c];
+}
+var Ae;
+class xu {
+  constructor(t, e) {
+    l(this, "state");
+    o(this, Ae);
+    this.state = t, u(this, Ae, e);
+  }
+  onDone(t) {
+    this.state.onDone(t);
+  }
+  onData(t) {
+    return s(this, Ae).push(t);
+  }
+  onError(t) {
+    const e = this.state.onError(t);
+    s(this, Ae).abort(e);
+  }
+  /**
+   * Closes the subscription producer so that no more objects an be emitted
+   */
+  close() {
+    this.state.close(), s(this, Ae).close();
+  }
+}
+Ae = new WeakMap();
+var ro, Ds, G, Os, Vs, aa, Cs, oi;
+class ic {
+  constructor(t, e, i) {
+    de(aa, 5, this);
+    o(this, Cs);
+    o(this, Ds);
+    o(this, G);
+    o(this, Os);
+    o(this, Vs, new V());
+    u(this, Ds, t), u(this, G, e), u(this, Os, i);
+  }
+  get id() {
+    return s(this, G).subscribe.id;
+  }
+  get trackAlias() {
+    return s(this, G).subscribe.trackAlias;
+  }
+  get name() {
+    return s(this, G).subscribe.name;
+  }
+  range() {
+    return s(this, G).range();
+  }
+  expiryNotification() {
+    return s(this, G).expiryNotification();
+  }
+  /**
+   * Update the subscription range
+   * @param startGroup the start group to subscribe to
+   * @param endGroup the end group to subscribe to
+   */
+  update(t, e) {
+    return h(this, null, function* () {
+      const i = {
+        type: y.SubscribeUpdate,
+        id: s(this, G).subscribe.id,
+        start: { group: t, object: k(0) },
+        end: { group: e + k(1), object: k(0) },
+        params: /* @__PURE__ */ new Map(),
+        subscriberPriority: 0
+      };
+      s(this, G).onUpdate(i), yield s(this, Ds).push(i);
+    });
+  }
+  unsubscribe() {
+    return h(this, null, function* () {
+      const t = { type: y.Unsubscribe, id: s(this, G).subscribe.id };
+      s(this, G).onUnsubscribe(t), yield s(this, Ds).push(t);
+    });
+  }
+  /// Closes the object reader so any pending readData calls are resolved
+  close() {
+    var t, e;
+    return s(this, Vs).resolve(), (e = (t = s(this, Os)).return) == null ? void 0 : e.call(t);
+  }
+  /// Closed is resolved when the subscription has been fully consumed which means no more objects will be available
+  closed() {
+    return s(this, Vs).promise;
+  }
+  /// Await this subscription to become done
+  /// Done does not mean that the subscription is closed,
+  /// it means that the server has confirmed our unsubscribe request
+  done() {
+    return s(this, G).done();
+  }
+  expiryState() {
+    return s(this, G).expiryState();
+  }
+  unsubscribed() {
+    return s(this, G).isUnsubscribed();
+  }
+  return() {
+    return h(this, null, function* () {
+      return s(this, Vs).resolve(), yield this.unsubscribe(), { done: !0, value: void 0 };
+    });
+  }
+  groups() {
+    return xt(this, null, function* () {
+      var t, e;
+      try {
+        for (var g = C(s(this, Os)), E, z, _; E = !(z = yield new O(g.next())).done; E = !1) {
+          var d = z.value;
+          var w = [];
+          try {
+            const A = rt(w, d, !0);
+            try {
+              for (var i = C(A.groups()), n, a, c; n = !(a = yield new O(i.next())).done; n = !1) {
+                const S = a.value;
+                const W = (t = s(this, G).range()) == null ? void 0 : t.startGroup, v = (e = s(this, G).range()) == null ? void 0 : e.endGroup;
+                if (W && S.groupId() < W)
+                  return { done: !0, value: void 0 };
+                if (v && S.groupId() > v)
+                  return { done: !0, value: void 0 };
+                yield S;
+              }
+            } catch (a) {
+              c = [a];
+            } finally {
+              try {
+                n && (a = i.return) && (yield new O(a.call(i)));
+              } finally {
+                if (c)
+                  throw c[0];
+              }
+            }
+          } catch (p) {
+            var m = p, b = !0;
+          } finally {
+            var I = nt(w, m, b);
+            I && (yield new O(I));
+          }
+        }
+      } catch (z) {
+        _ = [z];
+      } finally {
+        try {
+          E && (z = g.return) && (yield new O(z.call(g)));
+        } finally {
+          if (_)
+            throw _[0];
+        }
+      }
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this.groups();
+  }
+  /**
+   * @returns the next object from the subscription
+   */
+  objects() {
+    return xt(this, null, function* () {
+      try {
+        for (var a = C(this.groups()), c, d, w; c = !(d = yield new O(a.next())).done; c = !1) {
+          const p = d.value;
+          try {
+            for (var t = C(p), e, i, n; e = !(i = yield new O(t.next())).done; e = !1) {
+              const m = i.value;
+              yield m;
+            }
+          } catch (i) {
+            n = [i];
+          } finally {
+            try {
+              e && (i = t.return) && (yield new O(i.call(t)));
+            } finally {
+              if (n)
+                throw n[0];
+            }
+          }
+        }
+      } catch (d) {
+        w = [d];
+      } finally {
+        try {
+          c && (d = a.return) && (yield new O(d.call(a)));
+        } finally {
+          if (w)
+            throw w[0];
+        }
+      }
+    });
+  }
+  [(ro = [q({ context: "SubscriptionConsumer", enter: "info" })], Ct())]() {
+    return f(this, Cs, oi).call(this);
+  }
+  [Symbol.asyncDispose]() {
+    return f(this, Cs, oi).call(this);
+  }
+}
+aa = he(null), Ds = new WeakMap(), G = new WeakMap(), Os = new WeakMap(), Vs = new WeakMap(), Cs = new WeakSet(), oi = function() {
+  return h(this, null, function* () {
+    return yield this.close(), this.unsubscribe();
+  });
+}, oi = H(aa, 17, "#dispose", ro, Cs, oi), zt(aa, ic);
+const Pu = 2e3;
+var no, ao, oo, co, Nt, st, De, Oe, Ke, Vt, Xr, qe;
+co = [q({ context: "Session", return: "debug" })], oo = [q({ context: "Session", enter: "info", error: "error" })], ao = [q({ context: "Session", enter: "debug" })], no = [q({ context: "Session", enter: "debug" })];
+class Hr {
+  constructor(t, e) {
+    de(Ke, 5, this);
+    o(this, Vt);
+    // The owner session of the subscriber
+    o(this, Nt);
+    // The next subscribe id
+    l(this, "nextSubscribeId", k(0));
+    // The active subscriptions
+    o(this, st, new Y(/* @__PURE__ */ new Map()));
+    o(this, De);
+    o(this, Oe, gt.get().createContext("Subscriber"));
+    u(this, Nt, t), u(this, De, e), f(this, Vt, Xr).call(this).catch(D);
+  }
+  subscribe(t, e) {
+    return h(this, null, function* () {
+      const i = this.nextSubscribeId++, n = /* @__PURE__ */ new Map(), a = s(this, Nt).authToken();
+      a && n.set(mn, { type: mn, payload: new TextEncoder().encode(a) });
+      const c = {
+        type: y.Subscribe,
+        namespace: t,
+        name: e.name,
+        id: i,
+        trackAlias: i,
+        groupOrder: e.groupOrder,
+        subscriberPriority: e.priority,
+        filterType: e.filterType,
+        params: n
+      }, [d, w] = Bu(s(this, De), c);
+      if (s(this, st).update((m) => m.set(i, d)), yield s(this, De).push(c), !(yield Promise.race([d.state.ok(), s(this, Nt).closed()])))
+        throw new Error("Session closed");
+      return w.closed().then(() => Promise.race([Yn(Pu), this.closed()])).then(() => f(this, Vt, qe).call(this, w.id)).catch(() => f(this, Vt, qe).call(this, w.id)), w;
+    });
+  }
+  closed() {
+    return s(this, Nt).closed();
+  }
+  transportType() {
+    return s(this, Nt).transportType();
+  }
+  url() {
+    return s(this, Nt).url();
+  }
+  onMessage(t) {
+    return h(this, null, function* () {
+      switch (t.type) {
+        case y.Announce:
+          yield s(this, De).push({
+            type: y.AnnounceOk,
+            namespace: t.namespace
+          });
+          break;
+        case y.SubscribeOk:
+          {
+            const e = s(this, st).current().get(t.id);
+            e && e.state.onOk(t);
+          }
+          break;
+        case y.SubscribeError:
+          {
+            const e = s(this, st).current().get(t.id);
+            e || s(this, Oe).debug("No subscription found", t), e == null || e.onError(t), f(this, Vt, qe).call(this, t.id);
+          }
+          break;
+        case y.SubscribeDone:
+          {
+            const e = s(this, st).current().get(t.id);
+            e || s(this, Oe).debug("No subscription found", t), e == null || e.onDone(t);
+          }
+          break;
+      }
+    });
+  }
+  onObjectReader(t) {
+    return h(this, null, function* () {
+      const e = s(this, st).current().get(t.subscribeId());
+      if (!e) {
+        s(this, Oe).warn("No subscription found", t.subscribeId());
+        return;
+      }
+      yield e.onData(t);
+    });
+  }
+  close() {
+    s(this, st).current().forEach((t) => t.close()), s(this, st).close();
+  }
+}
+Ke = he(null), Nt = new WeakMap(), st = new WeakMap(), De = new WeakMap(), Oe = new WeakMap(), Vt = new WeakSet(), Xr = function() {
+  return h(this, null, function* () {
+    try {
+      for (var t = C(s(this, st)), e, i, n; e = !(i = yield t.next()).done; e = !1) {
+        const a = i.value;
+        const c = [...a.values()].map((d) => d.state.subscribe);
+        s(this, Oe).debug("current subscriptions", c);
+      }
+    } catch (i) {
+      n = [i];
+    } finally {
+      try {
+        e && (i = t.return) && (yield i.call(t));
+      } finally {
+        if (n)
+          throw n[0];
+      }
+    }
+  });
+}, qe = function(t) {
+  s(this, st).isClosed() || s(this, st).update((e) => (e.delete(t), e));
+}, Xr = H(Ke, 17, "#observeChanges", co, Vt, Xr), H(Ke, 1, "subscribe", oo, Hr), H(Ke, 1, "close", ao, Hr), qe = H(Ke, 17, "#deleteSubscription", no, Vt, qe), zt(Ke, Hr);
+var uo, ho, lo, wo, pt, ar, Ve, Bs, xs, N, rc, nc, Je, Yr, Zr, Kr, ci;
+class xa {
+  constructor(t, e) {
+    de(Je, 5, this);
+    o(this, N);
+    // The underlying transport implementation
+    o(this, pt);
+    // The background "thread" running the background tasks
+    o(this, ar);
+    // Outgoing messages
+    o(this, Ve);
+    o(this, Bs, gt.get().createContext("Session"));
+    l(this, "subscriber");
+    l(this, "publisher");
+    o(this, xs);
+    const [i, n] = Ca(100);
+    u(this, pt, t), u(this, Ve, n), this.subscriber = new Hr(this, i), this.publisher = new ba(this, t, i), u(this, ar, f(this, N, nc).call(this)), u(this, xs, new Y(e)), this.closed().then(() => this.close()).catch(D);
+  }
+  updateAuthToken(t) {
+    s(this, xs).update(t);
+  }
+  authToken() {
+    return s(this, xs).current();
+  }
+  transportType() {
+    return s(this, pt).transportType();
+  }
+  url() {
+    return s(this, pt).url();
+  }
+  closed() {
+    return s(this, ar);
+  }
+  close() {
+    try {
+      this.subscriber.close(), this.publisher.close(), s(this, Ve).cancel("closing"), s(this, pt).close();
+    } catch (t) {
+      s(this, Bs).warn("Error closing session", t);
+    }
+  }
+  [(wo = [q({ context: "Session", return: "info", error: "error" })], lo = [q({ context: "Session", return: "info", error: "error" })], ho = [q({ context: "Session", return: "info", error: "error" })], uo = [q({ context: "Session", enter: "debug" })], Io())]() {
+    f(this, N, ci).call(this);
+  }
+  [Symbol.dispose]() {
+    f(this, N, ci).call(this);
+  }
+}
+Je = he(null), pt = new WeakMap(), ar = new WeakMap(), Ve = new WeakMap(), Bs = new WeakMap(), xs = new WeakMap(), N = new WeakSet(), rc = function(t) {
+  return h(this, null, function* () {
+    var e, i;
+    switch (s(this, Bs).debug("received message", t), yield (e = this.subscriber) == null ? void 0 : e.onMessage(t), yield (i = this.publisher) == null ? void 0 : i.onMessage(t), t.type) {
+      case y.Goaway:
+        break;
+    }
+  });
+}, nc = function() {
+  return h(this, null, function* () {
+    return (yield Promise.all([f(this, N, Zr).call(this), f(this, N, Kr).call(this), f(this, N, Yr).call(this)])).find((e) => e instanceof Error);
+  });
+}, Yr = function() {
+  return h(this, null, function* () {
+    try {
+      try {
+        for (var t = C(s(this, Ve)), e, i, n; e = !(i = yield t.next()).done; e = !1) {
+          const a = i.value;
+          s(this, Bs).debug("sending message", a), yield s(this, pt).writeMessage(a);
+        }
+      } catch (i) {
+        n = [i];
+      } finally {
+        try {
+          e && (i = t.return) && (yield i.call(t));
+        } finally {
+          if (n)
+            throw n[0];
+        }
+      }
+    } catch (a) {
+      return a;
+    }
+  });
+}, Zr = function() {
+  return h(this, null, function* () {
+    yield s(this, pt).afterHandshake();
+    try {
+      for (; ; ) {
+        const t = yield s(this, pt).readMessage().catch(() => {
+        });
+        if (!t)
+          break;
+        yield f(this, N, rc).call(this, t);
+      }
+    } catch (t) {
+      return t;
+    } finally {
+      s(this, Ve).cancel("closing");
+    }
+  });
+}, Kr = function() {
+  return h(this, null, function* () {
+    var t;
+    try {
+      for (; ; ) {
+        const e = yield s(this, pt).objectStream();
+        if (!e)
+          break;
+        yield (t = this.subscriber) == null ? void 0 : t.onObjectReader(e);
+      }
+    } catch (e) {
+      return e;
+    }
+  });
+}, ci = function() {
+  this.close();
+}, Yr = H(Je, 17, "#runOutgoingMessages", wo, N, Yr), Zr = H(Je, 17, "#runControl", lo, N, Zr), Kr = H(Je, 17, "#runObjects", ho, N, Kr), ci = H(Je, 17, "#dispose", uo, N, ci), zt(Je, xa);
+const Ru = 128;
+var ct, or, Ce, Ps, cr, M, fe, pe;
+class ju {
+  constructor(t, e, i) {
+    o(this, M);
+    o(this, ct);
+    o(this, or);
+    o(this, Ce, !0);
+    o(this, Ps, !1);
+    o(this, cr);
+    u(this, ct, t), u(this, or, e), u(this, cr, i);
+  }
+  writeUnsigned8(t) {
+    return h(this, null, function* () {
+      return f(this, M, fe).call(this), yield f(this, M, pe).call(this), s(this, ct).writeUnsigned8(t);
+    });
+  }
+  writeVarInt(t) {
+    return h(this, null, function* () {
+      return f(this, M, fe).call(this), yield f(this, M, pe).call(this), s(this, ct).writeVarInt(t);
+    });
+  }
+  writeBigVarInt(t) {
+    return h(this, null, function* () {
+      return f(this, M, fe).call(this), yield f(this, M, pe).call(this), s(this, ct).writeBigVarInt(t);
+    });
+  }
+  write(t) {
+    return h(this, null, function* () {
+      return f(this, M, fe).call(this), yield f(this, M, pe).call(this), s(this, ct).write(t);
+    });
+  }
+  writeString(t) {
+    return h(this, null, function* () {
+      return f(this, M, fe).call(this), yield f(this, M, pe).call(this), s(this, ct).writeString(t);
+    });
+  }
+  flush() {
+    return h(this, null, function* () {
+      f(this, M, fe).call(this), u(this, Ce, !0), yield s(this, ct).flush();
+    });
+  }
+  close() {
+    return h(this, null, function* () {
+      s(this, Ps) || (u(this, Ce, !0), yield f(this, M, pe).call(this, !1), yield s(this, ct).flush(), u(this, Ps, !0), s(this, cr).call(this));
+    });
+  }
+}
+ct = new WeakMap(), or = new WeakMap(), Ce = new WeakMap(), Ps = new WeakMap(), cr = new WeakMap(), M = new WeakSet(), fe = function() {
+  if (s(this, Ps))
+    throw new Error("Stream is closed");
+}, pe = function(t = !0) {
+  if (s(this, Ce))
+    return u(this, Ce, !1), s(this, ct).writeUnsigned8(s(this, or) | (t ? Ru : 0));
+};
+var _t, te, Rs, Be, Gt, js, Ns, Bn, ac;
+class Nu {
+  constructor(t, e) {
+    o(this, Bn);
+    o(this, _t);
+    o(this, te);
+    o(this, Rs);
+    o(this, Be);
+    o(this, Gt, /* @__PURE__ */ new Map());
+    o(this, js, gt.get().createContext("WebSocketConnection"));
+    o(this, Ns, new Set(new Array(128).fill(0).map((t, e) => e + 1)));
+    u(this, _t, t), u(this, te, e), u(this, Rs, new ReadableStream(new Kc(t))), s(this, _t).addEventListener("close", () => {
+      s(this, Gt).forEach((i) => i.close());
+    });
+  }
+  openSendStream() {
+    const t = s(this, Ns).values().next().value;
+    if (!t)
+      throw new Error("No stream IDs available");
+    return s(this, Ns).delete(t), Promise.resolve(
+      new ju(new Oi(s(this, _t)), t, () => f(this, Bn, ac).call(this, t))
+    );
+  }
+  transportType() {
+    return "websocket";
+  }
+  url() {
+    return s(this, _t).url;
+  }
+  afterHandshake() {
+    return s(this, te).postHandshake();
+  }
+  objectStream() {
+    return h(this, null, function* () {
+      var t;
+      for (; ; ) {
+        u(this, Be, s(this, Rs).getReader());
+        try {
+          const { value: e, done: i } = yield s(this, Be).read();
+          if (i)
+            return;
+          const [n, a, c] = e;
+          if (s(this, Gt).has(k(a))) {
+            const d = s(this, Gt).get(k(a));
+            if (!d)
+              throw new Error("Stream not found");
+            c.length > 0 && (yield d.push(c)), n || (s(this, js).debug("Closing stream", { streamId: a }), d.close(), s(this, Gt).delete(k(a)));
+          } else {
+            let m;
+            s(this, js).debug("Creating new stream", { streamId: a });
+            const [d, w] = Ca(1e3), p = new ReadableStream({
+              pull(b) {
+                return h(this, null, function* () {
+                  const I = yield w.pop();
+                  I ? b.enqueue(I) : b.close();
+                });
+              }
+            });
+            if (s(this, Gt).set(k(a), d), n || (s(this, js).debug("Closing new stream", { streamId: a }), yield p.cancel(), s(this, Gt).delete(k(a))), c.length > 0)
+              return yield Ao(new bn(c, p), a);
+          }
+        } finally {
+          (t = s(this, Be)) == null || t.releaseLock();
+        }
+      }
+    });
+  }
+  close() {
+    var t;
+    return s(this, te).cancel().catch(D), s(this, Rs).cancel("closing").catch(D), (t = s(this, Be)) == null || t.cancel("closing").catch(D), s(this, _t).close();
+  }
+  closed() {
+    return Promise.resolve();
+  }
+  writeMessage(t) {
+    return h(this, null, function* () {
+      yield s(this, te).write(t);
+    });
+  }
+  readMessage() {
+    return h(this, null, function* () {
+      return s(this, te).read();
+    });
+  }
+}
+_t = new WeakMap(), te = new WeakMap(), Rs = new WeakMap(), Be = new WeakMap(), Gt = new WeakMap(), js = new WeakMap(), Ns = new WeakMap(), Bn = new WeakSet(), /**
+ * Return a stream ID to the pool of available stream IDs
+ * @param streamId - The stream ID to return
+ */
+ac = function(t) {
+  s(this, Ns).add(t);
+};
+var ee, xe, Pe, ur, hr, xn, Pn, oc;
+class Gu {
+  constructor(t, e, i) {
+    o(this, Pn);
+    o(this, ee);
+    o(this, xe);
+    o(this, Pe, new Zn(100));
+    o(this, ur);
+    o(this, hr, 0);
+    o(this, xn, gt.get().createContext("WebTransportConnection"));
+    u(this, ur, i), u(this, ee, t), u(this, xe, e), f(this, Pn, oc).call(this).catch((n) => {
+      s(this, xn).debug("Incoming streams handling ended with error", n), s(this, Pe).close();
+    });
+  }
+  openSendStream() {
+    return h(this, null, function* () {
+      const t = yield s(this, ee).createUnidirectionalStream();
+      return new Do(t);
+    });
+  }
+  transportType() {
+    return "webtransport";
+  }
+  url() {
+    return s(this, ur);
+  }
+  afterHandshake() {
+    return s(this, xe).postHandshake();
+  }
+  closed() {
+    return h(this, null, function* () {
+      yield s(this, ee).closed;
+    });
+  }
+  close() {
+    s(this, ee).close();
+  }
+  writeMessage(t) {
+    return h(this, null, function* () {
+      yield s(this, xe).write(t);
+    });
+  }
+  readMessage() {
+    return h(this, null, function* () {
+      return s(this, xe).read();
+    });
+  }
+  objectStream() {
+    return h(this, null, function* () {
+      return s(this, Pe).pop();
+    });
+  }
+}
+ee = new WeakMap(), xe = new WeakMap(), Pe = new WeakMap(), ur = new WeakMap(), hr = new WeakMap(), xn = new WeakMap(), Pn = new WeakSet(), oc = function() {
+  return h(this, null, function* () {
+    const t = s(this, ee).incomingUnidirectionalStreams.getReader();
+    for (; ; ) {
+      const { value: e, done: i } = yield t.read();
+      if (i) {
+        s(this, Pe).close();
+        return;
+      }
+      const n = new bn(new Uint8Array(), e);
+      yield s(this, Pe).push(Ao(n, s(this, hr))), _n(this, hr)._++;
+    }
+  });
+};
+function ea(r) {
+  return h(this, null, function* () {
+    const t = new WebSocket(r.wsUrl || r.url);
+    t.binaryType = "arraybuffer", yield new Promise((a, c) => {
+      t.addEventListener("error", c, { once: !0 }), t.addEventListener("open", a, { once: !0 });
+    });
+    const e = gn.wrapWebsocket(t);
+    ec(e, r.role).catch(() => {
+      t.close();
+    });
+    const i = new Nu(t, e);
+    return new xa(i, r.authToken);
+  });
+}
+function qa(r) {
+  return h(this, null, function* () {
+    const t = "60b82e8021689e163c1041b4475ef9c86e7565bc45d1a0aa43f5148769f461c7", e = new Uint8Array(t.length / 2);
+    for (let w = 0; w < e.length; w += 1)
+      e[w] = parseInt(t.slice(2 * w, 2 * w + 2), 16);
+    const i = new WebTransport(r.url, {
+      congestionControl: "low-latency"
+      // serverCertificateHashes: [{ algorithm: "sha-256", value: hexBytes }],
+    });
+    yield Promise.race([i.ready, i.closed.then(() => Promise.reject(new Error("WebTransport closed")))]);
+    const n = yield i.createBidirectionalStream(), a = gn.wrapWebTransport(n);
+    ec(a, r.role).catch(() => {
+      i.close();
+    });
+    const c = new Gu(i, a, r.url.toString());
+    return new xa(c, r.authToken);
+  });
+}
+function Lu(r) {
+  return h(this, null, function* () {
+    if (self.WebTransport && (r == null ? void 0 : r.preferredTransport) !== "websocket" && r.url.protocol.startsWith("https")) {
+      if (!r.websocketFallbackTimeoutMs)
+        return qa(r);
+      const t = qa(r).catch(() => ea(r)), e = yield Promise.race([t, Yn(r.websocketFallbackTimeoutMs)]);
+      return e || ea(r);
+    }
+    return ea(r);
+  });
+}
+var Lt;
+class $t {
+  constructor() {
+    o(this, Lt, {
+      name: "",
+      priority: 0,
+      groupOrder: "descending",
+      filterType: { type: "latest-group" }
+    });
+  }
+  name(t) {
+    return s(this, Lt).name = t, this;
+  }
+  priority(t) {
+    return s(this, Lt).priority = t, this;
+  }
+  groupOrder(t) {
+    return s(this, Lt).groupOrder = t, this;
+  }
+  /**
+   * @param startGroup the group to start the subscription at
+   * @returns the builder
+   */
+  startGroup(t) {
+    return s(this, Lt).filterType = {
+      type: "absolute-start",
+      start: { group: t, object: k(0) }
+    }, this;
+  }
+  range(t, e) {
+    return s(this, Lt).filterType = {
+      type: "absolute-range",
+      start: { group: t, object: k(0) },
+      end: { group: e, object: k(0) }
+    }, this;
+  }
+  build() {
+    return s(this, Lt);
+  }
+}
+Lt = new WeakMap();
+var Gs, dr;
+class cc {
+  constructor(t, e) {
+    o(this, Gs);
+    o(this, dr);
+    u(this, Gs, t), u(this, dr, e);
+  }
+  subscribe(t) {
+    return s(this, Gs).subscribe(this.namespace(), t);
+  }
+  closed() {
+    return s(this, Gs).closed();
+  }
+  namespace() {
+    return s(this, dr).namespace;
+  }
+}
+Gs = new WeakMap(), dr = new WeakMap();
+function Fu(r, t) {
+  return ["com.vindral.moq", r];
+}
+function le(r) {
+  const t = r.at(1);
+  if (!t)
+    throw new Error("namespace must contain a channel ID");
+  return t;
+}
+function Wu(r) {
+  return "tracks" in r;
+}
+function $u(r) {
+  const t = new TextDecoder().decode(r);
+  return JSON.parse(t);
+}
+var it, At, Re, ut, lr, Rn, wr, ma;
+const Ra = class Ra {
+  constructor(t, e) {
+    o(this, wr);
+    o(this, it);
+    // The largest group id seen so far - used to switch seamlessly between tracks
+    o(this, At);
+    // We keep track of the most recent groups to ensure we haven't missed any due to re-ordering before we close subscriptions
+    o(this, Re, new Va(100));
+    // This contains the unconsumed groups if this track has an absolute range
+    o(this, ut);
+    o(this, lr);
+    o(this, Rn, (t) => h(this, null, function* () {
+      if (!t)
+        return s(this, it).close();
+      if (s(this, ut))
+        return;
+      const e = s(this, Re).items().reduce((i, n) => i < n ? i : n, t);
+      u(this, ut, f(this, wr, ma).call(this, e, t)), s(this, ut).size === 0 && (yield s(this, it).close());
+    }));
+    u(this, it, t), u(this, At, e), t.done().then((i) => h(this, null, function* () {
+      var n;
+      return s(this, Rn).call(this, (n = i.finalInfo) == null ? void 0 : n.group);
+    })).catch(D), u(this, lr, t.groups());
+  }
+  static subscribe(t, e) {
+    return h(this, null, function* () {
+      const i = yield t.subscribe(e);
+      return new Ra(i, void 0);
+    });
+  }
+  subscribeId() {
+    return s(this, it).id;
+  }
+  name() {
+    return s(this, it).name;
+  }
+  largestGroupId() {
+    return s(this, At);
+  }
+  // The subscription needs renewal if it is still active and aren't finishing up the unconsumed group IDs.
+  // If we are just finishing up the unconsumed group IDs we assume we'll finish up before the expiry.
+  needsRenewal() {
+    return s(this, it).expiryState() === "active" && s(this, ut) === void 0;
+  }
+  /** Set the endGroup as the end of group.
+   *  This lets the subscription end when the endGroup is reached.
+   */
+  endOfTrack(t) {
+    const e = s(this, Re).items().reduce((i, n) => i < n ? i : n, t);
+    return this.update(e, t);
+  }
+  update(t, e) {
+    return h(this, null, function* () {
+      return u(this, ut, f(this, wr, ma).call(this, t, e)), s(this, ut).size === 0 && (yield s(this, it).close()), s(this, it).update(t, e);
+    });
+  }
+  unsubscribe() {
+    return s(this, it).unsubscribe();
+  }
+  next() {
+    return h(this, null, function* () {
+      var i;
+      if (s(this, ut) && s(this, ut).size === 0)
+        return { done: !0, value: void 0 };
+      const t = yield s(this, lr).next();
+      if (t.done)
+        return t;
+      const e = t.value.groupId();
+      return (i = s(this, ut)) == null || i.delete(e), s(this, Re).push(e), s(this, At) || u(this, At, e), u(this, At, s(this, At) < e ? e : s(this, At)), t;
+    });
+  }
+  return() {
+    return s(this, it).return();
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+};
+it = new WeakMap(), At = new WeakMap(), Re = new WeakMap(), ut = new WeakMap(), lr = new WeakMap(), Rn = new WeakMap(), wr = new WeakSet(), ma = function(t, e) {
+  const i = /* @__PURE__ */ new Set();
+  for (let n = t; n <= e; n++)
+    i == null || i.add(n);
+  return s(this, Re).items().forEach((n) => {
+    i == null || i.delete(n);
+  }), i;
+};
+let In = Ra;
+var Dt, je, Ft, se, fr, ya, pr;
+const ja = class ja {
+  constructor(t) {
+    o(this, fr);
+    // The current active subscription
+    o(this, Dt);
+    // The current group iterator - gets replaced by the next in #groups when it runs out
+    o(this, je);
+    // The next group iterators to switch to when the current one runs out
+    o(this, Ft, new Zn(10));
+    o(this, se);
+    o(this, pr, (t, e) => h(this, null, function* () {
+      var b = [];
+      try {
+        const i = rt(b, yield s(this, Dt).lock());
+        const n = { subscribeId: i.value.subscribeId() };
+        if (!i.value.needsRenewal()) {
+          s(this, se).debug("Subscription does not need renewal", n);
+          return;
+        }
+        const a = i.value.largestGroupId();
+        const c = a !== void 0;
+        const d = new $t().name(e.name).priority(e.priority).groupOrder(e.groupOrder);
+        n.largestGroupId = a;
+        s(this, se).debug("Renewing subscription", n);
+        switch (e.filterType.type) {
+          case "absolute-range":
+            s(this, se).debug("Absolute range is not renewed", n);
+            return;
+          case "absolute-start":
+          case "latest-group":
+          case "latest-object":
+            c && d.startGroup(a + k(1));
+            break;
+        }
+        const w = d.build();
+        n.newTrack = w;
+        const [p] = yield Promise.all([
+          t.subscribe(w),
+          c ? i.value.update(a, a) : i.value.unsubscribe()
+        ]);
+        p.done().then(() => f(this, fr, ya).call(this, p)).catch(D);
+        p.expiryNotification().then(() => s(this, pr).call(this, t, w)).catch(D);
+        const m = new In(p, a);
+        i.value = m;
+        yield s(this, Ft).push(m);
+        s(this, se).info("Subscription renewed", n);
+      } catch (I) {
+        var g = I, E = !0;
+      } finally {
+        nt(b, g, E);
+      }
+    }));
+    u(this, Dt, new Nc(t)), u(this, je, t), u(this, se, gt.get().createContext(`Renewable '${t.name()}'`));
+  }
+  static subscribe(t, e, i) {
+    return h(this, null, function* () {
+      const n = yield t.subscribe(e), a = new ja(new In(n, i));
+      return n.done().then(() => {
+        var c;
+        return f(c = a, fr, ya).call(c, n);
+      }).catch(D), n.expiryNotification().then(() => {
+        var c;
+        return s(c = a, pr).call(c, t, e);
+      }).catch(D), a;
+    });
+  }
+  largestGroupId() {
+    return s(this, Dt).unsafeValue().largestGroupId();
+  }
+  update(t, e) {
+    return h(this, null, function* () {
+      var n = [];
+      try {
+        const i = rt(n, yield s(this, Dt).lock());
+        s(this, Ft).close();
+        return i.value.update(t, e);
+      } catch (a) {
+        var c = a, d = !0;
+      } finally {
+        nt(n, c, d);
+      }
+    });
+  }
+  endOfTrack(t) {
+    return h(this, null, function* () {
+      var i = [];
+      try {
+        const e = rt(i, yield s(this, Dt).lock());
+        s(this, Ft).close();
+        return e.value.endOfTrack(t);
+      } catch (n) {
+        var a = n, c = !0;
+      } finally {
+        nt(i, a, c);
+      }
+    });
+  }
+  unsubscribe() {
+    return h(this, null, function* () {
+      var e = [];
+      try {
+        const t = rt(e, yield s(this, Dt).lock());
+        s(this, Ft).close();
+        return t.value.unsubscribe();
+      } catch (i) {
+        var n = i, a = !0;
+      } finally {
+        nt(e, n, a);
+      }
+    });
+  }
+  return() {
+    return h(this, null, function* () {
+      var e = [];
+      try {
+        const t = rt(e, yield s(this, Dt).lock());
+        s(this, Ft).close();
+        return t.value.return();
+      } catch (i) {
+        var n = i, a = !0;
+      } finally {
+        nt(e, n, a);
+      }
+    });
+  }
+  next() {
+    return h(this, null, function* () {
+      var e, i;
+      const t = yield s(this, je).next();
+      if (t.done) {
+        yield (i = (e = s(this, je)).return) == null ? void 0 : i.call(e);
+        const n = yield s(this, Ft).pop();
+        if (n)
+          return u(this, je, n), this.next();
+      }
+      return t;
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  objects() {
+    return xt(this, null, function* () {
+      try {
+        for (var d = C(this), w, p, m; w = !(p = yield new O(d.next())).done; w = !1) {
+          var t = p.value;
+          var e = [];
+          try {
+            const b = rt(e, t, !0);
+            yield* ta(b);
+          } catch (i) {
+            var n = i, a = !0;
+          } finally {
+            var c = nt(e, n, a);
+            c && (yield new O(c));
+          }
+        }
+      } catch (p) {
+        m = [p];
+      } finally {
+        try {
+          w && (p = d.return) && (yield new O(p.call(d)));
+        } finally {
+          if (m)
+            throw m[0];
+        }
+      }
+    });
+  }
+};
+Dt = new WeakMap(), je = new WeakMap(), Ft = new WeakMap(), se = new WeakMap(), fr = new WeakSet(), ya = function(t) {
+  return h(this, null, function* () {
+    var e;
+    if (!(t.unsubscribed() || (e = t.range()) != null && e.endGroup))
+      return this.return();
+  });
+}, pr = new WeakMap();
+let ce = ja;
+const Mu = "catalog";
+function _a(r) {
+  const t = $u(r.payload);
+  if (!Wu(t))
+    throw new Error("unexpected catalog type");
+  return t;
+}
+var Ne, br, mr, yr, jn, uc;
+const Nn = class Nn {
+  constructor(t, e, i) {
+    o(this, jn);
+    o(this, Ne);
+    o(this, br);
+    o(this, mr);
+    o(this, yr);
+    u(this, br, t), u(this, Ne, e), u(this, mr, i), u(this, yr, f(this, jn, uc).call(this));
+  }
+  catalog() {
+    return s(this, Ne);
+  }
+  closed() {
+    return s(this, yr);
+  }
+  close() {
+    return h(this, null, function* () {
+      return s(this, Ne).close(), (yield s(this, br).promise).unsubscribe();
+    });
+  }
+  static start(t, e) {
+    return h(this, null, function* () {
+      const i = V.fromPromise(
+        ce.subscribe(
+          t,
+          new $t().name(e.catalogName || Mu).groupOrder("ascending").build()
+        )
+      ), n = V.fromPromise(i.promise.then((w) => w.objects()));
+      if (e.catalog)
+        return new Nn(i, new Y(e.catalog), n);
+      const c = yield (yield n.promise).next();
+      if (!c.value)
+        throw new Error("No catalog found");
+      const d = _a(c.value);
+      return new Nn(i, new Y(d), n);
+    });
+  }
+};
+Ne = new WeakMap(), br = new WeakMap(), mr = new WeakMap(), yr = new WeakMap(), jn = new WeakSet(), uc = function() {
+  return h(this, null, function* () {
+    const t = yield s(this, mr).promise;
+    try {
+      for (var e = C(t), i, n, a; i = !(n = yield e.next()).done; i = !1) {
+        const c = n.value;
+        if (c.objectStatus !== X.Normal)
+          continue;
+        const d = _a(c);
+        s(this, Ne).update(d);
+      }
+    } catch (n) {
+      a = [n];
+    } finally {
+      try {
+        i && (n = e.return) && (yield n.call(e));
+      } finally {
+        if (a)
+          throw a[0];
+      }
+    }
+  });
+};
+let ga = Nn;
+var gr, Ls, kr, Fs, Ir, ka;
+class zu {
+  constructor(t, e, i, n) {
+    o(this, Ir);
+    o(this, gr);
+    o(this, Ls);
+    o(this, kr);
+    l(this, "track");
+    o(this, Fs, gt.get().createContext("CmafGroup"));
+    this.track = n, u(this, gr, i), u(this, Ls, t), u(this, kr, e);
+  }
+  [Symbol.asyncIterator]() {
+    return xt(this, null, function* () {
+      const t = { name: this.track.trackObject.name, namespace: this.track.namespace };
+      s(this, Fs).debug("start", Mt({}, t));
+      try {
+        for (var e = C(s(this, Ls)), i, n, a; i = !(n = yield new O(e.next())).done; i = !1) {
+          const c = n.value;
+          if (c.objectStatus === X.EndOfTrackAndGroup && (yield new O(this.track.endOfTrack(c.groupId))), c.objectStatus !== X.Normal)
+            continue;
+          const d = s(this, kr).createFragment(c.payload), w = d.timescale(), p = d.baseMediaDecodeTime() / w * 1e3, m = d.duration() / w * 1e3, b = p + m, I = s(this, gr) / 1e3 * w;
+          d.updateBaseMediaDecodeTime(d.baseMediaDecodeTime() - I);
+          const g = this.track.timestampRange();
+          if (g && p >= g[1])
+            break;
+          s(this, Fs).debug("fragment", Wr(Mt({}, t), {
+            startTime: p,
+            endTime: b,
+            subscribeId: c.subscribeId,
+            groupId: c.groupId,
+            objectId: c.objectId,
+            streamId: c.streamId
+          })), yield [c.groupId, d];
+        }
+      } catch (n) {
+        a = [n];
+      } finally {
+        try {
+          i && (n = e.return) && (yield new O(n.call(e)));
+        } finally {
+          if (a)
+            throw a[0];
+        }
+      }
+      s(this, Fs).debug("end", Mt({}, t));
+    });
+  }
+  [Ct()]() {
+    return f(this, Ir, ka).call(this);
+  }
+  [Symbol.asyncDispose]() {
+    return f(this, Ir, ka).call(this);
+  }
+}
+gr = new WeakMap(), Ls = new WeakMap(), kr = new WeakMap(), Fs = new WeakMap(), Ir = new WeakSet(), ka = function() {
+  return h(this, null, function* () {
+    var t, e;
+    return yield (e = (t = s(this, Ls)).return) == null ? void 0 : e.call(t), Promise.resolve();
+  });
+};
+var vr, Ot, Sr, Ur, Gn, hc;
+const is = class is {
+  constructor(t, e, i, n, a) {
+    o(this, vr);
+    o(this, Ot);
+    // A static offset that will be applied to all fragments
+    o(this, Sr);
+    // Stop consuming the track after we have passed thig timestamp
+    o(this, Ur);
+    l(this, "trackObject");
+    l(this, "namespace");
+    this.trackObject = t, this.namespace = e, u(this, Ot, i), u(this, vr, n), u(this, Sr, a);
+  }
+  static subscribe(t, e, i, n) {
+    return h(this, null, function* () {
+      var m;
+      if (e.format !== "cmaf")
+        throw new Error("format must be cmaf");
+      const a = new $t().name(e.name);
+      n && a.startGroup(n);
+      const c = a.build();
+      if (e.initTrack) {
+        const b = new $t().name(e.initTrack).build(), [I, g] = yield Promise.all([
+          f(m = is, Gn, hc).call(m, t, b),
+          ce.subscribe(t, c, n ? n - k(1) : void 0)
+        ]), E = new Ja(I);
+        return new is(e, t.namespace(), g, E, i);
+      }
+      go(e.initData, "no init data found on track");
+      const d = ko(e.initData), w = new Ja(new Uint8Array(d)), p = yield ce.subscribe(t, c, n ? n - k(1) : void 0);
+      return new is(e, t.namespace(), p, w, i);
+    });
+  }
+  largestGroupId() {
+    return s(this, Ot).largestGroupId();
+  }
+  stopAfterTimestampReached(t) {
+    u(this, Ur, [0, t]);
+  }
+  timestampRange() {
+    return s(this, Ur);
+  }
+  endOfTrack(t) {
+    return s(this, Ot).endOfTrack(t);
+  }
+  update(t, e) {
+    return s(this, Ot).update(t, e);
+  }
+  unsubscribe() {
+    return h(this, null, function* () {
+      return s(this, Ot).unsubscribe();
+    });
+  }
+  next() {
+    return h(this, null, function* () {
+      const t = yield s(this, Ot).next();
+      return t.done ? t : {
+        done: !1,
+        value: new zu(t.value, s(this, vr), s(this, Sr), this)
+      };
+    });
+  }
+  return() {
+    return h(this, null, function* () {
+      return yield s(this, Ot).return(), { done: !0, value: void 0 };
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  [Ct()]() {
+    return this.unsubscribe();
+  }
+  [Symbol.asyncDispose]() {
+    return h(this, null, function* () {
+      return this.unsubscribe();
+    });
+  }
+};
+vr = new WeakMap(), Ot = new WeakMap(), Sr = new WeakMap(), Ur = new WeakMap(), Gn = new WeakSet(), hc = function(t, e) {
+  return h(this, null, function* () {
+    var a = [];
+    try {
+      const i = rt(a, yield t.subscribe(e), !0);
+      const n = yield i.objects().next();
+      if (n.done)
+        throw new Error("No init object");
+      yield i.close();
+      return n.value.payload;
+    } catch (c) {
+      var d = c, w = !0;
+    } finally {
+      var p = nt(a, d, w);
+      p && (yield p);
+    }
+  });
+}, o(is, Gn);
+let Ia = is;
+const to = 1e4, Hu = 3e4;
+var Ln, ie, Ge, Er, Tr, Ar, Ze, Sa, dc;
+const Na = class Na {
+  constructor(t, e, i) {
+    o(this, Ze);
+    o(this, Ln, gt.get().createContext("Timeline"));
+    o(this, ie, new Y([]));
+    o(this, Ge);
+    o(this, Er);
+    o(this, Tr);
+    o(this, Ar);
+    u(this, Er, t), u(this, Tr, i), u(this, Ge, e), u(this, Ar, f(this, Ze, Sa).call(this, s(this, Ge))), this.closed().finally(() => s(this, ie).close()).catch(D);
+  }
+  closed() {
+    return s(this, Ar);
+  }
+  close() {
+    return h(this, null, function* () {
+      return (yield s(this, Ge).promise).unsubscribe();
+    });
+  }
+  timeline() {
+    const [t, e] = s(this, ie).value();
+    return t;
+  }
+  /**
+   * Returns the offset between the wallclock time and media timestamps.
+   * This is useful for time aligning two streams based on the common wallclock time
+   */
+  timestampWallclockOffset() {
+    return Dc(this.timeline().map((t) => t.mediaPts - t.wallclock));
+  }
+  static start(t, e) {
+    const i = V.fromPromise(
+      ce.subscribe(t, new $t().name(e).groupOrder("ascending").build())
+    );
+    return new Na(t, i, e);
+  }
+  waitForWallclockTime(t) {
+    return h(this, null, function* () {
+      return yield s(this, ie).waitFor((e) => !!e.find((i) => i.wallclock >= t)), this.timeline();
+    });
+  }
+  waitForTimelineToHaveMinDuration() {
+    return h(this, null, function* () {
+      return yield s(this, ie).waitFor((t) => {
+        const e = t[0], i = t[t.length - 1];
+        return !e || !i ? !1 : i.wallclock - e.wallclock > to;
+      }), this.timeline();
+    });
+  }
+};
+Ln = new WeakMap(), ie = new WeakMap(), Ge = new WeakMap(), Er = new WeakMap(), Tr = new WeakMap(), Ar = new WeakMap(), Ze = new WeakSet(), Sa = function(t) {
+  return h(this, null, function* () {
+    const e = yield t.promise;
+    try {
+      for (var g = C(e), E, z, _; E = !(z = yield g.next()).done; E = !1) {
+        var d = z.value;
+        var w = [];
+        try {
+          const A = rt(w, d, !0);
+          try {
+            for (var i = C(A), n, a, c; n = !(a = yield i.next()).done; n = !1) {
+              const S = a.value;
+              if (S.objectStatus !== X.Normal)
+                continue;
+              const W = Xu(S.payload);
+              s(this, ie).update((v) => {
+                var R, ei;
+                for (v.push(...W), v.sort((Nr, Gr) => Nr.wallclock - Gr.wallclock); v[0] && ((ei = (R = v[v.length - 1]) == null ? void 0 : R.wallclock) != null ? ei : 0) - v[0].wallclock > Hu; )
+                  v.shift();
+                return v;
+              }), e === s(this, Ge).resolved && S.groupId > k(0) && S.objectId == k(0) && f(this, Ze, dc).call(this, S.groupId).catch((v) => {
+                s(this, Ln).warn("backfill failed", v);
+              });
+            }
+          } catch (a) {
+            c = [a];
+          } finally {
+            try {
+              n && (a = i.return) && (yield a.call(i));
+            } finally {
+              if (c)
+                throw c[0];
+            }
+          }
+        } catch (p) {
+          var m = p, b = !0;
+        } finally {
+          var I = nt(w, m, b);
+          I && (yield I);
+        }
+      }
+    } catch (z) {
+      _ = [z];
+    } finally {
+      try {
+        E && (z = g.return) && (yield z.call(g));
+      } finally {
+        if (_)
+          throw _[0];
+      }
+    }
+  });
+}, dc = function(t) {
+  return h(this, null, function* () {
+    const e = t - k(1), i = this.timeline(), n = i[0], a = i[i.length - 1];
+    if (!n || !a || a.wallclock - n.wallclock > to)
+      return;
+    const c = V.fromPromise(
+      ce.subscribe(
+        s(this, Er),
+        new $t().name(s(this, Tr)).groupOrder("ascending").range(e, e).build()
+      )
+    );
+    return f(this, Ze, Sa).call(this, c);
+  });
+};
+let va = Na;
+function Xu(r) {
+  var e;
+  const t = new TextDecoder("utf-8").decode(r).split(`
+`);
+  return (e = t[0]) != null && e.startsWith("MEDIA_PTS") && t.shift(), t.filter((i) => i.length > 0).map((i) => {
+    const [n, a, c, d, w] = i.split(",");
+    if (!n || !d)
+      throw new Error(`invalid timeline row: ${i}`);
+    return {
+      mediaPts: parseInt(n),
+      groupId: a ? parseInt(a) : void 0,
+      objectId: c ? parseInt(c) : void 0,
+      wallclock: parseInt(d),
+      metadata: w
+    };
+  });
+}
+function Yu(r) {
+  return typeof r.language == "string";
+}
+var Fn, Dr, re, Ws;
+const Ga = class Ga {
+  constructor(t, e, i, n, a) {
+    o(this, Fn, new Oc());
+    o(this, Dr);
+    o(this, re);
+    o(this, Ws, 0);
+    l(this, "trackObject");
+    l(this, "namespace");
+    u(this, re, t), u(this, Dr, e), this.trackObject = i, this.namespace = n, u(this, Ws, a);
+  }
+  static subscribe(t, e, i) {
+    return h(this, null, function* () {
+      if (!Yu(e))
+        throw new Error("track object language is required");
+      const n = new $t().name(e.name).build(), a = yield ce.subscribe(t, n), c = a.objects();
+      return new Ga(a, c, e, t.namespace(), i);
+    });
+  }
+  largestGroupId() {
+    return s(this, re).largestGroupId();
+  }
+  update(t, e) {
+    return s(this, re).update(t, e);
+  }
+  unsubscribe() {
+    return s(this, re).unsubscribe();
+  }
+  next() {
+    return h(this, null, function* () {
+      for (; ; ) {
+        const t = yield s(this, Dr).next();
+        if (t.done)
+          return t;
+        if (t.value.objectStatus !== X.Normal)
+          continue;
+        const e = new TextDecoder().decode(t.value.payload), i = s(this, Fn).parse(e).map((a) => (a.startTime -= s(this, Ws) / 1e3, a.endTime -= s(this, Ws) / 1e3, a));
+        return {
+          done: !1,
+          value: { language: this.trackObject.language, cues: i }
+        };
+      }
+    });
+  }
+  return() {
+    return h(this, null, function* () {
+      return yield s(this, re).return(), { done: !0, value: void 0 };
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  [Ct()]() {
+    return this.unsubscribe();
+  }
+  [Symbol.asyncDispose]() {
+    return this.unsubscribe();
+  }
+};
+Fn = new WeakMap(), Dr = new WeakMap(), re = new WeakMap(), Ws = new WeakMap();
+let Ua = Ga;
+var fo, Le, Fe, We, ne, oa, $s, Jr;
+fo = [q({ context: "Channel", enter: "info" })];
+const rs = class rs {
+  constructor(t, e, i, n, a) {
+    o(this, $s);
+    l(this, "namespace");
+    o(this, Le);
+    o(this, Fe);
+    o(this, We);
+    o(this, ne);
+    this.namespace = n, u(this, Le, t), u(this, Fe, e), u(this, We, i), u(this, ne, a);
+  }
+  static start(t, e) {
+    return h(this, null, function* () {
+      const i = new cc(t, { namespace: e.namespace }), [n, a] = yield Promise.all([
+        va.start(i, "timeline"),
+        ga.start(i, { catalog: e.catalog, namespace: e.namespace })
+      ]);
+      return new rs(i, n, a, e.namespace, 0);
+    });
+  }
+  closed() {
+    return s(this, We).closed();
+  }
+  catalog() {
+    return s(this, We).catalog();
+  }
+  timestampWallclockOffset() {
+    return s(this, Fe).timestampWallclockOffset();
+  }
+  timestampOffsetMs() {
+    return s(this, ne);
+  }
+  setTimestampOffsetMs(t) {
+    u(this, ne, t);
+  }
+  waitForWallclockTime(t) {
+    return s(this, Fe).waitForWallclockTime(t);
+  }
+  subscribeCmafTrack(t, e) {
+    const n = this.catalog().current().tracks.find(
+      (a) => a["com.vindral.variant_uid"] === t["com.vindral.variant_uid"]
+    );
+    return f(this, $s, Jr).call(this, () => Ia.subscribe(s(this, Le), n != null ? n : t, s(this, ne), e));
+  }
+  subscribeWebVttTrack(t) {
+    return f(this, $s, Jr).call(this, () => Ua.subscribe(s(this, Le), t, s(this, ne)));
+  }
+  subscribeTrack(t) {
+    return f(this, $s, Jr).call(this, () => s(this, Le).subscribe(t));
+  }
+  /**
+   * Closes the channel subscriptions
+   */
+  close() {
+    return Promise.all([s(this, We).close(), s(this, Fe).close()]);
+  }
+};
+oa = he(null), Le = new WeakMap(), Fe = new WeakMap(), We = new WeakMap(), ne = new WeakMap(), $s = new WeakSet(), Jr = function(t) {
+  return h(this, null, function* () {
+    const [e, i] = this.catalog().value();
+    try {
+      return yield t();
+    } catch (n) {
+      if (e === this.catalog().current() && i && (yield Promise.race([i, Yn(500)])), e !== this.catalog().current())
+        return t();
+      throw n;
+    }
+  });
+}, H(oa, 9, "start", fo, rs), zt(oa, rs), de(oa, 3, rs);
+let vn = rs;
+var $e, Or, Wn, lc;
+const La = class La {
+  constructor(t) {
+    o(this, Wn);
+    o(this, $e);
+    o(this, Or);
+    const [e, i] = t.value.value();
+    u(this, $e, {
+      createdAt: /* @__PURE__ */ new Date(),
+      wallclock: new Date(e.ntpTimestamp),
+      rtt: e.rtt
+    }), u(this, Or, f(this, Wn, lc).call(this, t));
+  }
+  /**
+   * @returns returns the current wallclock time in milliseconds based on the ntp timestamp of the stats track + the elapsed time since the last stats track.
+   */
+  wallclock() {
+    const e = Date.now() - s(this, $e).createdAt.getTime();
+    return s(this, $e).wallclock.getTime() + e;
+  }
+  closed() {
+    return s(this, Or);
+  }
+  static start(t) {
+    return new La(t);
+  }
+};
+$e = new WeakMap(), Or = new WeakMap(), Wn = new WeakSet(), lc = function(t) {
+  return h(this, null, function* () {
+    try {
+      for (var e = C(t.value), i, n, a; i = !(n = yield e.next()).done; i = !1) {
+        const c = n.value;
+        u(this, $e, {
+          createdAt: /* @__PURE__ */ new Date(),
+          wallclock: new Date(c.ntpTimestamp),
+          rtt: c.rtt
+        });
+      }
+    } catch (n) {
+      a = [n];
+    } finally {
+      try {
+        i && (n = e.return) && (yield n.call(e));
+      } finally {
+        if (a)
+          throw a[0];
+      }
+    }
+  });
+};
+let Ea = La;
+function $r(r) {
+  return typeof r == "string" || r === null || r === void 0;
+}
+function Zu(r) {
+  return "provider" in r && typeof r.provider == "string" && (!("widevineLicenseUrl" in r) || $r(r.widevineLicenseUrl)) && (!("playreadyLicenseUrl" in r) || $r(r.playreadyLicenseUrl)) && (!("fairplayLicenseUrl" in r) || $r(r.fairplayLicenseUrl)) && (!("fairplayCertificate" in r) || $r(r.fairplayCertificate));
+}
+function Ku(r) {
+  try {
+    return ko(r);
+  } catch (t) {
+    throw new Error("Failed to convert fairplayCertificate");
+  }
+}
+function Ju(r) {
+  const t = new TextDecoder().decode(r), e = JSON.parse(t);
+  if (!Zu(e))
+    throw new Error("Invalid drm object");
+  const a = e, { fairplayCertificate: i } = a, n = Za(a, ["fairplayCertificate"]);
+  return Wr(Mt({}, n), {
+    fairplayCertificate: i ? Ku(i) : void 0
+  });
+}
+class Pa {
+  constructor(t) {
+    l(this, "value");
+    this.value = t;
+  }
+  static create(t, e, i) {
+    return h(this, null, function* () {
+      var w = [];
+      try {
+        const n = rt(w, yield t.subscribeTrack(new $t().name("drm").build()), !0);
+        const a = n.objects();
+        const c = yield a.next();
+        if (c.done)
+          throw new Error("No drm object received");
+        const d = Ju(c.value.payload);
+        return new Pa(Wr(Mt({}, d), { videoCodec: e, audioCodec: i }));
+      } catch (p) {
+        var m = p, b = !0;
+      } finally {
+        var I = nt(w, m, b);
+        I && (yield I);
+      }
+    });
+  }
+}
+function Qu(r) {
+  return "rtt" in r && typeof r.rtt == "number" && "ntpTimestamp" in r && typeof r.ntpTimestamp == "number" && "estimatedBandwidth" in r && typeof r.estimatedBandwidth == "number";
+}
+function eo(r) {
+  const t = new TextDecoder().decode(r), e = JSON.parse(t);
+  if (!Qu(e))
+    throw new Error("Invalid stats object");
+  return e;
+}
+const qu = 1e4;
+var Vr, $n, wc;
+const Fa = class Fa {
+  constructor(t, e, i) {
+    o(this, $n);
+    l(this, "ip");
+    l(this, "value");
+    o(this, Vr);
+    this.ip = i, this.value = new Y(e), u(this, Vr, f(this, $n, wc).call(this, t));
+  }
+  closed() {
+    return s(this, Vr);
+  }
+  idleTimeout() {
+    return h(this, null, function* () {
+      for (; ; ) {
+        const [t, e] = this.value.value();
+        try {
+          yield Promise.race([yo(qu, new Error("Idle timeout")), e]);
+        } catch (i) {
+          return i;
+        }
+      }
+    });
+  }
+  static start(t) {
+    return h(this, null, function* () {
+      const i = (yield t.subscribe(new $t().name("stats").groupOrder("ascending").build())).objects(), n = yield i.next();
+      if (n.done)
+        throw new Error("No stats object received");
+      const a = eo(n.value.payload);
+      if (!a.ip)
+        throw new Error("Expected IP in initial stats object");
+      return new Fa(i, a, a.ip);
+    });
+  }
+};
+Vr = new WeakMap(), $n = new WeakSet(), wc = function(t) {
+  return h(this, null, function* () {
+    try {
+      for (var e = C(t), i, n, a; i = !(n = yield e.next()).done; i = !1) {
+        const c = n.value;
+        if (c.objectStatus !== X.Normal)
+          continue;
+        const d = eo(c.payload);
+        this.value.update(d);
+      }
+    } catch (n) {
+      a = [n];
+    } finally {
+      try {
+        i && (n = e.return) && (yield n.call(e));
+      } finally {
+        if (a)
+          throw a[0];
+      }
+    }
+  });
+};
+let Ta = Fa;
+var Mn, Ms;
+class _u {
+  constructor(t) {
+    o(this, Mn, gt.get().createContext("UpstreamWatcher"));
+    o(this, Ms);
+    u(this, Ms, new Y(V.fromPromise(t.closed())));
+  }
+  update(t) {
+    s(this, Ms).update(V.fromPromise(t.closed()));
+  }
+  closed() {
+    return h(this, null, function* () {
+      try {
+        for (; ; ) {
+          const [t, e] = s(this, Ms).value();
+          let i = !1;
+          yield Promise.race([
+            e == null ? void 0 : e.then(() => i = !0),
+            t.promise.then(() => {
+              if (!i)
+                throw s(this, Mn).warn("Upstream closed"), new Error("Upstream closed");
+            })
+          ]);
+        }
+      } catch (t) {
+        return t;
+      }
+    });
+  }
+}
+Mn = new WeakMap(), Ms = new WeakMap();
+var zs, Cr, Br;
+class sa {
+  constructor(t, e) {
+    o(this, zs, gt.get().createContext("TracksIterator"));
+    o(this, Cr);
+    o(this, Br);
+    u(this, Cr, t), u(this, Br, e);
+  }
+  [Symbol.asyncIterator]() {
+    return xt(this, null, function* () {
+      const t = s(this, Br);
+      try {
+        for (var e = C(s(this, Cr)), i, n, a; i = !(n = yield new O(e.next())).done; i = !1) {
+          const c = n.value;
+          if (!c)
+            continue;
+          const d = {
+            name: c.trackObject.name,
+            namespace: c.namespace
+          };
+          s(this, zs).debug("track start", Mt({ mediaType: t }, d)), yield* ta(c), s(this, zs).debug("track end", Mt({ mediaType: t }, d));
+        }
+      } catch (n) {
+        a = [n];
+      } finally {
+        try {
+          i && (n = e.return) && (yield new O(n.call(e)));
+        } finally {
+          if (a)
+            throw a[0];
+        }
+      }
+      s(this, zs).debug("tracks ended", { mediaType: t });
+    });
+  }
+}
+zs = new WeakMap(), Cr = new WeakMap(), Br = new WeakMap();
+var po, bo, mo, Hs, Xs, Me, F, bt, mt, ae, Ys, xr, ni, Z, Qr, ui, fc, Da;
+mo = [q({ context: "Player", enter: "info" })], bo = [q({ context: "Player", enter: "info", return: "info" })], po = [q({ context: "Player", enter: "info" })];
+const ns = class ns {
+  constructor(t, e, i) {
+    de(ni, 5, this);
+    o(this, Z);
+    o(this, Hs);
+    o(this, Xs);
+    o(this, Me);
+    o(this, F);
+    o(this, bt, new Y(void 0));
+    o(this, mt, new Y(void 0));
+    o(this, ae, new Y(void 0));
+    o(this, Ys);
+    o(this, xr);
+    l(this, "subtitles", new sa(s(this, ae), "subtitles"));
+    l(this, "video", new sa(s(this, mt), "video"));
+    l(this, "audio", new sa(s(this, bt), "audio"));
+    u(this, Hs, t), u(this, Xs, Ea.start(i)), u(this, Me, i), u(this, F, new Y(e)), u(this, Ys, new _u(e)), u(this, xr, Promise.race([i.idleTimeout(), f(this, Z, fc).call(this), s(this, Ys).closed()])), s(this, Hs).closed().then(() => this.close()).catch(D);
+  }
+  closed() {
+    return s(this, xr);
+  }
+  static start(t, e) {
+    return h(this, null, function* () {
+      const i = new cc(t, { namespace: Fu("auxiliary") }), [[n, a, c], d] = yield Promise.all([
+        vn.start(t, e).then((p) => Promise.all([
+          Promise.resolve(p),
+          e.videoTrack ? p.subscribeCmafTrack(e.videoTrack) : void 0,
+          e.audioTrack ? p.subscribeCmafTrack(e.audioTrack) : void 0
+        ])),
+        Ta.start(i)
+      ]), w = new ns(t, n, d);
+      return c && s(w, bt).update(c), a && s(w, mt).update(a), w;
+    });
+  }
+  connectionInfo() {
+    const t = s(this, Me).value.current();
+    return {
+      ip: s(this, Me).ip,
+      rtt: t.rtt,
+      estimatedBandwidth: t.estimatedBandwidth
+    };
+  }
+  stats() {
+    return s(this, Me).value;
+  }
+  catalog() {
+    return s(this, F).current().catalog();
+  }
+  namespace() {
+    return s(this, F).current().namespace;
+  }
+  videoTrack() {
+    var t;
+    return (t = s(this, mt).current()) == null ? void 0 : t.trackObject;
+  }
+  audioTrack() {
+    var t;
+    return (t = s(this, bt).current()) == null ? void 0 : t.trackObject;
+  }
+  referenceClock() {
+    return s(this, Xs);
+  }
+  drm() {
+    return h(this, null, function* () {
+      var e, i;
+      if (this.catalog().current().tracks.find(({ name: n }) => n === "drm"))
+        return Pa.create(s(this, F).current(), (e = this.videoTrack()) == null ? void 0 : e.codec, (i = this.audioTrack()) == null ? void 0 : i.codec);
+    });
+  }
+  close() {
+    return Promise.all([
+      // Close the channel subscription
+      s(this, F).current().close(),
+      // Close the channel ObservableValue
+      s(this, F).close(),
+      // Close the consumers so that the iterators will stop
+      f(this, Z, Qr).call(this, s(this, bt)),
+      f(this, Z, Qr).call(this, s(this, mt)),
+      f(this, Z, Qr).call(this, s(this, ae))
+    ]);
+  }
+  zap(t, e) {
+    return h(this, null, function* () {
+      var E, z;
+      const i = yield vn.start(s(this, Hs), t), n = s(this, Xs).wallclock() - e, a = s(this, F).current(), c = a.timestampWallclockOffset(), d = yield i.waitForWallclockTime(n);
+      s(this, Ys).update(i), yield s(this, F).current().close();
+      const w = d.toReversed().find((_) => _.wallclock <= n), p = w != null && w.mediaPts ? w.mediaPts - a.timestampOffsetMs() : void 0, I = i.timestampWallclockOffset() - c + a.timestampOffsetMs();
+      i.setTimestampOffsetMs(I);
+      const g = w != null && w.groupId ? k(w.groupId) : void 0;
+      p && ((E = s(this, mt).current()) == null || E.stopAfterTimestampReached(p), (z = s(this, bt).current()) == null || z.stopAfterTimestampReached(p)), s(this, F).update(i), yield Promise.all([
+        t.videoTrack ? this.setVideoTrack(t.videoTrack, g) : void 0,
+        t.audioTrack ? this.setAudioTrack(t.audioTrack, g) : void 0
+      ]);
+    });
+  }
+  setSubtitleTrack(t) {
+    return h(this, null, function* () {
+      var i, n;
+      if (!t) {
+        yield (i = s(this, ae).current()) == null ? void 0 : i.unsubscribe();
+        return;
+      }
+      const [e] = yield Promise.all([
+        s(this, F).current().subscribeWebVttTrack(t),
+        (n = s(this, ae).current()) == null ? void 0 : n.unsubscribe()
+      ]);
+      s(this, ae).update(e);
+    });
+  }
+  setVideoTrack(t, e) {
+    return h(this, null, function* () {
+      const i = yield f(this, Z, ui).call(this, s(this, F).current(), t, s(this, mt).current(), e);
+      s(this, mt).update(i);
+    });
+  }
+  setAudioTrack(t, e) {
+    return h(this, null, function* () {
+      const i = yield f(this, Z, ui).call(this, s(this, F).current(), t, s(this, bt).current(), e);
+      s(this, bt).update(i);
+    });
+  }
+};
+ni = he(null), Hs = new WeakMap(), Xs = new WeakMap(), Me = new WeakMap(), F = new WeakMap(), bt = new WeakMap(), mt = new WeakMap(), ae = new WeakMap(), Ys = new WeakMap(), xr = new WeakMap(), Z = new WeakSet(), Qr = function(t) {
+  const e = t.current(), i = e == null ? void 0 : e.largestGroupId();
+  return t.isClosed() || t.update(void 0), t.close(), i ? e == null ? void 0 : e.update(i, i) : e == null ? void 0 : e.unsubscribe();
+}, ui = function(t, e, i, n) {
+  return h(this, null, function* () {
+    const a = i == null ? void 0 : i.largestGroupId(), [c, d] = yield Promise.all([
+      t.subscribeCmafTrack(
+        e,
+        n || (a ? a + k(1) : void 0)
+      ),
+      a ? i == null ? void 0 : i.update(a, a) : i == null ? void 0 : i.unsubscribe()
+    ]);
+    return c;
+  });
+}, fc = function() {
+  return h(this, null, function* () {
+    try {
+      for (var a = C(s(this, F)), c, d, w; c = !(d = yield a.next()).done; c = !1) {
+        const p = d.value;
+        try {
+          for (var t = C(p.catalog()), e, i, n; e = !(i = yield t.next()).done; e = !1) {
+            const m = i.value;
+            yield Promise.all([
+              f(this, Z, Da).call(this, m, s(this, mt)),
+              f(this, Z, Da).call(this, m, s(this, bt))
+            ]);
+          }
+        } catch (i) {
+          n = [i];
+        } finally {
+          try {
+            e && (i = t.return) && (yield i.call(t));
+          } finally {
+            if (n)
+              throw n[0];
+          }
+        }
+      }
+    } catch (d) {
+      w = [d];
+    } finally {
+      try {
+        c && (d = a.return) && (yield d.call(a));
+      } finally {
+        if (w)
+          throw w[0];
+      }
+    }
+  });
+}, Da = function(t, e) {
+  return h(this, null, function* () {
+    const i = e.current();
+    if (!i)
+      return;
+    const n = i.trackObject.name, a = i.trackObject["com.vindral.variant_uid"], c = t.tracks.find((w) => w.name === n), d = t.tracks.find((w) => w["com.vindral.variant_uid"] === a);
+    if (!c) {
+      if (!d) {
+        e.update(void 0);
+        return;
+      }
+      e.update(yield s(this, F).current().subscribeCmafTrack(d));
+    }
+  });
+}, H(ni, 1, "close", mo, ns), H(ni, 1, "zap", bo, ns), ui = H(ni, 17, "#replaceTrack", po, Z, ui), zt(ni, ns);
+let Aa = ns;
+function ia(r, t, e) {
+  const i = new URL("/voq/subscribe", r);
+  return i.searchParams.set("sessionId", t.sessionId), i.searchParams.set("clientId", t.clientId), i.searchParams.set("channelId", t.channelId), e && i.searchParams.set("authToken", e), i;
+}
+const th = 1e4;
+var L, Q, yt, ze, Zs, Ks, B, oe, Pr, Rr, zn, Js, K, pc, Qs, jr, qs, bc, mc, yc, gc, Oa;
+const Wa = class Wa {
+  constructor(t, e, i, n, a, c) {
+    o(this, K);
+    o(this, L);
+    o(this, Q);
+    o(this, yt);
+    o(this, ze, "disconnected");
+    o(this, Zs);
+    o(this, Ks);
+    o(this, B);
+    o(this, oe, /* @__PURE__ */ new Map());
+    o(this, Pr);
+    o(this, Rr, new Va(10));
+    o(this, zn, Number.MAX_SAFE_INTEGER);
+    o(this, Js, /* @__PURE__ */ new Map());
+    o(this, Qs, (t) => {
+      if (!t) {
+        s(this, B).setSubtitleTrack(void 0).catch(D);
+        return;
+      }
+      const e = s(this, oe).get(le(s(this, B).namespace())), i = e == null ? void 0 : e.getTextTrack(t);
+      i && s(this, B).setSubtitleTrack(i).catch(D);
+    });
+    o(this, jr, (t) => {
+      switch (t.type) {
+        case "subscribe":
+          {
+            if (s(this, qs)) {
+              s(this, Q).info("Ignoring  - we are already switching");
+              return;
+            }
+            u(this, qs, !0), f(this, K, mc).call(this, t.subscription).catch((e) => {
+              s(this, Q).error("error handling subscription", e), s(this, L).emit("received signal", {
+                type: "subscription changed",
+                subscription: t.subscription,
+                reset: !0
+              });
+            }).finally(() => u(this, qs, !1));
+          }
+          break;
+        case "telemetry":
+          xc(new URL("/api/telemetry", s(this, yt).url().replace("wss://", "https://")), {
+            body: t.body,
+            headers: { "Content-Type": "text/plain" }
+          }).catch(D);
+          break;
+        case "refresh auth":
+          s(this, yt).updateAuthToken(t.token);
+          break;
+      }
+    });
+    o(this, qs, !1);
+    l(this, "disconnect", (t = "Disconnect Requested") => {
+      s(this, Q).info("Disconnecting", t), s(this, yt).close(), s(this, B).close().catch(D), u(this, Js, /* @__PURE__ */ new Map()), u(this, ze, "disconnected");
+    });
+    u(this, L, t), u(this, Q, e), u(this, yt, i), u(this, B, n), u(this, oe, a), u(this, Pr, c), s(this, L).on("send signal", s(this, jr)), s(this, L).on("disconnect", this.disconnect), s(this, L).on("text track", s(this, Qs)), f(this, K, pc).call(this).catch(D), f(this, K, yc).call(this).catch(D);
+  }
+  get estimatedBandwidth() {
+    return s(this, zn);
+  }
+  get firstConnectionTime() {
+    return s(this, Zs);
+  }
+  get lastConnectionTime() {
+    return s(this, Ks);
+  }
+  unload() {
+    s(this, L).off("send signal", s(this, jr)), s(this, L).off("disconnect", this.disconnect), s(this, L).off("text track", s(this, Qs)), this.disconnect();
+  }
+  suspend() {
+  }
+  unsuspend() {
+  }
+  getStatistics() {
+    const e = s(this, B).connectionInfo().estimatedBandwidth;
+    return {
+      rtt: Vc(s(this, Rr).items()),
+      estimatedBandwidth: e,
+      connectCount: 0,
+      connectionAttemptCount: 0,
+      edgeUrl: s(this, yt).url(),
+      connectionProtocol: "moq"
+    };
+  }
+  static start(t, e, i, n) {
+    return h(this, null, function* () {
+      var A, S, W, v;
+      const a = new Map(
+        n.connectInfo.channels.map((R) => [
+          le(R.catalog.namespace),
+          new ra(new Y(R.catalog))
+        ])
+      ), c = yield n.onConnectInfo(n.connectInfo), d = n.options.get("authenticationToken");
+      let w, p;
+      switch (typeof n.edgeUrl) {
+        case "string": {
+          w = ia(n.edgeUrl, c, d);
+          break;
+        }
+        default:
+          w = ia(n.edgeUrl.moqUrl || n.edgeUrl.moqWsUrl, c, d), p = ia(n.edgeUrl.moqWsUrl, c, d);
+          break;
+      }
+      const m = (A = n.connectInfo.channels.find((R) => R.channelId === c.channelId)) == null ? void 0 : A.catalog;
+      e.debug("Resolved edge url", { edgeUrl: w, edgeWsUrl: p }), go(m, "no catalog found");
+      const b = (S = a.get(le(m.namespace))) == null ? void 0 : S.getVideoTrack(c.video), I = (W = a.get(le(m.namespace))) == null ? void 0 : W.getAudioTrack(c.audio), g = yield Lu({
+        url: w,
+        wsUrl: p,
+        handshakePipelining: !0,
+        authToken: n.options.get("authenticationToken"),
+        preferredTransport: n.options.get("webtransportEnabled") ? "webtransport" : "websocket",
+        role: su.Subscriber
+      }), E = yield Promise.race([
+        Aa.start(g.subscriber, {
+          namespace: m.namespace,
+          catalog: m,
+          videoTrack: b == null ? void 0 : b.track,
+          audioTrack: I == null ? void 0 : I.track
+        }),
+        yo(th, new Error("Timeout waiting for player to start"))
+      ]), z = new ra(E.catalog());
+      a.set(le(m.namespace), z), t.emit("received signal", {
+        type: "client ip",
+        ip: E.connectionInfo().ip
+      }), E.drm().then((R) => {
+        R && t.emit("received drm data", R.value);
+      }).catch((R) => {
+        e.error("Error getting DRM data", R);
+      });
+      const _ = new Wa(t, e, g, E, a, i);
+      return c.textTrack && s(v = _, Qs).call(v, c.textTrack), _;
+    });
+  }
+  getState() {
+    return s(this, ze);
+  }
+  get rtt() {
+    return s(this, B).connectionInfo().rtt;
+  }
+  close() {
+    s(this, yt).close();
+  }
+  closed() {
+    return Promise.race([s(this, yt).closed(), s(this, B).closed()]);
+  }
+};
+L = new WeakMap(), Q = new WeakMap(), yt = new WeakMap(), ze = new WeakMap(), Zs = new WeakMap(), Ks = new WeakMap(), B = new WeakMap(), oe = new WeakMap(), Pr = new WeakMap(), Rr = new WeakMap(), zn = new WeakMap(), Js = new WeakMap(), K = new WeakSet(), pc = function() {
+  return h(this, null, function* () {
+    try {
+      for (var t = C(s(this, B).stats()), e, i, n; e = !(i = yield t.next()).done; e = !1) {
+        const { rtt: a } = i.value;
+        s(this, Rr).push(a);
+      }
+    } catch (i) {
+      n = [i];
+    } finally {
+      try {
+        e && (i = t.return) && (yield i.call(t));
+      } finally {
+        if (n)
+          throw n[0];
+      }
+    }
+  });
+}, Qs = new WeakMap(), jr = new WeakMap(), qs = new WeakMap(), bc = function(t) {
+  return h(this, null, function* () {
+    var n;
+    const e = yield s(this, Pr).connect({ channelId: t });
+    if (!Pc(e))
+      throw new Error("no moq connect info found");
+    const i = (n = e.channels.find((a) => a.channelId === t)) == null ? void 0 : n.catalog;
+    if (!i)
+      throw new Error("no catalog found");
+    return i;
+  });
+}, mc = function(t) {
+  return h(this, null, function* () {
+    var c, d, w;
+    s(this, Q).info("handle subscription", t);
+    const e = s(this, B);
+    let i = s(this, oe).get(t.channelId);
+    if (i || (i = new ra(new Y(yield f(this, K, bc).call(this, t.channelId))), s(this, oe).set(t.channelId, i)), e.namespace().join("/") !== i.namespace().join("/")) {
+      s(this, Q).info("changing channel", t.channelId);
+      const p = i.getVideoTrack(t.video), m = i.getAudioTrack(t.audio);
+      yield e.zap(
+        {
+          namespace: i.namespace(),
+          catalog: i.catalog(),
+          videoTrack: p == null ? void 0 : p.track,
+          audioTrack: m == null ? void 0 : m.track
+        },
+        500
+      ), s(this, Q).info("switched channel", t.channelId), (c = s(this, oe).get(le(e.namespace()))) == null || c.updateCatalog(e.catalog()), s(this, L).emit("received signal", {
+        type: "subscription changed",
+        subscription: t
+      });
+      return;
+    }
+    const n = i.getVideoTrack(t.video), a = i.getAudioTrack(t.audio);
+    yield Promise.all([
+      n && n.track.name !== ((d = s(this, B).videoTrack()) == null ? void 0 : d.name) ? s(this, B).setVideoTrack(n.track) : void 0,
+      a && a.track.name !== ((w = s(this, B).audioTrack()) == null ? void 0 : w.name) ? s(this, B).setAudioTrack(a.track) : void 0
+    ]), s(this, L).emit("received signal", {
+      type: "subscription changed",
+      subscription: t
+    });
+  });
+}, yc = function() {
+  return h(this, null, function* () {
+    try {
+      u(this, ze, "connecting"), s(this, Q).info("Connecting..."), u(this, Ks, Date.now()), s(this, Zs) || u(this, Zs, s(this, Ks)), u(this, ze, "connected"), yield Promise.all([
+        f(this, K, Oa).call(this, s(this, B).referenceClock(), s(this, B).audio),
+        f(this, K, Oa).call(this, s(this, B).referenceClock(), s(this, B).video),
+        f(this, K, gc).call(this, s(this, B).subtitles)
+      ]), yield s(this, B).closed(), s(this, yt).close(), s(this, Q).info("Session closed");
+    } catch (t) {
+      s(this, Q).warn("Session error", t);
+    }
+  });
+}, gc = function(t) {
+  return h(this, null, function* () {
+    try {
+      for (var e = C(t), i, n, a; i = !(n = yield e.next()).done; i = !1) {
+        const c = n.value;
+        s(this, L).emit("text track data", c);
+      }
+    } catch (n) {
+      a = [n];
+    } finally {
+      try {
+        i && (n = e.return) && (yield n.call(e));
+      } finally {
+        if (a)
+          throw a[0];
+      }
+    }
+  });
+}, Oa = function(t, e) {
+  return h(this, null, function* () {
+    let i = "", n = "";
+    try {
+      for (var p = C(e), m, b, I; m = !(b = yield p.next()).done; m = !1) {
+        const g = b.value;
+        const E = le(g.track.namespace), z = g.track.trackObject.language;
+        try {
+          for (var a = C(g), c, d, w; c = !(d = yield a.next()).done; c = !1) {
+            const [_, A] = d.value;
+            i !== "" && i !== E && A.mediaType() === "video" && s(this, L).emit("add event", {
+              type: "channel switch",
+              channelId: E,
+              timestamp: A.baseMediaDecodeTime() / A.timescale() * 1e3
+            }), i = E, n !== "" && z && n !== z && A.mediaType() === "audio" && s(this, L).emit("add event", {
+              type: "language switch",
+              language: z,
+              timestamp: A.baseMediaDecodeTime() / A.timescale() * 1e3
+            }), n = z;
+            const S = A.producerReferenceTime(), W = s(this, Js).get(g.track.namespace) || 0;
+            if (S && Date.now() - W > 1e3) {
+              s(this, Js).set(g.track.namespace, Date.now());
+              const v = t.wallclock() - S.getTime();
+              s(this, Q).info("ti", {
+                medaiType: A.mediaType(),
+                referenceClock: t,
+                delta: v,
+                groupId: _,
+                timestamp: A.baseMediaDecodeTime() / A.timescale() * 1e3 + v,
+                wallclockTime: S.getTime()
+              }), s(this, L).emit("received signal", {
+                type: "timing info",
+                timingInfo: {
+                  channelId: E,
+                  timestamp: A.baseMediaDecodeTime() / A.timescale() * 1e3 + v,
+                  wallclockTime: S.getTime()
+                }
+              });
+            }
+            s(this, L).emit("received moq data", {
+              payload: A,
+              channelId: E,
+              groupId: _,
+              // FIXME: We should replace this with something better than hashing the track name
+              renditionId: eh(g.track.trackObject.name)
+            });
+          }
+        } catch (d) {
+          w = [d];
+        } finally {
+          try {
+            c && (d = a.return) && (yield d.call(a));
+          } finally {
+            if (w)
+              throw w[0];
+          }
+        }
+      }
+    } catch (b) {
+      I = [b];
+    } finally {
+      try {
+        m && (b = p.return) && (yield b.call(p));
+      } finally {
+        if (I)
+          throw I[0];
+      }
+    }
+  });
+};
+let so = Wa;
+function eh(r) {
+  return r.split("").reduce(
+    (e, i) => e = i.charCodeAt(0) + (e << 6) + (e << 16) - e,
+    0
+  );
+}
+var Wt, He, Hn, kc;
+class ra {
+  constructor(t) {
+    o(this, Hn);
+    o(this, Wt);
+    o(this, He);
+    u(this, Wt, t), u(this, He, f(this, Hn, kc).call(this));
+  }
+  catalog() {
+    return s(this, Wt).current();
+  }
+  namespace() {
+    return s(this, Wt).current().namespace;
+  }
+  updateCatalog(t) {
+    u(this, Wt, t);
+  }
+  getTextTrack(t) {
+    return s(this, Wt).current().tracks.find((e) => e.label === t);
+  }
+  getAudioTrack(t) {
+    return t.codec ? s(this, He).filter((i) => !(!Cc(i) || i.bitRate > t.bitRate || t.codec && i.codec !== t.codec || t.language && i.language !== t.language)).at(-1) : void 0;
+  }
+  getVideoTrack(t) {
+    return t.codec ? s(this, He).filter((i) => !(!Bc(i) || i.bitRate > t.bitRate || t.codec && i.codec !== t.codec)).at(-1) : void 0;
+  }
+  renditions() {
+    return s(this, He);
+  }
+}
+Wt = new WeakMap(), He = new WeakMap(), Hn = new WeakSet(), kc = function() {
+  const [t, e] = s(this, Wt).value();
+  return Rc(t);
+};
+export {
+  ra as CatalogObserver,
+  so as MoqConnectionAdapter
+};