@vindral/web-sdk 3.4.3 → 4.0.0-190-g016e452d

package/CyQYN-2T.js

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