@moq/publish 0.1.0

package/main-DGBFe0O7.js

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