@webitel/ui-sdk 25.12.79 → 26.2.0-1

package/dist/plyr-B0Ha1r7X.js

@@ -0,0 +1,4152 @@
+function m(e, i, t) {
+  return (i = bt(i)) in e ? Object.defineProperty(e, i, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[i] = t, e;
+}
+function gt(e, i) {
+  if (typeof e != "object" || !e) return e;
+  var t = e[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var s = t.call(e, i);
+    if (typeof s != "object") return s;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (i === "string" ? String : Number)(e);
+}
+function bt(e) {
+  var i = gt(e, "string");
+  return typeof i == "symbol" ? i : i + "";
+}
+function yt(e, i) {
+  if (!(e instanceof i)) throw new TypeError("Cannot call a class as a function");
+}
+function Oe(e, i) {
+  for (var t = 0; t < i.length; t++) {
+    var s = i[t];
+    s.enumerable = s.enumerable || !1, s.configurable = !0, "value" in s && (s.writable = !0), Object.defineProperty(e, s.key, s);
+  }
+}
+function vt(e, i, t) {
+  return i && Oe(e.prototype, i), t && Oe(e, t), e;
+}
+function wt(e, i, t) {
+  return i in e ? Object.defineProperty(e, i, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[i] = t, e;
+}
+function _e(e, i) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var s = Object.getOwnPropertySymbols(e);
+    i && (s = s.filter(function(n) {
+      return Object.getOwnPropertyDescriptor(e, n).enumerable;
+    })), t.push.apply(t, s);
+  }
+  return t;
+}
+function je(e) {
+  for (var i = 1; i < arguments.length; i++) {
+    var t = arguments[i] != null ? arguments[i] : {};
+    i % 2 ? _e(Object(t), !0).forEach(function(s) {
+      wt(e, s, t[s]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : _e(Object(t)).forEach(function(s) {
+      Object.defineProperty(e, s, Object.getOwnPropertyDescriptor(t, s));
+    });
+  }
+  return e;
+}
+var De = {
+  addCSS: !0,
+  thumbWidth: 15,
+  watch: !0
+};
+function kt(e, i) {
+  return (function() {
+    return Array.from(document.querySelectorAll(i)).includes(this);
+  }).call(e, i);
+}
+function Tt(e, i) {
+  if (e && i) {
+    var t = new Event(i, {
+      bubbles: !0
+    });
+    e.dispatchEvent(t);
+  }
+}
+var ie = function(e) {
+  return e != null ? e.constructor : null;
+}, Me = function(e, i) {
+  return !!(e && i && e instanceof i);
+}, Be = function(e) {
+  return e == null;
+}, We = function(e) {
+  return ie(e) === Object;
+}, Ct = function(e) {
+  return ie(e) === Number && !Number.isNaN(e);
+}, ze = function(e) {
+  return ie(e) === String;
+}, At = function(e) {
+  return ie(e) === Boolean;
+}, Et = function(e) {
+  return ie(e) === Function;
+}, Ke = function(e) {
+  return Array.isArray(e);
+}, Ye = function(e) {
+  return Me(e, NodeList);
+}, St = function(e) {
+  return Me(e, Element);
+}, Pt = function(e) {
+  return Me(e, Event);
+}, Mt = function(e) {
+  return Be(e) || (ze(e) || Ke(e) || Ye(e)) && !e.length || We(e) && !Object.keys(e).length;
+}, D = {
+  nullOrUndefined: Be,
+  object: We,
+  number: Ct,
+  string: ze,
+  boolean: At,
+  function: Et,
+  array: Ke,
+  nodeList: Ye,
+  element: St,
+  event: Pt,
+  empty: Mt
+};
+function Nt(e) {
+  var i = "".concat(e).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
+  return i ? Math.max(0, (i[1] ? i[1].length : 0) - (i[2] ? +i[2] : 0)) : 0;
+}
+function xt(e, i) {
+  if (1 > i) {
+    var t = Nt(i);
+    return parseFloat(e.toFixed(t));
+  }
+  return Math.round(e / i) * i;
+}
+var Lt = (function() {
+  function e(i, t) {
+    yt(this, e), D.element(i) ? this.element = i : D.string(i) && (this.element = document.querySelector(i)), D.element(this.element) && D.empty(this.element.rangeTouch) && (this.config = je({}, De, {}, t), this.init());
+  }
+  return vt(e, [{
+    key: "init",
+    value: function() {
+      e.enabled && (this.config.addCSS && (this.element.style.userSelect = "none", this.element.style.webKitUserSelect = "none", this.element.style.touchAction = "manipulation"), this.listeners(!0), this.element.rangeTouch = this);
+    }
+  }, {
+    key: "destroy",
+    value: function() {
+      e.enabled && (this.config.addCSS && (this.element.style.userSelect = "", this.element.style.webKitUserSelect = "", this.element.style.touchAction = ""), this.listeners(!1), this.element.rangeTouch = null);
+    }
+  }, {
+    key: "listeners",
+    value: function(i) {
+      var t = this, s = i ? "addEventListener" : "removeEventListener";
+      ["touchstart", "touchmove", "touchend"].forEach(function(n) {
+        t.element[s](n, function(r) {
+          return t.set(r);
+        }, !1);
+      });
+    }
+  }, {
+    key: "get",
+    value: function(i) {
+      if (!e.enabled || !D.event(i)) return null;
+      var t, s = i.target, n = i.changedTouches[0], r = parseFloat(s.getAttribute("min")) || 0, l = parseFloat(s.getAttribute("max")) || 100, o = parseFloat(s.getAttribute("step")) || 1, c = s.getBoundingClientRect(), u = 100 / c.width * (this.config.thumbWidth / 2) / 100;
+      return 0 > (t = 100 / c.width * (n.clientX - c.left)) ? t = 0 : 100 < t && (t = 100), 50 > t ? t -= (100 - 2 * t) * u : 50 < t && (t += 2 * (t - 50) * u), r + xt(t / 100 * (l - r), o);
+    }
+  }, {
+    key: "set",
+    value: function(i) {
+      e.enabled && D.event(i) && !i.target.disabled && (i.preventDefault(), i.target.value = this.get(i), Tt(i.target, i.type === "touchend" ? "change" : "input"));
+    }
+  }], [{
+    key: "setup",
+    value: function(i) {
+      var t = 1 < arguments.length && arguments[1] !== void 0 ? arguments[1] : {}, s = null;
+      if (D.empty(i) || D.string(i) ? s = Array.from(document.querySelectorAll(D.string(i) ? i : 'input[type="range"]')) : D.element(i) ? s = [i] : D.nodeList(i) ? s = Array.from(i) : D.array(i) && (s = i.filter(D.element)), D.empty(s)) return null;
+      var n = je({}, De, {}, t);
+      if (D.string(i) && n.watch) {
+        var r = new MutationObserver(function(l) {
+          Array.from(l).forEach(function(o) {
+            Array.from(o.addedNodes).forEach(function(c) {
+              D.element(c) && kt(c, i) && new e(c, n);
+            });
+          });
+        });
+        r.observe(document.body, {
+          childList: !0,
+          subtree: !0
+        });
+      }
+      return s.map(function(l) {
+        return new e(l, t);
+      });
+    }
+  }, {
+    key: "enabled",
+    get: function() {
+      return "ontouchstart" in document.documentElement;
+    }
+  }]), e;
+})();
+const se = (e) => e !== null && typeof e < "u" ? e.constructor : null, B = (e, i) => !!(e && i && e instanceof i), Ne = (e) => e === null || typeof e > "u", Xe = (e) => se(e) === Object, $t = (e) => se(e) === Number && !Number.isNaN(e), pe = (e) => se(e) === String, It = (e) => se(e) === Boolean, Qe = (e) => typeof e == "function", Je = (e) => Array.isArray(e), Ot = (e) => B(e, WeakMap), Ge = (e) => B(e, NodeList), _t = (e) => se(e) === Text, jt = (e) => B(e, Event), Dt = (e) => B(e, KeyboardEvent), Rt = (e) => B(e, window.TextTrackCue) || B(e, window.VTTCue), Ht = (e) => B(e, TextTrack) || !Ne(e) && pe(e.kind), qt = (e) => B(e, Promise) && Qe(e.then);
+function Vt(e) {
+  return e !== null && typeof e == "object" && e.nodeType === 1 && typeof e.style == "object" && typeof e.ownerDocument == "object";
+}
+function Ze(e) {
+  return Ne(e) || (pe(e) || Je(e) || Ge(e)) && !e.length || Xe(e) && !Object.keys(e).length;
+}
+function Ft(e) {
+  if (B(e, window.URL))
+    return !0;
+  if (!pe(e))
+    return !1;
+  let i = e;
+  (!e.startsWith("http://") || !e.startsWith("https://")) && (i = `http://${e}`);
+  try {
+    return !Ze(new URL(i).hostname);
+  } catch {
+    return !1;
+  }
+}
+var a = {
+  nullOrUndefined: Ne,
+  object: Xe,
+  number: $t,
+  string: pe,
+  boolean: It,
+  function: Qe,
+  array: Je,
+  weakMap: Ot,
+  nodeList: Ge,
+  element: Vt,
+  textNode: _t,
+  event: jt,
+  keyboardEvent: Dt,
+  cue: Rt,
+  track: Ht,
+  promise: qt,
+  url: Ft,
+  empty: Ze
+};
+const ke = (() => {
+  const e = document.createElement("span"), i = {
+    WebkitTransition: "webkitTransitionEnd",
+    MozTransition: "transitionend",
+    OTransition: "oTransitionEnd otransitionend",
+    transition: "transitionend"
+  }, t = Object.keys(i).find((s) => e.style[s] !== void 0);
+  return a.string(t) ? i[t] : !1;
+})();
+function et(e, i) {
+  setTimeout(() => {
+    try {
+      e.hidden = !0, e.offsetHeight, e.hidden = !1;
+    } catch {
+    }
+  }, i);
+}
+function Ut(e) {
+  return JSON.parse(JSON.stringify(e));
+}
+function tt(e, i) {
+  return i.split(".").reduce((t, s) => t && t[s], e);
+}
+function L(e = {}, ...i) {
+  if (!i.length)
+    return e;
+  const t = i.shift();
+  return a.object(t) ? (Object.keys(t).forEach((s) => {
+    a.object(t[s]) ? (Object.keys(e).includes(s) || Object.assign(e, {
+      [s]: {}
+    }), L(e[s], t[s])) : Object.assign(e, {
+      [s]: t[s]
+    });
+  }), L(e, ...i)) : e;
+}
+function it(e, i) {
+  const t = e.length ? e : [e];
+  Array.from(t).reverse().forEach((s, n) => {
+    const r = n > 0 ? i.cloneNode(!0) : i, l = s.parentNode, o = s.nextSibling;
+    r.appendChild(s), o ? l.insertBefore(r, o) : l.appendChild(r);
+  });
+}
+function Te(e, i) {
+  !a.element(e) || a.empty(i) || Object.entries(i).filter(([, t]) => !a.nullOrUndefined(t)).forEach(([t, s]) => e.setAttribute(t, s));
+}
+function y(e, i, t) {
+  const s = document.createElement(e);
+  return a.object(i) && Te(s, i), a.string(t) && (s.textContent = t), s;
+}
+function Bt(e, i) {
+  !a.element(e) || !a.element(i) || i.parentNode.insertBefore(e, i.nextSibling);
+}
+function Re(e, i, t, s) {
+  a.element(i) && i.appendChild(y(e, t, s));
+}
+function U(e) {
+  if (a.nodeList(e) || a.array(e)) {
+    Array.from(e).forEach(U);
+    return;
+  }
+  !a.element(e) || !a.element(e.parentNode) || e.parentNode.removeChild(e);
+}
+function ae(e) {
+  if (!a.element(e)) return;
+  let {
+    length: i
+  } = e.childNodes;
+  for (; i > 0; )
+    e.removeChild(e.lastChild), i -= 1;
+}
+function ue(e, i) {
+  return !a.element(i) || !a.element(i.parentNode) || !a.element(e) ? null : (i.parentNode.replaceChild(e, i), e);
+}
+function V(e, i) {
+  if (!a.string(e) || a.empty(e)) return {};
+  const t = {}, s = L({}, i);
+  return e.split(",").forEach((n) => {
+    const r = n.trim(), l = r.replace(".", ""), c = r.replace(/[[\]]/g, "").split("="), [u] = c, p = c.length > 1 ? c[1].replace(/["']/g, "") : "";
+    switch (r.charAt(0)) {
+      case ".":
+        a.string(s.class) ? t.class = `${s.class} ${l}` : t.class = l;
+        break;
+      case "#":
+        t.id = r.replace("#", "");
+        break;
+      case "[":
+        t[u] = p;
+        break;
+    }
+  }), L(s, t);
+}
+function K(e, i) {
+  if (!a.element(e)) return;
+  let t = i;
+  a.boolean(t) || (t = !e.hidden), e.hidden = t;
+}
+function E(e, i, t) {
+  if (a.nodeList(e))
+    return Array.from(e).map((s) => E(s, i, t));
+  if (a.element(e)) {
+    let s = "toggle";
+    return typeof t < "u" && (s = t ? "add" : "remove"), e.classList[s](i), e.classList.contains(i);
+  }
+  return !1;
+}
+function he(e, i) {
+  return a.element(e) && e.classList.contains(i);
+}
+function Y(e, i) {
+  const {
+    prototype: t
+  } = Element;
+  function s() {
+    return Array.from(document.querySelectorAll(i)).includes(this);
+  }
+  return (t.matches || t.webkitMatchesSelector || t.mozMatchesSelector || t.msMatchesSelector || s).call(e, i);
+}
+function Wt(e, i) {
+  const {
+    prototype: t
+  } = Element;
+  function s() {
+    let r = this;
+    do {
+      if (Y.matches(r, i)) return r;
+      r = r.parentElement || r.parentNode;
+    } while (r !== null && r.nodeType === 1);
+    return null;
+  }
+  return (t.closest || s).call(e, i);
+}
+function Z(e) {
+  return this.elements.container.querySelectorAll(e);
+}
+function I(e) {
+  return this.elements.container.querySelector(e);
+}
+function be(e = null, i = !1) {
+  a.element(e) && e.focus({
+    preventScroll: !0,
+    focusVisible: i
+  });
+}
+const He = {
+  "audio/ogg": "vorbis",
+  "audio/wav": "1",
+  "video/webm": "vp8, vorbis",
+  "video/mp4": "avc1.42E01E, mp4a.40.2",
+  "video/ogg": "theora"
+}, $ = {
+  // Basic support
+  audio: "canPlayType" in document.createElement("audio"),
+  video: "canPlayType" in document.createElement("video"),
+  // Check for support
+  // Basic functionality vs full UI
+  check(e, i) {
+    const t = $[e] || i !== "html5", s = t && $.rangeInput;
+    return {
+      api: t,
+      ui: s
+    };
+  },
+  // Picture-in-picture support
+  pip: document.pictureInPictureEnabled && !y("video").disablePictureInPicture,
+  // Airplay support
+  // Safari only currently
+  airplay: a.function(window.WebKitPlaybackTargetAvailabilityEvent),
+  // Inline playback support
+  // https://webkit.org/blog/6784/new-video-policies-for-ios/
+  playsinline: "playsInline" in document.createElement("video"),
+  // Check for mime type support against a player instance
+  // Credits: http://diveintohtml5.info/everything.html
+  // Related: http://www.leanbackplayer.com/test/h5mt.html
+  mime(e) {
+    if (a.empty(e))
+      return !1;
+    const [i] = e.split("/");
+    let t = e;
+    if (!this.isHTML5 || i !== this.type)
+      return !1;
+    Object.keys(He).includes(t) && (t += `; codecs="${He[e]}"`);
+    try {
+      return !!(t && this.media.canPlayType(t).replace(/no/, ""));
+    } catch {
+      return !1;
+    }
+  },
+  // Check for textTracks support
+  textTracks: "textTracks" in document.createElement("video"),
+  // <input type="range"> Sliders
+  rangeInput: (() => {
+    const e = document.createElement("input");
+    return e.type = "range", e.type === "range";
+  })(),
+  // Touch
+  // NOTE: Remember a device can be mouse + touch enabled so we check on first touch event
+  touch: "ontouchstart" in document.documentElement,
+  // Detect transitions support
+  transitions: ke !== !1,
+  // Reduced motion iOS & MacOS setting
+  // https://webkit.org/blog/7551/responsive-design-for-motion/
+  reducedMotion: "matchMedia" in window && window.matchMedia("(prefers-reduced-motion)").matches
+}, zt = (() => {
+  let e = !1;
+  try {
+    const i = Object.defineProperty({}, "passive", {
+      get() {
+        return e = !0, null;
+      }
+    });
+    window.addEventListener("test", null, i), window.removeEventListener("test", null, i);
+  } catch {
+  }
+  return e;
+})();
+function ee(e, i, t, s = !1, n = !0, r = !1) {
+  if (!e || !("addEventListener" in e) || a.empty(i) || !a.function(t))
+    return;
+  const l = i.split(" ");
+  let o = r;
+  zt && (o = {
+    // Whether the listener can be passive (i.e. default never prevented)
+    passive: n,
+    // Whether the listener is a capturing listener or not
+    capture: r
+  }), l.forEach((c) => {
+    this && this.eventListeners && s && this.eventListeners.push({
+      element: e,
+      type: c,
+      callback: t,
+      options: o
+    }), e[s ? "addEventListener" : "removeEventListener"](c, t, o);
+  });
+}
+function T(e, i = "", t, s = !0, n = !1) {
+  ee.call(this, e, i, t, !0, s, n);
+}
+function fe(e, i = "", t, s = !0, n = !1) {
+  ee.call(this, e, i, t, !1, s, n);
+}
+function xe(e, i = "", t, s = !0, n = !1) {
+  const r = (...l) => {
+    fe(e, i, r, s, n), t.apply(this, l);
+  };
+  ee.call(this, e, i, r, !0, s, n);
+}
+function v(e, i = "", t = !1, s = {}) {
+  if (!a.element(e) || a.empty(i))
+    return;
+  const n = new CustomEvent(i, {
+    bubbles: t,
+    detail: {
+      ...s,
+      plyr: this
+    }
+  });
+  e.dispatchEvent(n);
+}
+function Kt() {
+  this && this.eventListeners && (this.eventListeners.forEach((e) => {
+    const {
+      element: i,
+      type: t,
+      callback: s,
+      options: n
+    } = e;
+    i.removeEventListener(t, s, n);
+  }), this.eventListeners = []);
+}
+function Yt() {
+  return new Promise((e) => this.ready ? setTimeout(e, 0) : T.call(this, this.elements.container, "ready", e)).then(() => {
+  });
+}
+function F(e) {
+  a.promise(e) && e.then(null, () => {
+  });
+}
+function Ce(e) {
+  return a.array(e) ? e.filter((i, t) => e.indexOf(i) === t) : e;
+}
+function st(e, i) {
+  return !a.array(e) || !e.length ? null : e.reduce((t, s) => Math.abs(s - i) < Math.abs(t - i) ? s : t);
+}
+function nt(e) {
+  return !window || !window.CSS ? !1 : window.CSS.supports(e);
+}
+const qe = [[1, 1], [4, 3], [3, 4], [5, 4], [4, 5], [3, 2], [2, 3], [16, 10], [10, 16], [16, 9], [9, 16], [21, 9], [9, 21], [32, 9], [9, 32]].reduce((e, [i, t]) => ({
+  ...e,
+  [i / t]: [i, t]
+}), {});
+function rt(e) {
+  return !a.array(e) && (!a.string(e) || !e.includes(":")) ? !1 : (a.array(e) ? e : e.split(":")).map(Number).every(a.number);
+}
+function de(e) {
+  if (!a.array(e) || !e.every(a.number))
+    return null;
+  const [i, t] = e, s = (r, l) => l === 0 ? r : s(l, r % l), n = s(i, t);
+  return [i / n, t / n];
+}
+function Le(e) {
+  const i = (s) => rt(s) ? s.split(":").map(Number) : null;
+  let t = i(e);
+  if (t === null && (t = i(this.config.ratio)), t === null && !a.empty(this.embed) && a.array(this.embed.ratio) && ({
+    ratio: t
+  } = this.embed), t === null && this.isHTML5) {
+    const {
+      videoWidth: s,
+      videoHeight: n
+    } = this.media;
+    t = [s, n];
+  }
+  return de(t);
+}
+function X(e) {
+  if (!this.isVideo)
+    return {};
+  const {
+    wrapper: i
+  } = this.elements, t = Le.call(this, e);
+  if (!a.array(t))
+    return {};
+  const [s, n] = de(t), r = nt(`aspect-ratio: ${s}/${n}`), l = 100 / s * n;
+  if (r ? i.style.aspectRatio = `${s}/${n}` : i.style.paddingBottom = `${l}%`, this.isVimeo && !this.config.vimeo.premium && this.supported.ui) {
+    const o = 100 / this.media.offsetWidth * Number.parseInt(window.getComputedStyle(this.media).paddingBottom, 10), c = (o - l) / (o / 50);
+    this.fullscreen.active ? i.style.paddingBottom = null : this.media.style.transform = `translateY(-${c}%)`;
+  } else this.isHTML5 && i.classList.add(this.config.classNames.videoFixedRatio);
+  return {
+    padding: l,
+    ratio: t
+  };
+}
+function at(e, i, t = 0.05) {
+  const s = e / i, n = st(Object.keys(qe), s);
+  return Math.abs(n - s) <= t ? qe[n] : [e, i];
+}
+function Xt() {
+  const e = Math.max(document.documentElement.clientWidth || 0, window.innerWidth || 0), i = Math.max(document.documentElement.clientHeight || 0, window.innerHeight || 0);
+  return [e, i];
+}
+const z = {
+  getSources() {
+    return this.isHTML5 ? Array.from(this.media.querySelectorAll("source")).filter((i) => {
+      const t = i.getAttribute("type");
+      return a.empty(t) ? !0 : $.mime.call(this, t);
+    }) : [];
+  },
+  // Get quality levels
+  getQualityOptions() {
+    return this.config.quality.forced ? this.config.quality.options : z.getSources.call(this).map((e) => Number(e.getAttribute("size"))).filter(Boolean);
+  },
+  setup() {
+    if (!this.isHTML5)
+      return;
+    const e = this;
+    e.options.speed = e.config.speed.options, a.empty(this.config.ratio) || X.call(e), Object.defineProperty(e.media, "quality", {
+      get() {
+        const t = z.getSources.call(e).find((s) => s.getAttribute("src") === e.source);
+        return t && Number(t.getAttribute("size"));
+      },
+      set(i) {
+        if (e.quality !== i) {
+          if (e.config.quality.forced && a.function(e.config.quality.onChange))
+            e.config.quality.onChange(i);
+          else {
+            const s = z.getSources.call(e).find((u) => Number(u.getAttribute("size")) === i);
+            if (!s)
+              return;
+            const {
+              currentTime: n,
+              paused: r,
+              preload: l,
+              readyState: o,
+              playbackRate: c
+            } = e.media;
+            e.media.src = s.getAttribute("src"), (l !== "none" || o) && (e.once("loadedmetadata", () => {
+              e.speed = c, e.currentTime = n, r || F(e.play());
+            }), e.media.load());
+          }
+          v.call(e, e.media, "qualitychange", !1, {
+            quality: i
+          });
+        }
+      }
+    });
+  },
+  // Cancel current network requests
+  // See https://github.com/sampotts/plyr/issues/174
+  cancelRequests() {
+    this.isHTML5 && (U(z.getSources.call(this)), this.media.setAttribute("src", this.config.blankVideo), this.media.load(), this.debug.log("Cancelled network requests"));
+  }
+}, Qt = !!window.document.documentMode, Jt = /Edge/.test(navigator.userAgent), Gt = "WebkitAppearance" in document.documentElement.style && !/Edge/.test(navigator.userAgent), Zt = navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1, ei = /iPad|iPhone|iPod/i.test(navigator.userAgent) && navigator.maxTouchPoints > 1;
+var _ = {
+  isIE: Qt,
+  isEdge: Jt,
+  isWebKit: Gt,
+  isIPadOS: Zt,
+  isIos: ei
+};
+function ti(e) {
+  return `${e}-${Math.floor(Math.random() * 1e4)}`;
+}
+function Ae(e, ...i) {
+  return a.empty(e) ? e : e.toString().replace(/\{(\d+)\}/g, (t, s) => i[s].toString());
+}
+function ii(e, i) {
+  return e === 0 || i === 0 || Number.isNaN(e) || Number.isNaN(i) ? 0 : (e / i * 100).toFixed(2);
+}
+function G(e = "", i = "", t = "") {
+  return e.replace(new RegExp(i.toString().replace(/([.*+?^=!:${}()|[\]/\\])/g, "\\$1"), "g"), t.toString());
+}
+function lt(e = "") {
+  return e.toString().replace(/\w\S*/g, (i) => i.charAt(0).toUpperCase() + i.slice(1).toLowerCase());
+}
+function si(e = "") {
+  let i = e.toString();
+  return i = G(i, "-", " "), i = G(i, "_", " "), i = lt(i), G(i, " ", "");
+}
+function ni(e = "") {
+  let i = e.toString();
+  return i = si(i), i.charAt(0).toLowerCase() + i.slice(1);
+}
+function ri(e) {
+  const i = document.createDocumentFragment(), t = document.createElement("div");
+  return i.appendChild(t), t.innerHTML = e, i.firstChild.textContent;
+}
+function ai(e) {
+  const i = document.createElement("div");
+  return i.appendChild(e), i.innerHTML;
+}
+const Ve = {
+  pip: "PIP",
+  airplay: "AirPlay",
+  html5: "HTML5",
+  vimeo: "Vimeo",
+  youtube: "YouTube"
+}, O = {
+  get(e = "", i = {}) {
+    if (a.empty(e) || a.empty(i))
+      return "";
+    let t = tt(i.i18n, e);
+    if (a.empty(t))
+      return Object.keys(Ve).includes(e) ? Ve[e] : "";
+    const s = {
+      "{seektime}": i.seekTime,
+      "{title}": i.title
+    };
+    return Object.entries(s).forEach(([n, r]) => {
+      t = G(t, n, r);
+    }), t;
+  }
+};
+class te {
+  constructor(i) {
+    m(this, "get", (t) => {
+      if (!te.supported || !this.enabled)
+        return null;
+      const s = window.localStorage.getItem(this.key);
+      if (a.empty(s)) return null;
+      const n = JSON.parse(s);
+      return a.string(t) && t.length ? n[t] : n;
+    }), m(this, "set", (t) => {
+      if (!te.supported || !this.enabled || !a.object(t))
+        return;
+      let s = this.get();
+      a.empty(s) && (s = {}), L(s, t);
+      try {
+        window.localStorage.setItem(this.key, JSON.stringify(s));
+      } catch {
+      }
+    }), this.enabled = i.config.storage.enabled, this.key = i.config.storage.key;
+  }
+  // Check for actual support (see if we can use it)
+  static get supported() {
+    try {
+      if (!("localStorage" in window)) return !1;
+      const i = "___test";
+      return window.localStorage.setItem(i, i), window.localStorage.removeItem(i), !0;
+    } catch {
+      return !1;
+    }
+  }
+}
+function ne(e, i = "text", t = !1) {
+  return new Promise((s, n) => {
+    try {
+      const r = new XMLHttpRequest();
+      if (!("withCredentials" in r)) return;
+      t && (r.withCredentials = !0), r.addEventListener("load", () => {
+        if (i === "text")
+          try {
+            s(JSON.parse(r.responseText));
+          } catch {
+            s(r.responseText);
+          }
+        else
+          s(r.response);
+      }), r.addEventListener("error", () => {
+        throw new Error(r.status);
+      }), r.open("GET", e, !0), r.responseType = i, r.send();
+    } catch (r) {
+      n(r);
+    }
+  });
+}
+function ot(e, i) {
+  if (!a.string(e))
+    return;
+  const t = "cache", s = a.string(i);
+  let n = !1;
+  const r = () => document.getElementById(i) !== null, l = (o, c) => {
+    o.innerHTML = c, !(s && r()) && document.body.insertAdjacentElement("afterbegin", o);
+  };
+  if (!s || !r()) {
+    const o = te.supported, c = document.createElement("div");
+    if (c.setAttribute("hidden", ""), s && c.setAttribute("id", i), o) {
+      const u = window.localStorage.getItem(`${t}-${i}`);
+      if (n = u !== null, n) {
+        const p = JSON.parse(u);
+        l(c, p.content);
+      }
+    }
+    ne(e).then((u) => {
+      if (!a.empty(u)) {
+        if (o)
+          try {
+            window.localStorage.setItem(`${t}-${i}`, JSON.stringify({
+              content: u
+            }));
+          } catch {
+          }
+        l(c, u);
+      }
+    }).catch(() => {
+    });
+  }
+}
+const ct = (e) => Math.trunc(e / 60 / 60 % 60, 10), li = (e) => Math.trunc(e / 60 % 60, 10), oi = (e) => Math.trunc(e % 60, 10);
+function ge(e = 0, i = !1, t = !1) {
+  if (!a.number(e))
+    return ge(void 0, i, t);
+  const s = (o) => `0${o}`.slice(-2);
+  let n = ct(e);
+  const r = li(e), l = oi(e);
+  return i || n > 0 ? n = `${n}:` : n = "", `${t && e > 0 ? "-" : ""}${n}${s(r)}:${s(l)}`;
+}
+const d = {
+  // Get icon URL
+  getIconUrl() {
+    const e = new URL(this.config.iconUrl, window.location), i = window.location.host ? window.location.host : window.top.location.host, t = e.host !== i || _.isIE && !window.svg4everybody;
+    return {
+      url: this.config.iconUrl,
+      cors: t
+    };
+  },
+  // Find the UI controls
+  findElements() {
+    try {
+      return this.elements.controls = I.call(this, this.config.selectors.controls.wrapper), this.elements.buttons = {
+        play: Z.call(this, this.config.selectors.buttons.play),
+        pause: I.call(this, this.config.selectors.buttons.pause),
+        restart: I.call(this, this.config.selectors.buttons.restart),
+        rewind: I.call(this, this.config.selectors.buttons.rewind),
+        fastForward: I.call(this, this.config.selectors.buttons.fastForward),
+        mute: I.call(this, this.config.selectors.buttons.mute),
+        pip: I.call(this, this.config.selectors.buttons.pip),
+        airplay: I.call(this, this.config.selectors.buttons.airplay),
+        settings: I.call(this, this.config.selectors.buttons.settings),
+        captions: I.call(this, this.config.selectors.buttons.captions),
+        fullscreen: I.call(this, this.config.selectors.buttons.fullscreen)
+      }, this.elements.progress = I.call(this, this.config.selectors.progress), this.elements.inputs = {
+        seek: I.call(this, this.config.selectors.inputs.seek),
+        volume: I.call(this, this.config.selectors.inputs.volume)
+      }, this.elements.display = {
+        buffer: I.call(this, this.config.selectors.display.buffer),
+        currentTime: I.call(this, this.config.selectors.display.currentTime),
+        duration: I.call(this, this.config.selectors.display.duration)
+      }, a.element(this.elements.progress) && (this.elements.display.seekTooltip = this.elements.progress.querySelector(`.${this.config.classNames.tooltip}`)), !0;
+    } catch (e) {
+      return this.debug.warn("It looks like there is a problem with your custom controls HTML", e), this.toggleNativeControls(!0), !1;
+    }
+  },
+  // Create <svg> icon
+  createIcon(e, i) {
+    const t = "http://www.w3.org/2000/svg", s = d.getIconUrl.call(this), n = `${s.cors ? "" : s.url}#${this.config.iconPrefix}`, r = document.createElementNS(t, "svg");
+    Te(r, L(i, {
+      "aria-hidden": "true",
+      focusable: "false"
+    }));
+    const l = document.createElementNS(t, "use"), o = `${n}-${e}`;
+    return "href" in l && l.setAttributeNS("http://www.w3.org/1999/xlink", "href", o), l.setAttributeNS("http://www.w3.org/1999/xlink", "xlink:href", o), r.appendChild(l), r;
+  },
+  // Create hidden text label
+  createLabel(e, i = {}) {
+    const t = O.get(e, this.config), s = {
+      ...i,
+      class: [i.class, this.config.classNames.hidden].filter(Boolean).join(" ")
+    };
+    return y("span", s, t);
+  },
+  // Create a badge
+  createBadge(e) {
+    if (a.empty(e))
+      return null;
+    const i = y("span", {
+      class: this.config.classNames.menu.value
+    });
+    return i.appendChild(y("span", {
+      class: this.config.classNames.menu.badge
+    }, e)), i;
+  },
+  // Create a <button>
+  createButton(e, i) {
+    const t = L({}, i);
+    let s = ni(e);
+    const n = {
+      element: "button",
+      toggle: !1,
+      label: null,
+      icon: null,
+      labelPressed: null,
+      iconPressed: null
+    };
+    switch (["element", "icon", "label"].forEach((l) => {
+      Object.keys(t).includes(l) && (n[l] = t[l], delete t[l]);
+    }), n.element === "button" && !Object.keys(t).includes("type") && (t.type = "button"), Object.keys(t).includes("class") ? t.class.split(" ").includes(this.config.classNames.control) || L(t, {
+      class: `${t.class} ${this.config.classNames.control}`
+    }) : t.class = this.config.classNames.control, e) {
+      case "play":
+        n.toggle = !0, n.label = "play", n.labelPressed = "pause", n.icon = "play", n.iconPressed = "pause";
+        break;
+      case "mute":
+        n.toggle = !0, n.label = "mute", n.labelPressed = "unmute", n.icon = "volume", n.iconPressed = "muted";
+        break;
+      case "captions":
+        n.toggle = !0, n.label = "enableCaptions", n.labelPressed = "disableCaptions", n.icon = "captions-off", n.iconPressed = "captions-on";
+        break;
+      case "fullscreen":
+        n.toggle = !0, n.label = "enterFullscreen", n.labelPressed = "exitFullscreen", n.icon = "enter-fullscreen", n.iconPressed = "exit-fullscreen";
+        break;
+      case "play-large":
+        t.class += ` ${this.config.classNames.control}--overlaid`, s = "play", n.label = "play", n.icon = "play";
+        break;
+      default:
+        a.empty(n.label) && (n.label = s), a.empty(n.icon) && (n.icon = e);
+    }
+    const r = y(n.element);
+    return n.toggle ? (r.appendChild(d.createIcon.call(this, n.iconPressed, {
+      class: "icon--pressed"
+    })), r.appendChild(d.createIcon.call(this, n.icon, {
+      class: "icon--not-pressed"
+    })), r.appendChild(d.createLabel.call(this, n.labelPressed, {
+      class: "label--pressed"
+    })), r.appendChild(d.createLabel.call(this, n.label, {
+      class: "label--not-pressed"
+    }))) : (r.appendChild(d.createIcon.call(this, n.icon)), r.appendChild(d.createLabel.call(this, n.label))), L(t, V(this.config.selectors.buttons[s], t)), Te(r, t), s === "play" ? (a.array(this.elements.buttons[s]) || (this.elements.buttons[s] = []), this.elements.buttons[s].push(r)) : this.elements.buttons[s] = r, r;
+  },
+  // Create an <input type='range'>
+  createRange(e, i) {
+    const t = y("input", L(V(this.config.selectors.inputs[e]), {
+      type: "range",
+      min: 0,
+      max: 100,
+      step: 0.01,
+      value: 0,
+      autocomplete: "off",
+      // A11y fixes for https://github.com/sampotts/plyr/issues/905
+      role: "slider",
+      "aria-label": O.get(e, this.config),
+      "aria-valuemin": 0,
+      "aria-valuemax": 100,
+      "aria-valuenow": 0
+    }, i));
+    return this.elements.inputs[e] = t, d.updateRangeFill.call(this, t), Lt.setup(t), t;
+  },
+  // Create a <progress>
+  createProgress(e, i) {
+    const t = y("progress", L(V(this.config.selectors.display[e]), {
+      min: 0,
+      max: 100,
+      value: 0,
+      role: "progressbar",
+      "aria-hidden": !0
+    }, i));
+    if (e !== "volume") {
+      t.appendChild(y("span", null, "0"));
+      const s = {
+        played: "played",
+        buffer: "buffered"
+      }[e], n = s ? O.get(s, this.config) : "";
+      t.textContent = `% ${n.toLowerCase()}`;
+    }
+    return this.elements.display[e] = t, t;
+  },
+  // Create time display
+  createTime(e, i) {
+    const t = V(this.config.selectors.display[e], i), s = y("div", L(t, {
+      class: `${t.class ? t.class : ""} ${this.config.classNames.display.time} `.trim(),
+      "aria-label": O.get(e, this.config),
+      role: "timer"
+    }), "00:00");
+    return this.elements.display[e] = s, s;
+  },
+  // Bind keyboard shortcuts for a menu item
+  // We have to bind to keyup otherwise Firefox triggers a click when a keydown event handler shifts focus
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=1220143
+  bindMenuItemShortcuts(e, i) {
+    T.call(this, e, "keydown keyup", (t) => {
+      if (![" ", "ArrowUp", "ArrowDown", "ArrowRight"].includes(t.key) || (t.preventDefault(), t.stopPropagation(), t.type === "keydown"))
+        return;
+      const s = Y(e, '[role="menuitemradio"]');
+      if (!s && [" ", "ArrowRight"].includes(t.key))
+        d.showMenuPanel.call(this, i, !0);
+      else {
+        let n;
+        t.key !== " " && (t.key === "ArrowDown" || s && t.key === "ArrowRight" ? (n = e.nextElementSibling, a.element(n) || (n = e.parentNode.firstElementChild)) : (n = e.previousElementSibling, a.element(n) || (n = e.parentNode.lastElementChild)), be.call(this, n, !0));
+      }
+    }, !1), T.call(this, e, "keyup", (t) => {
+      t.key === "Return" && d.focusFirstMenuItem.call(this, null, !0);
+    });
+  },
+  // Create a settings menu item
+  createMenuItem({
+    value: e,
+    list: i,
+    type: t,
+    title: s,
+    badge: n = null,
+    checked: r = !1
+  }) {
+    const l = V(this.config.selectors.inputs[t]), o = y("button", L(l, {
+      type: "button",
+      role: "menuitemradio",
+      class: `${this.config.classNames.control} ${l.class ? l.class : ""}`.trim(),
+      "aria-checked": r,
+      value: e
+    })), c = y("span");
+    c.innerHTML = s, a.element(n) && c.appendChild(n), o.appendChild(c), Object.defineProperty(o, "checked", {
+      enumerable: !0,
+      get() {
+        return o.getAttribute("aria-checked") === "true";
+      },
+      set(u) {
+        u && Array.from(o.parentNode.children).filter((p) => Y(p, '[role="menuitemradio"]')).forEach((p) => p.setAttribute("aria-checked", "false")), o.setAttribute("aria-checked", u ? "true" : "false");
+      }
+    }), this.listeners.bind(o, "click keyup", (u) => {
+      if (!(a.keyboardEvent(u) && u.key !== " ")) {
+        switch (u.preventDefault(), u.stopPropagation(), o.checked = !0, t) {
+          case "language":
+            this.currentTrack = Number(e);
+            break;
+          case "quality":
+            this.quality = e;
+            break;
+          case "speed":
+            this.speed = Number.parseFloat(e);
+            break;
+        }
+        d.showMenuPanel.call(this, "home", a.keyboardEvent(u));
+      }
+    }, t, !1), d.bindMenuItemShortcuts.call(this, o, t), i.appendChild(o);
+  },
+  // Format a time for display
+  formatTime(e = 0, i = !1) {
+    if (!a.number(e))
+      return e;
+    const t = ct(this.duration) > 0;
+    return ge(e, t, i);
+  },
+  // Update the displayed time
+  updateTimeDisplay(e = null, i = 0, t = !1) {
+    !a.element(e) || !a.number(i) || (e.textContent = d.formatTime(i, t));
+  },
+  // Update volume UI and storage
+  updateVolume() {
+    this.supported.ui && (a.element(this.elements.inputs.volume) && d.setRange.call(this, this.elements.inputs.volume, this.muted ? 0 : this.volume), a.element(this.elements.buttons.mute) && (this.elements.buttons.mute.pressed = this.muted || this.volume === 0));
+  },
+  // Update seek value and lower fill
+  setRange(e, i = 0) {
+    a.element(e) && (e.value = i, d.updateRangeFill.call(this, e));
+  },
+  // Update <progress> elements
+  updateProgress(e) {
+    if (!this.supported.ui || !a.event(e))
+      return;
+    let i = 0;
+    const t = (s, n) => {
+      const r = a.number(n) ? n : 0, l = a.element(s) ? s : this.elements.display.buffer;
+      if (a.element(l)) {
+        l.value = r;
+        const o = l.getElementsByTagName("span")[0];
+        a.element(o) && (o.childNodes[0].nodeValue = r);
+      }
+    };
+    if (e)
+      switch (e.type) {
+        // Video playing
+        case "timeupdate":
+        case "seeking":
+        case "seeked":
+          i = ii(this.currentTime, this.duration), e.type === "timeupdate" && d.setRange.call(this, this.elements.inputs.seek, i);
+          break;
+        // Check buffer status
+        case "playing":
+        case "progress":
+          t(this.elements.display.buffer, this.buffered * 100);
+          break;
+      }
+  },
+  // Webkit polyfill for lower fill range
+  updateRangeFill(e) {
+    const i = a.event(e) ? e.target : e;
+    if (!(!a.element(i) || i.getAttribute("type") !== "range")) {
+      if (Y(i, this.config.selectors.inputs.seek)) {
+        i.setAttribute("aria-valuenow", this.currentTime);
+        const t = d.formatTime(this.currentTime), s = d.formatTime(this.duration), n = O.get("seekLabel", this.config);
+        i.setAttribute("aria-valuetext", n.replace("{currentTime}", t).replace("{duration}", s));
+      } else if (Y(i, this.config.selectors.inputs.volume)) {
+        const t = i.value * 100;
+        i.setAttribute("aria-valuenow", t), i.setAttribute("aria-valuetext", `${t.toFixed(1)}%`);
+      } else
+        i.setAttribute("aria-valuenow", i.value);
+      !_.isWebKit && !_.isIPadOS || i.style.setProperty("--value", `${i.value / i.max * 100}%`);
+    }
+  },
+  // Update hover tooltip for seeking
+  updateSeekTooltip(e) {
+    var i, t;
+    if (!this.config.tooltips.seek || !a.element(this.elements.inputs.seek) || !a.element(this.elements.display.seekTooltip) || this.duration === 0)
+      return;
+    const s = this.elements.display.seekTooltip, n = `${this.config.classNames.tooltip}--visible`, r = (p) => E(s, n, p);
+    if (this.touch) {
+      r(!1);
+      return;
+    }
+    let l = 0;
+    const o = this.elements.progress.getBoundingClientRect();
+    if (a.event(e)) {
+      const p = e.pageX - e.clientX;
+      l = 100 / o.width * (e.pageX - o.left - p);
+    } else if (he(s, n))
+      l = Number.parseFloat(s.style.left, 10);
+    else
+      return;
+    l < 0 ? l = 0 : l > 100 && (l = 100);
+    const c = this.duration / 100 * l;
+    s.textContent = d.formatTime(c);
+    const u = (i = this.config.markers) === null || i === void 0 || (t = i.points) === null || t === void 0 ? void 0 : t.find(({
+      time: p
+    }) => p === Math.round(c));
+    u && s.insertAdjacentHTML("afterbegin", `${u.label}<br>`), s.style.left = `${l}%`, a.event(e) && ["mouseenter", "mouseleave"].includes(e.type) && r(e.type === "mouseenter");
+  },
+  // Handle time change event
+  timeUpdate(e) {
+    const i = !a.element(this.elements.display.duration) && this.config.invertTime;
+    d.updateTimeDisplay.call(this, this.elements.display.currentTime, i ? this.duration - this.currentTime : this.currentTime, i), !(e && e.type === "timeupdate" && this.media.seeking) && d.updateProgress.call(this, e);
+  },
+  // Show the duration on metadataloaded or durationchange events
+  durationUpdate() {
+    if (!this.supported.ui || !this.config.invertTime && this.currentTime)
+      return;
+    if (this.duration >= 2 ** 32) {
+      K(this.elements.display.currentTime, !0), K(this.elements.progress, !0);
+      return;
+    }
+    a.element(this.elements.inputs.seek) && this.elements.inputs.seek.setAttribute("aria-valuemax", this.duration);
+    const e = a.element(this.elements.display.duration);
+    !e && this.config.displayDuration && this.paused && d.updateTimeDisplay.call(this, this.elements.display.currentTime, this.duration), e && d.updateTimeDisplay.call(this, this.elements.display.duration, this.duration), this.config.markers.enabled && d.setMarkers.call(this), d.updateSeekTooltip.call(this);
+  },
+  // Hide/show a tab
+  toggleMenuButton(e, i) {
+    K(this.elements.settings.buttons[e], !i);
+  },
+  // Update the selected setting
+  updateSetting(e, i, t) {
+    const s = this.elements.settings.panels[e];
+    let n = null, r = i;
+    if (e === "captions")
+      n = this.currentTrack;
+    else {
+      if (n = a.empty(t) ? this[e] : t, a.empty(n) && (n = this.config[e].default), !a.empty(this.options[e]) && !this.options[e].includes(n)) {
+        this.debug.warn(`Unsupported value of '${n}' for ${e}`);
+        return;
+      }
+      if (!this.config[e].options.includes(n)) {
+        this.debug.warn(`Disabled value of '${n}' for ${e}`);
+        return;
+      }
+    }
+    if (a.element(r) || (r = s && s.querySelector('[role="menu"]')), !a.element(r))
+      return;
+    const l = this.elements.settings.buttons[e].querySelector(`.${this.config.classNames.menu.value}`);
+    l.innerHTML = d.getLabel.call(this, e, n);
+    const o = r && r.querySelector(`[value="${n}"]`);
+    a.element(o) && (o.checked = !0);
+  },
+  // Translate a value into a nice label
+  getLabel(e, i) {
+    switch (e) {
+      case "speed":
+        return i === 1 ? O.get("normal", this.config) : `${i}&times;`;
+      case "quality":
+        if (a.number(i)) {
+          const t = O.get(`qualityLabel.${i}`, this.config);
+          return t.length ? t : `${i}p`;
+        }
+        return lt(i);
+      case "captions":
+        return A.getLabel.call(this);
+      default:
+        return null;
+    }
+  },
+  // Set the quality menu
+  setQualityMenu(e) {
+    if (!a.element(this.elements.settings.panels.quality))
+      return;
+    const i = "quality", t = this.elements.settings.panels.quality.querySelector('[role="menu"]');
+    a.array(e) && (this.options.quality = Ce(e).filter((r) => this.config.quality.options.includes(r)));
+    const s = !a.empty(this.options.quality) && this.options.quality.length > 1;
+    if (d.toggleMenuButton.call(this, i, s), ae(t), d.checkMenu.call(this), !s)
+      return;
+    const n = (r) => {
+      const l = O.get(`qualityBadge.${r}`, this.config);
+      return l.length ? d.createBadge.call(this, l) : null;
+    };
+    this.options.quality.sort((r, l) => {
+      const o = this.config.quality.options;
+      return o.indexOf(r) > o.indexOf(l) ? 1 : -1;
+    }).forEach((r) => {
+      d.createMenuItem.call(this, {
+        value: r,
+        list: t,
+        type: i,
+        title: d.getLabel.call(this, "quality", r),
+        badge: n(r)
+      });
+    }), d.updateSetting.call(this, i, t);
+  },
+  // Set the looping options
+  /* setLoopMenu() {
+        // Menu required
+        if (!is.element(this.elements.settings.panels.loop)) {
+            return;
+        }
+         const options = ['start', 'end', 'all', 'reset'];
+        const list = this.elements.settings.panels.loop.querySelector('[role="menu"]');
+         // Show the pane and tab
+        toggleHidden(this.elements.settings.buttons.loop, false);
+        toggleHidden(this.elements.settings.panels.loop, false);
+         // Toggle the pane and tab
+        const toggle = !is.empty(this.loop.options);
+        controls.toggleMenuButton.call(this, 'loop', toggle);
+         // Empty the menu
+        emptyElement(list);
+         options.forEach(option => {
+            const item = createElement('li');
+             const button = createElement(
+                'button',
+                extend(getAttributesFromSelector(this.config.selectors.buttons.loop), {
+                    type: 'button',
+                    class: this.config.classNames.control,
+                    'data-plyr-loop-action': option,
+                }),
+                i18n.get(option, this.config)
+            );
+             if (['start', 'end'].includes(option)) {
+                const badge = controls.createBadge.call(this, '00:00');
+                button.appendChild(badge);
+            }
+             item.appendChild(button);
+            list.appendChild(item);
+        });
+    }, */
+  // Get current selected caption language
+  // TODO: rework this to user the getter in the API?
+  // Set a list of available captions languages
+  setCaptionsMenu() {
+    if (!a.element(this.elements.settings.panels.captions))
+      return;
+    const e = "captions", i = this.elements.settings.panels.captions.querySelector('[role="menu"]'), t = A.getTracks.call(this), s = !!t.length;
+    if (d.toggleMenuButton.call(this, e, s), ae(i), d.checkMenu.call(this), !s)
+      return;
+    const n = t.map((r, l) => ({
+      value: l,
+      checked: this.captions.toggled && this.currentTrack === l,
+      title: A.getLabel.call(this, r),
+      badge: r.language && d.createBadge.call(this, r.language.toUpperCase()),
+      list: i,
+      type: "language"
+    }));
+    n.unshift({
+      value: -1,
+      checked: !this.captions.toggled,
+      title: O.get("disabled", this.config),
+      list: i,
+      type: "language"
+    }), n.forEach(d.createMenuItem.bind(this)), d.updateSetting.call(this, e, i);
+  },
+  // Set a list of available captions languages
+  setSpeedMenu() {
+    if (!a.element(this.elements.settings.panels.speed))
+      return;
+    const e = "speed", i = this.elements.settings.panels.speed.querySelector('[role="menu"]');
+    this.options.speed = this.options.speed.filter((s) => s >= this.minimumSpeed && s <= this.maximumSpeed);
+    const t = !a.empty(this.options.speed) && this.options.speed.length > 1;
+    d.toggleMenuButton.call(this, e, t), ae(i), d.checkMenu.call(this), t && (this.options.speed.forEach((s) => {
+      d.createMenuItem.call(this, {
+        value: s,
+        list: i,
+        type: e,
+        title: d.getLabel.call(this, "speed", s)
+      });
+    }), d.updateSetting.call(this, e, i));
+  },
+  // Check if we need to hide/show the settings menu
+  checkMenu() {
+    const {
+      buttons: e
+    } = this.elements.settings, i = !a.empty(e) && Object.values(e).some((t) => !t.hidden);
+    K(this.elements.settings.menu, !i);
+  },
+  // Focus the first menu item in a given (or visible) menu
+  focusFirstMenuItem(e, i = !1) {
+    if (this.elements.settings.popup.hidden)
+      return;
+    let t = e;
+    a.element(t) || (t = Object.values(this.elements.settings.panels).find((n) => !n.hidden));
+    const s = t.querySelector('[role^="menuitem"]');
+    be.call(this, s, i);
+  },
+  // Show/hide menu
+  toggleMenu(e) {
+    const {
+      popup: i
+    } = this.elements.settings, t = this.elements.buttons.settings;
+    if (!a.element(i) || !a.element(t))
+      return;
+    const {
+      hidden: s
+    } = i;
+    let n = s;
+    if (a.boolean(e))
+      n = e;
+    else if (a.keyboardEvent(e) && e.key === "Escape")
+      n = !1;
+    else if (a.event(e)) {
+      const r = a.function(e.composedPath) ? e.composedPath()[0] : e.target, l = i.contains(r);
+      if (l || !l && e.target !== t && n)
+        return;
+    }
+    t.setAttribute("aria-expanded", n), K(i, !n), E(this.elements.container, this.config.classNames.menu.open, n), n && a.keyboardEvent(e) ? d.focusFirstMenuItem.call(this, null, !0) : !n && !s && be.call(this, t, a.keyboardEvent(e));
+  },
+  // Get the natural size of a menu panel
+  getMenuSize(e) {
+    const i = e.cloneNode(!0);
+    i.style.position = "absolute", i.style.opacity = 0, i.removeAttribute("hidden"), e.parentNode.appendChild(i);
+    const t = i.scrollWidth, s = i.scrollHeight;
+    return U(i), {
+      width: t,
+      height: s
+    };
+  },
+  // Show a panel in the menu
+  showMenuPanel(e = "", i = !1) {
+    const t = this.elements.container.querySelector(`#plyr-settings-${this.id}-${e}`);
+    if (!a.element(t))
+      return;
+    const s = t.parentNode, n = Array.from(s.children).find((r) => !r.hidden);
+    if ($.transitions && !$.reducedMotion) {
+      s.style.width = `${n.scrollWidth}px`, s.style.height = `${n.scrollHeight}px`;
+      const r = d.getMenuSize.call(this, t), l = (o) => {
+        o.target !== s || !["width", "height"].includes(o.propertyName) || (s.style.width = "", s.style.height = "", fe.call(this, s, ke, l));
+      };
+      T.call(this, s, ke, l), s.style.width = `${r.width}px`, s.style.height = `${r.height}px`;
+    }
+    K(n, !0), K(t, !1), d.focusFirstMenuItem.call(this, t, i);
+  },
+  // Set the download URL
+  setDownloadUrl() {
+    const e = this.elements.buttons.download;
+    a.element(e) && e.setAttribute("href", this.download);
+  },
+  // Build the default HTML
+  create(e) {
+    const {
+      bindMenuItemShortcuts: i,
+      createButton: t,
+      createProgress: s,
+      createRange: n,
+      createTime: r,
+      setQualityMenu: l,
+      setSpeedMenu: o,
+      showMenuPanel: c
+    } = d;
+    this.elements.controls = null, a.array(this.config.controls) && this.config.controls.includes("play-large") && this.elements.container.appendChild(t.call(this, "play-large"));
+    const u = y("div", V(this.config.selectors.controls.wrapper));
+    this.elements.controls = u;
+    const p = {
+      class: "plyr__controls__item"
+    };
+    return Ce(a.array(this.config.controls) ? this.config.controls : []).forEach((b) => {
+      if (b === "restart" && u.appendChild(t.call(this, "restart", p)), b === "rewind" && u.appendChild(t.call(this, "rewind", p)), b === "play" && u.appendChild(t.call(this, "play", p)), b === "fast-forward" && u.appendChild(t.call(this, "fast-forward", p)), b === "progress") {
+        const h = y("div", {
+          class: `${p.class} plyr__progress__container`
+        }), g = y("div", V(this.config.selectors.progress));
+        if (g.appendChild(n.call(this, "seek", {
+          id: `plyr-seek-${e.id}`
+        })), g.appendChild(s.call(this, "buffer")), this.config.tooltips.seek) {
+          const C = y("span", {
+            class: this.config.classNames.tooltip
+          }, "00:00");
+          g.appendChild(C), this.elements.display.seekTooltip = C;
+        }
+        this.elements.progress = g, h.appendChild(this.elements.progress), u.appendChild(h);
+      }
+      if (b === "current-time" && u.appendChild(r.call(this, "currentTime", p)), b === "duration" && u.appendChild(r.call(this, "duration", p)), b === "mute" || b === "volume") {
+        let {
+          volume: h
+        } = this.elements;
+        if ((!a.element(h) || !u.contains(h)) && (h = y("div", L({}, p, {
+          class: `${p.class} plyr__volume`.trim()
+        })), this.elements.volume = h, u.appendChild(h)), b === "mute" && h.appendChild(t.call(this, "mute")), b === "volume" && !_.isIos && !_.isIPadOS) {
+          const g = {
+            max: 1,
+            step: 0.05,
+            value: this.config.volume
+          };
+          h.appendChild(n.call(this, "volume", L(g, {
+            id: `plyr-volume-${e.id}`
+          })));
+        }
+      }
+      if (b === "captions" && u.appendChild(t.call(this, "captions", p)), b === "settings" && !a.empty(this.config.settings)) {
+        const h = y("div", L({}, p, {
+          class: `${p.class} plyr__menu`.trim(),
+          hidden: ""
+        }));
+        h.appendChild(t.call(this, "settings", {
+          "aria-haspopup": !0,
+          "aria-controls": `plyr-settings-${e.id}`,
+          "aria-expanded": !1
+        }));
+        const g = y("div", {
+          class: "plyr__menu__container",
+          id: `plyr-settings-${e.id}`,
+          hidden: ""
+        }), C = y("div"), w = y("div", {
+          id: `plyr-settings-${e.id}-home`
+        }), x = y("div", {
+          role: "menu"
+        });
+        w.appendChild(x), C.appendChild(w), this.elements.settings.panels.home = w, this.config.settings.forEach((P) => {
+          const f = y("button", L(V(this.config.selectors.buttons.settings), {
+            type: "button",
+            class: `${this.config.classNames.control} ${this.config.classNames.control}--forward`,
+            role: "menuitem",
+            "aria-haspopup": !0,
+            hidden: ""
+          }));
+          i.call(this, f, P), T.call(this, f, "click", () => {
+            c.call(this, P, !1);
+          });
+          const k = y("span", null, O.get(P, this.config)), M = y("span", {
+            class: this.config.classNames.menu.value
+          });
+          M.innerHTML = e[P], k.appendChild(M), f.appendChild(k), x.appendChild(f);
+          const j = y("div", {
+            id: `plyr-settings-${e.id}-${P}`,
+            hidden: ""
+          }), R = y("button", {
+            type: "button",
+            class: `${this.config.classNames.control} ${this.config.classNames.control}--back`
+          });
+          R.appendChild(y("span", {
+            "aria-hidden": !0
+          }, O.get(P, this.config))), R.appendChild(y("span", {
+            class: this.config.classNames.hidden
+          }, O.get("menuBack", this.config))), T.call(this, j, "keydown", (H) => {
+            H.key === "ArrowLeft" && (H.preventDefault(), H.stopPropagation(), c.call(this, "home", !0));
+          }, !1), T.call(this, R, "click", () => {
+            c.call(this, "home", !1);
+          }), j.appendChild(R), j.appendChild(y("div", {
+            role: "menu"
+          })), C.appendChild(j), this.elements.settings.buttons[P] = f, this.elements.settings.panels[P] = j;
+        }), g.appendChild(C), h.appendChild(g), u.appendChild(h), this.elements.settings.popup = g, this.elements.settings.menu = h;
+      }
+      if (b === "pip" && $.pip && u.appendChild(t.call(this, "pip", p)), b === "airplay" && $.airplay && u.appendChild(t.call(this, "airplay", p)), b === "download") {
+        const h = L({}, p, {
+          element: "a",
+          href: this.download,
+          target: "_blank"
+        });
+        this.isHTML5 && (h.download = "");
+        const {
+          download: g
+        } = this.config.urls;
+        !a.url(g) && this.isEmbed && L(h, {
+          icon: `logo-${this.provider}`,
+          label: this.provider
+        }), u.appendChild(t.call(this, "download", h));
+      }
+      b === "fullscreen" && u.appendChild(t.call(this, "fullscreen", p));
+    }), this.isHTML5 && l.call(this, z.getQualityOptions.call(this)), o.call(this), u;
+  },
+  // Insert controls
+  inject() {
+    if (this.config.loadSprite) {
+      const l = d.getIconUrl.call(this);
+      l.cors && ot(l.url, "sprite-plyr");
+    }
+    this.id = Math.floor(Math.random() * 1e4);
+    let e = null;
+    this.elements.controls = null;
+    const i = {
+      id: this.id,
+      seektime: this.config.seekTime,
+      title: this.config.title
+    };
+    let t = !0;
+    a.function(this.config.controls) && (this.config.controls = this.config.controls.call(this, i)), this.config.controls || (this.config.controls = []), a.element(this.config.controls) || a.string(this.config.controls) ? e = this.config.controls : (e = d.create.call(this, {
+      id: this.id,
+      seektime: this.config.seekTime,
+      speed: this.speed,
+      quality: this.quality,
+      captions: A.getLabel.call(this)
+      // TODO: Looping
+      // loop: 'None',
+    }), t = !1);
+    const s = (l) => {
+      let o = l;
+      return Object.entries(i).forEach(([c, u]) => {
+        o = G(o, `{${c}}`, u);
+      }), o;
+    };
+    t && a.string(this.config.controls) && (e = s(e));
+    let n;
+    a.string(this.config.selectors.controls.container) && (n = document.querySelector(this.config.selectors.controls.container)), a.element(n) || (n = this.elements.container);
+    const r = a.element(e) ? "insertAdjacentElement" : "insertAdjacentHTML";
+    if (n[r]("afterbegin", e), a.element(this.elements.controls) || d.findElements.call(this), !a.empty(this.elements.buttons)) {
+      const l = (o) => {
+        const c = this.config.classNames.controlPressed;
+        o.setAttribute("aria-pressed", "false"), Object.defineProperty(o, "pressed", {
+          configurable: !0,
+          enumerable: !0,
+          get() {
+            return he(o, c);
+          },
+          set(u = !1) {
+            E(o, c, u), o.setAttribute("aria-pressed", u ? "true" : "false");
+          }
+        });
+      };
+      Object.values(this.elements.buttons).filter(Boolean).forEach((o) => {
+        a.array(o) || a.nodeList(o) ? Array.from(o).filter(Boolean).forEach(l) : l(o);
+      });
+    }
+    if (_.isEdge && et(n), this.config.tooltips.controls) {
+      const {
+        classNames: l,
+        selectors: o
+      } = this.config, c = `${o.controls.wrapper} ${o.labels} .${l.hidden}`, u = Z.call(this, c);
+      Array.from(u).forEach((p) => {
+        E(p, this.config.classNames.hidden, !1), E(p, this.config.classNames.tooltip, !0);
+      });
+    }
+  },
+  // Set media metadata
+  setMediaMetadata() {
+    try {
+      "mediaSession" in navigator && (navigator.mediaSession.metadata = new window.MediaMetadata({
+        title: this.config.mediaMetadata.title,
+        artist: this.config.mediaMetadata.artist,
+        album: this.config.mediaMetadata.album,
+        artwork: this.config.mediaMetadata.artwork
+      }));
+    } catch {
+    }
+  },
+  // Add markers
+  setMarkers() {
+    var e, i;
+    if (!this.duration || this.elements.markers) return;
+    const t = (e = this.config.markers) === null || e === void 0 || (i = e.points) === null || i === void 0 ? void 0 : i.filter(({
+      time: c
+    }) => c > 0 && c < this.duration);
+    if (!(t != null && t.length)) return;
+    const s = document.createDocumentFragment(), n = document.createDocumentFragment();
+    let r = null;
+    const l = `${this.config.classNames.tooltip}--visible`, o = (c) => E(r, l, c);
+    t.forEach((c) => {
+      const u = y("span", {
+        class: this.config.classNames.marker
+      }, ""), p = `${c.time / this.duration * 100}%`;
+      r && (u.addEventListener("mouseenter", () => {
+        c.label || (r.style.left = p, r.innerHTML = c.label, o(!0));
+      }), u.addEventListener("mouseleave", () => {
+        o(!1);
+      })), u.addEventListener("click", () => {
+        this.currentTime = c.time;
+      }), u.style.left = p, n.appendChild(u);
+    }), s.appendChild(n), this.config.tooltips.seek || (r = y("span", {
+      class: this.config.classNames.tooltip
+    }, ""), s.appendChild(r)), this.elements.markers = {
+      points: n,
+      tip: r
+    }, this.elements.progress.appendChild(s);
+  }
+};
+function ut(e, i = !0) {
+  let t = e;
+  if (i) {
+    const s = document.createElement("a");
+    s.href = t, t = s.href;
+  }
+  try {
+    return new URL(t);
+  } catch {
+    return null;
+  }
+}
+function ht(e) {
+  const i = new URLSearchParams();
+  return a.object(e) && Object.entries(e).forEach(([t, s]) => {
+    i.set(t, s);
+  }), i;
+}
+const A = {
+  // Setup captions
+  setup() {
+    if (!this.supported.ui)
+      return;
+    if (!this.isVideo || this.isYouTube || this.isHTML5 && !$.textTracks) {
+      a.array(this.config.controls) && this.config.controls.includes("settings") && this.config.settings.includes("captions") && d.setCaptionsMenu.call(this);
+      return;
+    }
+    if (a.element(this.elements.captions) || (this.elements.captions = y("div", V(this.config.selectors.captions)), this.elements.captions.setAttribute("dir", "auto"), Bt(this.elements.captions, this.elements.wrapper)), _.isIE && window.URL) {
+      const n = this.media.querySelectorAll("track");
+      Array.from(n).forEach((r) => {
+        const l = r.getAttribute("src"), o = ut(l);
+        o !== null && o.hostname !== window.location.href.hostname && ["http:", "https:"].includes(o.protocol) && ne(l, "blob").then((c) => {
+          r.setAttribute("src", window.URL.createObjectURL(c));
+        }).catch(() => {
+          U(r);
+        });
+      });
+    }
+    const e = navigator.languages || [navigator.language || navigator.userLanguage || "en"], i = Ce(e.map((n) => n.split("-")[0]));
+    let t = (this.storage.get("language") || this.captions.language || this.config.captions.language || "auto").toLowerCase();
+    t === "auto" && ([t] = i);
+    let s = this.storage.get("captions") || this.captions.active;
+    if (a.boolean(s) || ({
+      active: s
+    } = this.config.captions), Object.assign(this.captions, {
+      toggled: !1,
+      active: s,
+      language: t,
+      languages: i
+    }), this.isHTML5) {
+      const n = this.config.captions.update ? "addtrack removetrack" : "removetrack";
+      T.call(this, this.media.textTracks, n, A.update.bind(this));
+    }
+    setTimeout(A.update.bind(this), 0);
+  },
+  // Update available language options in settings based on tracks
+  update() {
+    const e = A.getTracks.call(this, !0), {
+      active: i,
+      language: t,
+      meta: s,
+      currentTrackNode: n
+    } = this.captions, r = !!e.find((l) => l.language === t);
+    this.isHTML5 && this.isVideo && e.filter((l) => !s.get(l)).forEach((l) => {
+      this.debug.log("Track added", l), s.set(l, {
+        default: l.mode === "showing"
+      }), l.mode === "showing" && (l.mode = "hidden"), T.call(this, l, "cuechange", () => A.updateCues.call(this));
+    }), (r && this.language !== t || !e.includes(n)) && (A.setLanguage.call(this, t), A.toggle.call(this, i && r)), this.elements && E(this.elements.container, this.config.classNames.captions.enabled, !a.empty(e)), a.array(this.config.controls) && this.config.controls.includes("settings") && this.config.settings.includes("captions") && d.setCaptionsMenu.call(this);
+  },
+  // Toggle captions display
+  // Used internally for the toggleCaptions method, with the passive option forced to false
+  toggle(e, i = !0) {
+    if (!this.supported.ui)
+      return;
+    const {
+      toggled: t
+    } = this.captions, s = this.config.classNames.captions.active, n = a.nullOrUndefined(e) ? !t : e;
+    if (n !== t) {
+      if (i || (this.captions.active = n, this.storage.set({
+        captions: n
+      })), !this.language && n && !i) {
+        const r = A.getTracks.call(this), l = A.findTrack.call(this, [this.captions.language, ...this.captions.languages], !0);
+        this.captions.language = l.language, A.set.call(this, r.indexOf(l));
+        return;
+      }
+      this.elements.buttons.captions && (this.elements.buttons.captions.pressed = n), E(this.elements.container, s, n), this.captions.toggled = n, d.updateSetting.call(this, "captions"), v.call(this, this.media, n ? "captionsenabled" : "captionsdisabled");
+    }
+    setTimeout(() => {
+      n && this.captions.toggled && (this.captions.currentTrackNode.mode = "hidden");
+    });
+  },
+  // Set captions by track index
+  // Used internally for the currentTrack setter with the passive option forced to false
+  set(e, i = !0) {
+    const t = A.getTracks.call(this);
+    if (e === -1) {
+      A.toggle.call(this, !1, i);
+      return;
+    }
+    if (!a.number(e)) {
+      this.debug.warn("Invalid caption argument", e);
+      return;
+    }
+    if (!(e in t)) {
+      this.debug.warn("Track not found", e);
+      return;
+    }
+    if (this.captions.currentTrack !== e) {
+      this.captions.currentTrack = e;
+      const s = t[e], {
+        language: n
+      } = s || {};
+      this.captions.currentTrackNode = s, d.updateSetting.call(this, "captions"), i || (this.captions.language = n, this.storage.set({
+        language: n
+      })), this.isVimeo && this.embed.enableTextTrack(n, null, !1), v.call(this, this.media, "languagechange");
+    }
+    A.toggle.call(this, !0, i), this.isHTML5 && this.isVideo && A.updateCues.call(this);
+  },
+  // Set captions by language
+  // Used internally for the language setter with the passive option forced to false
+  setLanguage(e, i = !0) {
+    if (!a.string(e)) {
+      this.debug.warn("Invalid language argument", e);
+      return;
+    }
+    const t = e.toLowerCase();
+    this.captions.language = t;
+    const s = A.getTracks.call(this), n = A.findTrack.call(this, [t]);
+    A.set.call(this, s.indexOf(n), i);
+  },
+  // Get current valid caption tracks
+  // If update is false it will also ignore tracks without metadata
+  // This is used to "freeze" the language options when captions.update is false
+  getTracks(e = !1) {
+    return Array.from((this.media || {}).textTracks || []).filter((t) => !this.isHTML5 || e || this.captions.meta.has(t)).filter((t) => ["captions", "subtitles"].includes(t.kind));
+  },
+  // Match tracks based on languages and get the first
+  findTrack(e, i = !1) {
+    const t = A.getTracks.call(this), s = (l) => Number((this.captions.meta.get(l) || {}).default), n = Array.from(t).sort((l, o) => s(o) - s(l));
+    let r;
+    return e.every((l) => (r = n.find((o) => o.language === l), !r)), r || (i ? n[0] : void 0);
+  },
+  // Get the current track
+  getCurrentTrack() {
+    return A.getTracks.call(this)[this.currentTrack];
+  },
+  // Get UI label for track
+  getLabel(e) {
+    let i = e;
+    return !a.track(i) && $.textTracks && this.captions.toggled && (i = A.getCurrentTrack.call(this)), a.track(i) ? a.empty(i.label) ? a.empty(i.language) ? O.get("enabled", this.config) : e.language.toUpperCase() : i.label : O.get("disabled", this.config);
+  },
+  // Update captions using current track's active cues
+  // Also optional array argument in case there isn't any track (ex: vimeo)
+  updateCues(e) {
+    if (!this.supported.ui)
+      return;
+    if (!a.element(this.elements.captions)) {
+      this.debug.warn("No captions element to render to");
+      return;
+    }
+    if (!a.nullOrUndefined(e) && !Array.isArray(e)) {
+      this.debug.warn("updateCues: Invalid input", e);
+      return;
+    }
+    let i = e;
+    if (!i) {
+      const n = A.getCurrentTrack.call(this);
+      i = Array.from((n || {}).activeCues || []).map((r) => r.getCueAsHTML()).map(ai);
+    }
+    const t = i.map((n) => n.trim()).join(`
+`);
+    if (t !== this.elements.captions.innerHTML) {
+      ae(this.elements.captions);
+      const n = y("span", V(this.config.selectors.caption));
+      n.innerHTML = t, this.elements.captions.appendChild(n), v.call(this, this.media, "cuechange");
+    }
+  }
+}, dt = {
+  // Disable
+  enabled: !0,
+  // Custom media title
+  title: "",
+  // Logging to console
+  debug: !1,
+  // Auto play (if supported)
+  autoplay: !1,
+  // Only allow one media playing at once (vimeo only)
+  autopause: !0,
+  // Allow inline playback on iOS
+  playsinline: !0,
+  // Default time to skip when rewind/fast forward
+  seekTime: 10,
+  // Default volume
+  volume: 1,
+  muted: !1,
+  // Pass a custom duration
+  duration: null,
+  // Display the media duration on load in the current time position
+  // If you have opted to display both duration and currentTime, this is ignored
+  displayDuration: !0,
+  // Invert the current time to be a countdown
+  invertTime: !0,
+  // Clicking the currentTime inverts it's value to show time left rather than elapsed
+  toggleInvert: !0,
+  // Force an aspect ratio
+  // The format must be `'w:h'` (e.g. `'16:9'`)
+  ratio: null,
+  // Click video container to play/pause
+  clickToPlay: !0,
+  // Auto hide the controls
+  hideControls: !0,
+  // Reset to start when playback ended
+  resetOnEnd: !1,
+  // Disable the standard context menu
+  disableContextMenu: !0,
+  // Sprite (for icons)
+  loadSprite: !0,
+  iconPrefix: "plyr",
+  iconUrl: "https://cdn.plyr.io/3.8.4/plyr.svg",
+  // Blank video (used to prevent errors on source change)
+  blankVideo: "https://cdn.plyr.io/static/blank.mp4",
+  // Quality default
+  quality: {
+    default: 576,
+    // The options to display in the UI, if available for the source media
+    options: [4320, 2880, 2160, 1440, 1080, 720, 576, 480, 360, 240],
+    forced: !1,
+    onChange: null
+  },
+  // Set loops
+  loop: {
+    active: !1
+    // start: null,
+    // end: null,
+  },
+  // Speed default and options to display
+  speed: {
+    selected: 1,
+    // The options to display in the UI, if available for the source media (e.g. Vimeo and YouTube only support 0.5x-4x)
+    options: [0.5, 0.75, 1, 1.25, 1.5, 1.75, 2, 4]
+  },
+  // Keyboard shortcut settings
+  keyboard: {
+    focused: !0,
+    global: !1
+  },
+  // Display tooltips
+  tooltips: {
+    controls: !1,
+    seek: !0
+  },
+  // Captions settings
+  captions: {
+    active: !1,
+    language: "auto",
+    // Listen to new tracks added after Plyr is initialized.
+    // This is needed for streaming captions, but may result in unselectable options
+    update: !1
+  },
+  // Fullscreen settings
+  fullscreen: {
+    enabled: !0,
+    // Allow fullscreen?
+    fallback: !0,
+    // Fallback using full viewport/window
+    iosNative: !1
+    // Use the native fullscreen in iOS (disables custom controls)
+    // Selector for the fullscreen container so contextual / non-player content can remain visible in fullscreen mode
+    // Non-ancestors of the player element will be ignored
+    // container: null, // defaults to the player element
+  },
+  // Local storage
+  storage: {
+    enabled: !0,
+    key: "plyr"
+  },
+  // Default controls
+  controls: [
+    "play-large",
+    // 'restart',
+    // 'rewind',
+    "play",
+    // 'fast-forward',
+    "progress",
+    "current-time",
+    // 'duration',
+    "mute",
+    "volume",
+    "captions",
+    "settings",
+    "pip",
+    "airplay",
+    // 'download',
+    "fullscreen"
+  ],
+  settings: ["captions", "quality", "speed"],
+  // Localisation
+  i18n: {
+    restart: "Restart",
+    rewind: "Rewind {seektime}s",
+    play: "Play",
+    pause: "Pause",
+    fastForward: "Forward {seektime}s",
+    seek: "Seek",
+    seekLabel: "{currentTime} of {duration}",
+    played: "Played",
+    buffered: "Buffered",
+    currentTime: "Current time",
+    duration: "Duration",
+    volume: "Volume",
+    mute: "Mute",
+    unmute: "Unmute",
+    enableCaptions: "Enable captions",
+    disableCaptions: "Disable captions",
+    download: "Download",
+    enterFullscreen: "Enter fullscreen",
+    exitFullscreen: "Exit fullscreen",
+    frameTitle: "Player for {title}",
+    captions: "Captions",
+    settings: "Settings",
+    pip: "PIP",
+    menuBack: "Go back to previous menu",
+    speed: "Speed",
+    normal: "Normal",
+    quality: "Quality",
+    loop: "Loop",
+    start: "Start",
+    end: "End",
+    all: "All",
+    reset: "Reset",
+    disabled: "Disabled",
+    enabled: "Enabled",
+    advertisement: "Ad",
+    qualityBadge: {
+      2160: "4K",
+      1440: "HD",
+      1080: "HD",
+      720: "HD",
+      576: "SD",
+      480: "SD"
+    }
+  },
+  // URLs
+  urls: {
+    download: null,
+    vimeo: {
+      sdk: "https://player.vimeo.com/api/player.js",
+      iframe: "https://player.vimeo.com/video/{0}?{1}",
+      api: "https://vimeo.com/api/oembed.json?url={0}"
+    },
+    youtube: {
+      sdk: "https://www.youtube.com/iframe_api",
+      api: "https://noembed.com/embed?url=https://www.youtube.com/watch?v={0}"
+    },
+    googleIMA: {
+      sdk: "https://imasdk.googleapis.com/js/sdkloader/ima3.js"
+    }
+  },
+  // Custom control listeners
+  listeners: {
+    seek: null,
+    play: null,
+    pause: null,
+    restart: null,
+    rewind: null,
+    fastForward: null,
+    mute: null,
+    volume: null,
+    captions: null,
+    download: null,
+    fullscreen: null,
+    pip: null,
+    airplay: null,
+    speed: null,
+    quality: null,
+    loop: null,
+    language: null
+  },
+  // Events to watch and bubble
+  events: [
+    // Events to watch on HTML5 media elements and bubble
+    // https://developer.mozilla.org/en/docs/Web/Guide/Events/Media_events
+    "ended",
+    "progress",
+    "stalled",
+    "playing",
+    "waiting",
+    "canplay",
+    "canplaythrough",
+    "loadstart",
+    "loadeddata",
+    "loadedmetadata",
+    "timeupdate",
+    "volumechange",
+    "play",
+    "pause",
+    "error",
+    "seeking",
+    "seeked",
+    "emptied",
+    "ratechange",
+    "cuechange",
+    // Custom events
+    "download",
+    "enterfullscreen",
+    "exitfullscreen",
+    "captionsenabled",
+    "captionsdisabled",
+    "languagechange",
+    "controlshidden",
+    "controlsshown",
+    "ready",
+    // YouTube
+    "statechange",
+    // Quality
+    "qualitychange",
+    // Ads
+    "adsloaded",
+    "adscontentpause",
+    "adscontentresume",
+    "adstarted",
+    "adsmidpoint",
+    "adscomplete",
+    "adsallcomplete",
+    "adsimpression",
+    "adsclick"
+  ],
+  // Selectors
+  // Change these to match your template if using custom HTML
+  selectors: {
+    editable: "input, textarea, select, [contenteditable]",
+    container: ".plyr",
+    controls: {
+      container: null,
+      wrapper: ".plyr__controls"
+    },
+    labels: "[data-plyr]",
+    buttons: {
+      play: '[data-plyr="play"]',
+      pause: '[data-plyr="pause"]',
+      restart: '[data-plyr="restart"]',
+      rewind: '[data-plyr="rewind"]',
+      fastForward: '[data-plyr="fast-forward"]',
+      mute: '[data-plyr="mute"]',
+      captions: '[data-plyr="captions"]',
+      download: '[data-plyr="download"]',
+      fullscreen: '[data-plyr="fullscreen"]',
+      pip: '[data-plyr="pip"]',
+      airplay: '[data-plyr="airplay"]',
+      settings: '[data-plyr="settings"]',
+      loop: '[data-plyr="loop"]'
+    },
+    inputs: {
+      seek: '[data-plyr="seek"]',
+      volume: '[data-plyr="volume"]',
+      speed: '[data-plyr="speed"]',
+      language: '[data-plyr="language"]',
+      quality: '[data-plyr="quality"]'
+    },
+    display: {
+      currentTime: ".plyr__time--current",
+      duration: ".plyr__time--duration",
+      buffer: ".plyr__progress__buffer",
+      loop: ".plyr__progress__loop",
+      // Used later
+      volume: ".plyr__volume--display"
+    },
+    progress: ".plyr__progress",
+    captions: ".plyr__captions",
+    caption: ".plyr__caption"
+  },
+  // Class hooks added to the player in different states
+  classNames: {
+    type: "plyr--{0}",
+    provider: "plyr--{0}",
+    video: "plyr__video-wrapper",
+    embed: "plyr__video-embed",
+    videoFixedRatio: "plyr__video-wrapper--fixed-ratio",
+    embedContainer: "plyr__video-embed__container",
+    poster: "plyr__poster",
+    posterEnabled: "plyr__poster-enabled",
+    ads: "plyr__ads",
+    control: "plyr__control",
+    controlPressed: "plyr__control--pressed",
+    playing: "plyr--playing",
+    paused: "plyr--paused",
+    stopped: "plyr--stopped",
+    loading: "plyr--loading",
+    hover: "plyr--hover",
+    tooltip: "plyr__tooltip",
+    cues: "plyr__cues",
+    marker: "plyr__progress__marker",
+    hidden: "plyr__sr-only",
+    hideControls: "plyr--hide-controls",
+    isTouch: "plyr--is-touch",
+    uiSupported: "plyr--full-ui",
+    noTransition: "plyr--no-transition",
+    display: {
+      time: "plyr__time"
+    },
+    menu: {
+      value: "plyr__menu__value",
+      badge: "plyr__badge",
+      open: "plyr--menu-open"
+    },
+    captions: {
+      enabled: "plyr--captions-enabled",
+      active: "plyr--captions-active"
+    },
+    fullscreen: {
+      enabled: "plyr--fullscreen-enabled",
+      fallback: "plyr--fullscreen-fallback"
+    },
+    pip: {
+      supported: "plyr--pip-supported",
+      active: "plyr--pip-active"
+    },
+    airplay: {
+      supported: "plyr--airplay-supported",
+      active: "plyr--airplay-active"
+    },
+    previewThumbnails: {
+      // Tooltip thumbs
+      thumbContainer: "plyr__preview-thumb",
+      thumbContainerShown: "plyr__preview-thumb--is-shown",
+      imageContainer: "plyr__preview-thumb__image-container",
+      timeContainer: "plyr__preview-thumb__time-container",
+      // Scrubbing
+      scrubbingContainer: "plyr__preview-scrubbing",
+      scrubbingContainerShown: "plyr__preview-scrubbing--is-shown"
+    }
+  },
+  // Embed attributes
+  attributes: {
+    embed: {
+      provider: "data-plyr-provider",
+      id: "data-plyr-embed-id",
+      hash: "data-plyr-embed-hash"
+    }
+  },
+  // Advertisements plugin
+  // Register for an account here: http://vi.ai/publisher-video-monetization/?aid=plyrio
+  ads: {
+    enabled: !1,
+    publisherId: "",
+    tagUrl: ""
+  },
+  // Preview Thumbnails plugin
+  previewThumbnails: {
+    enabled: !1,
+    src: "",
+    withCredentials: !1
+  },
+  // Vimeo plugin
+  vimeo: {
+    byline: !1,
+    portrait: !1,
+    title: !1,
+    speed: !0,
+    transparent: !1,
+    // Custom settings from Plyr
+    customControls: !0,
+    referrerPolicy: null,
+    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement/referrerPolicy
+    // Whether the owner of the video has a Pro or Business account
+    // (which allows us to properly hide controls without CSS hacks, etc)
+    premium: !1
+  },
+  // YouTube plugin
+  youtube: {
+    rel: 0,
+    // No related vids
+    showinfo: 0,
+    // Hide info
+    iv_load_policy: 3,
+    // Hide annotations
+    modestbranding: 1,
+    // Hide logos as much as possible (they still show one in the corner when paused)
+    // Custom settings from Plyr
+    customControls: !0,
+    noCookie: !1
+    // Whether to use an alternative version of YouTube without cookies
+  },
+  // Media Metadata
+  mediaMetadata: {
+    title: "",
+    artist: "",
+    album: "",
+    artwork: []
+  },
+  // Markers
+  markers: {
+    enabled: !1,
+    points: []
+  }
+}, ye = {
+  active: "picture-in-picture",
+  inactive: "inline"
+}, W = {
+  html5: "html5",
+  youtube: "youtube",
+  vimeo: "vimeo"
+}, ve = {
+  audio: "audio",
+  video: "video"
+};
+function ci(e) {
+  return /^(?:https?:\/\/)?(?:www\.)?(?:youtube\.com|youtube-nocookie\.com|youtu\.?be)\/.+$/.test(e) ? W.youtube : /^https?:\/\/player.vimeo.com\/video\/\d{0,9}(?=\b|\/)/.test(e) ? W.vimeo : null;
+}
+function we() {
+}
+class ui {
+  constructor(i = !1) {
+    this.enabled = window.console && i, this.enabled && this.log("Debugging enabled");
+  }
+  get log() {
+    return this.enabled ? Function.prototype.bind.call(console.log, console) : we;
+  }
+  get warn() {
+    return this.enabled ? Function.prototype.bind.call(console.warn, console) : we;
+  }
+  get error() {
+    return this.enabled ? Function.prototype.bind.call(console.error, console) : we;
+  }
+}
+class q {
+  constructor(i) {
+    m(this, "onChange", () => {
+      if (!this.supported) return;
+      const t = this.player.elements.buttons.fullscreen;
+      a.element(t) && (t.pressed = this.active);
+      const s = this.target === this.player.media ? this.target : this.player.elements.container;
+      v.call(this.player, s, this.active ? "enterfullscreen" : "exitfullscreen", !0);
+    }), m(this, "toggleFallback", (t = !1) => {
+      if (t) {
+        var s, n;
+        this.scrollPosition = {
+          x: (s = window.scrollX) !== null && s !== void 0 ? s : 0,
+          y: (n = window.scrollY) !== null && n !== void 0 ? n : 0
+        };
+      } else
+        window.scrollTo(this.scrollPosition.x, this.scrollPosition.y);
+      if (document.body.style.overflow = t ? "hidden" : "", E(this.target, this.player.config.classNames.fullscreen.fallback, t), _.isIos) {
+        let r = document.head.querySelector('meta[name="viewport"]');
+        const l = "viewport-fit=cover";
+        r || (r = document.createElement("meta"), r.setAttribute("name", "viewport"));
+        const o = a.string(r.content) && r.content.includes(l);
+        t ? (this.cleanupViewport = !o, o || (r.content += `,${l}`)) : this.cleanupViewport && (r.content = r.content.split(",").filter((c) => c.trim() !== l).join(","));
+      }
+      this.onChange();
+    }), m(this, "trapFocus", (t) => {
+      if (_.isIos || _.isIPadOS || !this.active || t.key !== "Tab") return;
+      const s = document.activeElement, n = Z.call(this.player, "a[href], button:not(:disabled), input:not(:disabled), [tabindex]"), [r] = n, l = n[n.length - 1];
+      s === l && !t.shiftKey ? (r.focus(), t.preventDefault()) : s === r && t.shiftKey && (l.focus(), t.preventDefault());
+    }), m(this, "update", () => {
+      if (this.supported) {
+        let t;
+        this.forceFallback ? t = "Fallback (forced)" : q.nativeSupported ? t = "Native" : t = "Fallback", this.player.debug.log(`${t} fullscreen enabled`);
+      } else
+        this.player.debug.log("Fullscreen not supported and fallback disabled");
+      E(this.player.elements.container, this.player.config.classNames.fullscreen.enabled, this.supported);
+    }), m(this, "enter", () => {
+      this.supported && (_.isIos && this.player.config.fullscreen.iosNative ? this.player.isVimeo ? this.player.embed.requestFullscreen() : this.target.webkitEnterFullscreen() : !q.nativeSupported || this.forceFallback ? this.toggleFallback(!0) : this.prefix ? a.empty(this.prefix) || this.target[`${this.prefix}Request${this.property}`]() : this.target.requestFullscreen({
+        navigationUI: "hide"
+      }));
+    }), m(this, "exit", () => {
+      if (this.supported) {
+        if (_.isIos && this.player.config.fullscreen.iosNative)
+          this.player.isVimeo ? this.player.embed.exitFullscreen() : this.target.webkitEnterFullscreen(), F(this.player.play());
+        else if (!q.nativeSupported || this.forceFallback)
+          this.toggleFallback(!1);
+        else if (!this.prefix)
+          (document.cancelFullScreen || document.exitFullscreen).call(document);
+        else if (!a.empty(this.prefix)) {
+          const t = this.prefix === "moz" ? "Cancel" : "Exit";
+          document[`${this.prefix}${t}${this.property}`]();
+        }
+      }
+    }), m(this, "toggle", () => {
+      this.active ? this.exit() : this.enter();
+    }), this.player = i, this.prefix = q.prefix, this.property = q.property, this.scrollPosition = {
+      x: 0,
+      y: 0
+    }, this.forceFallback = i.config.fullscreen.fallback === "force", this.player.elements.fullscreen = i.config.fullscreen.container && Wt(this.player.elements.container, i.config.fullscreen.container), T.call(this.player, document, this.prefix === "ms" ? "MSFullscreenChange" : `${this.prefix}fullscreenchange`, () => {
+      this.onChange();
+    }), T.call(this.player, this.player.elements.container, "dblclick", (t) => {
+      a.element(this.player.elements.controls) && this.player.elements.controls.contains(t.target) || this.player.listeners.proxy(t, this.toggle, "fullscreen");
+    }), T.call(this, this.player.elements.container, "keydown", (t) => this.trapFocus(t)), this.update();
+  }
+  // Determine if native supported
+  static get nativeSupported() {
+    return !!(document.fullscreenEnabled || document.webkitFullscreenEnabled || document.mozFullScreenEnabled || document.msFullscreenEnabled);
+  }
+  // If we're actually using native
+  get useNative() {
+    return q.nativeSupported && !this.forceFallback;
+  }
+  // Get the prefix for handlers
+  static get prefix() {
+    if (a.function(document.exitFullscreen)) return "";
+    let i = "";
+    return ["webkit", "moz", "ms"].some((s) => a.function(document[`${s}ExitFullscreen`]) || a.function(document[`${s}CancelFullScreen`]) ? (i = s, !0) : !1), i;
+  }
+  static get property() {
+    return this.prefix === "moz" ? "FullScreen" : "Fullscreen";
+  }
+  // Determine if fullscreen is supported
+  get supported() {
+    return [
+      // Fullscreen is enabled in config
+      this.player.config.fullscreen.enabled,
+      // Must be a video
+      this.player.isVideo,
+      // Either native is supported or fallback enabled
+      q.nativeSupported || this.player.config.fullscreen.fallback,
+      // YouTube has no way to trigger fullscreen, so on devices with no native support, playsinline
+      // must be enabled and iosNative fullscreen must be disabled to offer the fullscreen fallback
+      !this.player.isYouTube || q.nativeSupported || !_.isIos || this.player.config.playsinline && !this.player.config.fullscreen.iosNative
+    ].every(Boolean);
+  }
+  // Get active state
+  get active() {
+    if (!this.supported) return !1;
+    if (!q.nativeSupported || this.forceFallback)
+      return he(this.target, this.player.config.classNames.fullscreen.fallback);
+    const i = this.prefix ? this.target.getRootNode()[`${this.prefix}${this.property}Element`] : this.target.getRootNode().fullscreenElement;
+    return i && i.shadowRoot ? i === this.target.getRootNode().host : i === this.target;
+  }
+  // Get target element
+  get target() {
+    var i;
+    return _.isIos && this.player.config.fullscreen.iosNative ? this.player.media : (i = this.player.elements.fullscreen) !== null && i !== void 0 ? i : this.player.elements.container;
+  }
+}
+function le(e, i = 1) {
+  return new Promise((t, s) => {
+    const n = new Image(), r = () => {
+      delete n.onload, delete n.onerror, (n.naturalWidth >= i ? t : s)(n);
+    };
+    Object.assign(n, {
+      onload: r,
+      onerror: r,
+      src: e
+    });
+  });
+}
+const S = {
+  addStyleHook() {
+    E(this.elements.container, this.config.selectors.container.replace(".", ""), !0), E(this.elements.container, this.config.classNames.uiSupported, this.supported.ui);
+  },
+  // Toggle native HTML5 media controls
+  toggleNativeControls(e = !1) {
+    e && this.isHTML5 ? this.media.setAttribute("controls", "") : this.media.removeAttribute("controls");
+  },
+  // Setup the UI
+  build() {
+    if (this.listeners.media(), !this.supported.ui) {
+      this.debug.warn(`Basic support only for ${this.provider} ${this.type}`), S.toggleNativeControls.call(this, !0);
+      return;
+    }
+    a.element(this.elements.controls) || (d.inject.call(this), this.listeners.controls()), S.toggleNativeControls.call(this), this.isHTML5 && A.setup.call(this), this.volume = null, this.muted = null, this.loop = null, this.quality = null, this.speed = null, d.updateVolume.call(this), d.timeUpdate.call(this), d.durationUpdate.call(this), S.checkPlaying.call(this), E(this.elements.container, this.config.classNames.pip.supported, $.pip && this.isHTML5 && this.isVideo), E(this.elements.container, this.config.classNames.airplay.supported, $.airplay && this.isHTML5), E(this.elements.container, this.config.classNames.isTouch, this.touch), this.ready = !0, setTimeout(() => {
+      v.call(this, this.media, "ready");
+    }, 0), S.setTitle.call(this), this.poster && S.setPoster.call(this, this.poster, !1).catch(() => {
+    }), this.config.duration && d.durationUpdate.call(this), this.config.mediaMetadata && d.setMediaMetadata.call(this);
+  },
+  // Setup aria attribute for play and iframe title
+  setTitle() {
+    let e = O.get("play", this.config);
+    if (a.string(this.config.title) && !a.empty(this.config.title) && (e += `, ${this.config.title}`), Array.from(this.elements.buttons.play || []).forEach((i) => {
+      i.setAttribute("aria-label", e);
+    }), this.isEmbed) {
+      const i = I.call(this, "iframe");
+      if (!a.element(i))
+        return;
+      const t = a.empty(this.config.title) ? "video" : this.config.title, s = O.get("frameTitle", this.config);
+      i.setAttribute("title", s.replace("{title}", t));
+    }
+  },
+  // Toggle poster
+  togglePoster(e) {
+    E(this.elements.container, this.config.classNames.posterEnabled, e);
+  },
+  // Set the poster image (async)
+  // Used internally for the poster setter, with the passive option forced to false
+  setPoster(e, i = !0) {
+    return i && this.poster ? Promise.reject(new Error("Poster already set")) : (this.media.setAttribute("data-poster", e), this.elements.poster.removeAttribute("hidden"), Yt.call(this).then(() => le(e)).catch((t) => {
+      throw e === this.poster && S.togglePoster.call(this, !1), t;
+    }).then(() => {
+      if (e !== this.poster)
+        throw new Error("setPoster cancelled by later call to setPoster");
+    }).then(() => (Object.assign(this.elements.poster.style, {
+      backgroundImage: `url('${e}')`,
+      // Reset backgroundSize as well (since it can be set to "cover" for padded thumbnails for youtube)
+      backgroundSize: ""
+    }), S.togglePoster.call(this, !0), e)));
+  },
+  // Check playing state
+  checkPlaying(e) {
+    E(this.elements.container, this.config.classNames.playing, this.playing), E(this.elements.container, this.config.classNames.paused, this.paused), E(this.elements.container, this.config.classNames.stopped, this.stopped), Array.from(this.elements.buttons.play || []).forEach((i) => {
+      Object.assign(i, {
+        pressed: this.playing
+      }), i.setAttribute("aria-label", O.get(this.playing ? "pause" : "play", this.config));
+    }), !(a.event(e) && e.type === "timeupdate") && S.toggleControls.call(this);
+  },
+  // Check if media is loading
+  checkLoading(e) {
+    this.loading = ["stalled", "waiting"].includes(e.type), clearTimeout(this.timers.loading), this.timers.loading = setTimeout(() => {
+      E(this.elements.container, this.config.classNames.loading, this.loading), S.toggleControls.call(this);
+    }, this.loading ? 250 : 0);
+  },
+  // Toggle controls based on state and `force` argument
+  toggleControls(e) {
+    const {
+      controls: i
+    } = this.elements;
+    if (i && this.config.hideControls) {
+      const t = this.touch && this.lastSeekTime + 2e3 > Date.now();
+      this.toggleControls(!!(e || this.loading || this.paused || i.pressed || i.hover || t));
+    }
+  },
+  // Migrate any custom properties from the media to the parent
+  migrateStyles() {
+    Object.values({
+      ...this.media.style
+    }).filter((e) => !a.empty(e) && a.string(e) && e.startsWith("--plyr")).forEach((e) => {
+      this.elements.container.style.setProperty(e, this.media.style.getPropertyValue(e)), this.media.style.removeProperty(e);
+    }), a.empty(this.media.style) && this.media.removeAttribute("style");
+  }
+};
+class hi {
+  constructor(i) {
+    m(this, "firstTouch", () => {
+      const {
+        player: t
+      } = this, {
+        elements: s
+      } = t;
+      t.touch = !0, E(s.container, t.config.classNames.isTouch, !0);
+    }), m(this, "global", (t = !0) => {
+      const {
+        player: s
+      } = this;
+      s.config.keyboard.global && ee.call(s, window, "keydown keyup", this.handleKey, t, !1), ee.call(s, document.body, "click", this.toggleMenu, t), xe.call(s, document.body, "touchstart", this.firstTouch);
+    }), m(this, "container", () => {
+      const {
+        player: t
+      } = this, {
+        config: s,
+        elements: n,
+        timers: r
+      } = t;
+      !s.keyboard.global && s.keyboard.focused && T.call(t, n.container, "keydown keyup", this.handleKey, !1), T.call(t, n.container, "mousemove mouseleave touchstart touchmove enterfullscreen exitfullscreen", (c) => {
+        const {
+          controls: u
+        } = n;
+        u && c.type === "enterfullscreen" && (u.pressed = !1, u.hover = !1);
+        const p = ["touchstart", "touchmove", "mousemove"].includes(c.type);
+        let b = 0;
+        p && (S.toggleControls.call(t, !0), b = t.touch ? 3e3 : 2e3), clearTimeout(r.controls), r.controls = setTimeout(() => S.toggleControls.call(t, !1), b);
+      });
+      const l = () => {
+        if (!t.isVimeo || t.config.vimeo.premium)
+          return;
+        const c = n.wrapper, {
+          active: u
+        } = t.fullscreen, [p, b] = Le.call(t), h = nt(`aspect-ratio: ${p} / ${b}`);
+        if (!u) {
+          h ? (c.style.width = null, c.style.height = null) : (c.style.maxWidth = null, c.style.margin = null);
+          return;
+        }
+        const [g, C] = Xt(), w = g / C > p / b;
+        h ? (c.style.width = w ? "auto" : "100%", c.style.height = w ? "100%" : "auto") : (c.style.maxWidth = w ? `${C / b * p}px` : null, c.style.margin = w ? "0 auto" : null);
+      }, o = () => {
+        clearTimeout(r.resized), r.resized = setTimeout(l, 50);
+      };
+      T.call(t, n.container, "enterfullscreen exitfullscreen", (c) => {
+        const {
+          target: u
+        } = t.fullscreen;
+        if (u !== n.container || !t.isEmbed && a.empty(t.config.ratio))
+          return;
+        l(), (c.type === "enterfullscreen" ? T : fe).call(t, window, "resize", o);
+      });
+    }), m(this, "media", () => {
+      const {
+        player: t
+      } = this, {
+        elements: s
+      } = t;
+      if (T.call(t, t.media, "timeupdate seeking seeked", (r) => d.timeUpdate.call(t, r)), T.call(t, t.media, "durationchange loadeddata loadedmetadata", (r) => d.durationUpdate.call(t, r)), T.call(t, t.media, "ended", () => {
+        t.isHTML5 && t.isVideo && t.config.resetOnEnd && (t.restart(), t.pause());
+      }), T.call(t, t.media, "progress playing seeking seeked", (r) => d.updateProgress.call(t, r)), T.call(t, t.media, "volumechange", (r) => d.updateVolume.call(t, r)), T.call(t, t.media, "playing play pause ended emptied timeupdate", (r) => S.checkPlaying.call(t, r)), T.call(t, t.media, "waiting canplay seeked playing", (r) => S.checkLoading.call(t, r)), t.supported.ui && t.config.clickToPlay && !t.isAudio) {
+        const r = I.call(t, `.${t.config.classNames.video}`);
+        if (!a.element(r))
+          return;
+        T.call(t, s.container, "click", (l) => {
+          ![s.container, r].includes(l.target) && !r.contains(l.target) || t.touch && t.config.hideControls || (t.ended ? (this.proxy(l, t.restart, "restart"), this.proxy(l, () => {
+            F(t.play());
+          }, "play")) : this.proxy(l, () => {
+            F(t.togglePlay());
+          }, "play"));
+        });
+      }
+      t.supported.ui && t.config.disableContextMenu && T.call(t, s.wrapper, "contextmenu", (r) => {
+        r.preventDefault();
+      }, !1), T.call(t, t.media, "volumechange", () => {
+        t.storage.set({
+          volume: t.volume,
+          muted: t.muted
+        });
+      }), T.call(t, t.media, "ratechange", () => {
+        d.updateSetting.call(t, "speed"), t.storage.set({
+          speed: t.speed
+        });
+      }), T.call(t, t.media, "qualitychange", (r) => {
+        d.updateSetting.call(t, "quality", null, r.detail.quality);
+      }), T.call(t, t.media, "ready qualitychange", () => {
+        d.setDownloadUrl.call(t);
+      });
+      const n = t.config.events.concat(["keyup", "keydown"]).join(" ");
+      T.call(t, t.media, n, (r) => {
+        let {
+          detail: l = {}
+        } = r;
+        r.type === "error" && (l = t.media.error), v.call(t, s.container, r.type, !0, l);
+      });
+    }), m(this, "proxy", (t, s, n) => {
+      const {
+        player: r
+      } = this, l = r.config.listeners[n], o = a.function(l);
+      let c = !0;
+      o && (c = l.call(r, t)), c !== !1 && a.function(s) && s.call(r, t);
+    }), m(this, "bind", (t, s, n, r, l = !0) => {
+      const {
+        player: o
+      } = this, c = o.config.listeners[r], u = a.function(c);
+      T.call(o, t, s, (p) => this.proxy(p, n, r), l && !u);
+    }), m(this, "controls", () => {
+      const {
+        player: t
+      } = this, {
+        elements: s
+      } = t, n = _.isIE ? "change" : "input";
+      if (s.buttons.play && Array.from(s.buttons.play).forEach((r) => {
+        this.bind(r, "click", () => {
+          F(t.togglePlay());
+        }, "play");
+      }), this.bind(s.buttons.restart, "click", t.restart, "restart"), this.bind(s.buttons.rewind, "click", () => {
+        t.lastSeekTime = Date.now(), t.rewind();
+      }, "rewind"), this.bind(s.buttons.fastForward, "click", () => {
+        t.lastSeekTime = Date.now(), t.forward();
+      }, "fastForward"), this.bind(s.buttons.mute, "click", () => {
+        t.muted = !t.muted;
+      }, "mute"), this.bind(s.buttons.captions, "click", () => t.toggleCaptions()), this.bind(s.buttons.download, "click", () => {
+        v.call(t, t.media, "download");
+      }, "download"), this.bind(s.buttons.fullscreen, "click", () => {
+        t.fullscreen.toggle();
+      }, "fullscreen"), this.bind(s.buttons.pip, "click", () => {
+        t.pip = "toggle";
+      }, "pip"), this.bind(s.buttons.airplay, "click", t.airplay, "airplay"), this.bind(s.buttons.settings, "click", (r) => {
+        r.stopPropagation(), r.preventDefault(), d.toggleMenu.call(t, r);
+      }, null, !1), this.bind(
+        s.buttons.settings,
+        "keyup",
+        (r) => {
+          if ([" ", "Enter"].includes(r.key)) {
+            if (r.key === "Enter") {
+              d.focusFirstMenuItem.call(t, null, !0);
+              return;
+            }
+            r.preventDefault(), r.stopPropagation(), d.toggleMenu.call(t, r);
+          }
+        },
+        null,
+        !1
+        // Can't be passive as we're preventing default
+      ), this.bind(s.settings.menu, "keydown", (r) => {
+        r.key === "Escape" && d.toggleMenu.call(t, r);
+      }), this.bind(s.inputs.seek, "mousedown mousemove", (r) => {
+        const l = s.progress.getBoundingClientRect(), o = r.pageX - r.clientX, c = 100 / l.width * (r.pageX - l.left - o);
+        r.currentTarget.setAttribute("seek-value", c);
+      }), this.bind(s.inputs.seek, "mousedown mouseup keydown keyup touchstart touchend", (r) => {
+        const l = r.currentTarget, o = "play-on-seeked";
+        if (a.keyboardEvent(r) && !["ArrowLeft", "ArrowRight"].includes(r.key))
+          return;
+        t.lastSeekTime = Date.now();
+        const c = l.hasAttribute(o), u = ["mouseup", "touchend", "keyup"].includes(r.type);
+        c && u ? (l.removeAttribute(o), F(t.play())) : !u && t.playing && (l.setAttribute(o, ""), t.pause());
+      }), _.isIos) {
+        const r = Z.call(t, 'input[type="range"]');
+        Array.from(r).forEach((l) => this.bind(l, n, (o) => et(o.target)));
+      }
+      this.bind(s.inputs.seek, n, (r) => {
+        const l = r.currentTarget;
+        let o = l.getAttribute("seek-value");
+        a.empty(o) && (o = l.value), l.removeAttribute("seek-value"), t.currentTime = o / l.max * t.duration;
+      }, "seek"), this.bind(s.progress, "mouseenter mouseleave mousemove", (r) => d.updateSeekTooltip.call(t, r)), this.bind(s.progress, "mousemove touchmove", (r) => {
+        const {
+          previewThumbnails: l
+        } = t;
+        l && l.loaded && l.startMove(r);
+      }), this.bind(s.progress, "mouseleave touchend click", () => {
+        const {
+          previewThumbnails: r
+        } = t;
+        r && r.loaded && r.endMove(!1, !0);
+      }), this.bind(s.progress, "mousedown touchstart", (r) => {
+        const {
+          previewThumbnails: l
+        } = t;
+        l && l.loaded && l.startScrubbing(r);
+      }), this.bind(s.progress, "mouseup touchend", (r) => {
+        const {
+          previewThumbnails: l
+        } = t;
+        l && l.loaded && l.endScrubbing(r);
+      }), _.isWebKit && Array.from(Z.call(t, 'input[type="range"]')).forEach((r) => {
+        this.bind(r, "input", (l) => d.updateRangeFill.call(t, l.target));
+      }), t.config.toggleInvert && !a.element(s.display.duration) && this.bind(s.display.currentTime, "click", () => {
+        t.currentTime !== 0 && (t.config.invertTime = !t.config.invertTime, d.timeUpdate.call(t));
+      }), this.bind(s.inputs.volume, n, (r) => {
+        t.volume = r.target.value;
+      }, "volume"), this.bind(s.controls, "mouseenter mouseleave", (r) => {
+        s.controls.hover = !t.touch && r.type === "mouseenter";
+      }), s.fullscreen && Array.from(s.fullscreen.children).filter((r) => !r.contains(s.container)).forEach((r) => {
+        this.bind(r, "mouseenter mouseleave", (l) => {
+          s.controls && (s.controls.hover = !t.touch && l.type === "mouseenter");
+        });
+      }), this.bind(s.controls, "mousedown mouseup touchstart touchend touchcancel", (r) => {
+        s.controls.pressed = ["mousedown", "touchstart"].includes(r.type);
+      }), this.bind(s.controls, "focusin", () => {
+        const {
+          config: r,
+          timers: l
+        } = t;
+        E(s.controls, r.classNames.noTransition, !0), S.toggleControls.call(t, !0), setTimeout(() => {
+          E(s.controls, r.classNames.noTransition, !1);
+        }, 0);
+        const o = this.touch ? 3e3 : 4e3;
+        clearTimeout(l.controls), l.controls = setTimeout(() => S.toggleControls.call(t, !1), o);
+      }), this.bind(s.inputs.volume, "wheel", (r) => {
+        const l = r.webkitDirectionInvertedFromDevice, [o, c] = [r.deltaX, -r.deltaY].map((b) => l ? -b : b), u = Math.sign(Math.abs(o) > Math.abs(c) ? o : c);
+        t.increaseVolume(u / 50);
+        const {
+          volume: p
+        } = t.media;
+        (u === 1 && p < 1 || u === -1 && p > 0) && r.preventDefault();
+      }, "volume", !1);
+    }), this.player = i, this.lastKey = null, this.focusTimer = null, this.lastKeyDown = null, this.handleKey = this.handleKey.bind(this), this.toggleMenu = this.toggleMenu.bind(this), this.firstTouch = this.firstTouch.bind(this);
+  }
+  // Handle key presses
+  handleKey(i) {
+    const {
+      player: t
+    } = this, {
+      elements: s
+    } = t, {
+      key: n,
+      type: r,
+      altKey: l,
+      ctrlKey: o,
+      metaKey: c,
+      shiftKey: u
+    } = i, p = r === "keydown", b = p && n === this.lastKey;
+    if (l || o || c || u || !n)
+      return;
+    const h = (g) => {
+      t.currentTime = t.duration / 10 * g;
+    };
+    if (p) {
+      const g = document.activeElement;
+      if (a.element(g)) {
+        const {
+          editable: w
+        } = t.config.selectors, {
+          seek: x
+        } = s.inputs;
+        if (g !== x && Y(g, w) || i.key === " " && Y(g, 'button, [role^="menuitem"]'))
+          return;
+      }
+      switch ([" ", "ArrowLeft", "ArrowUp", "ArrowRight", "ArrowDown", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "c", "f", "k", "l", "m"].includes(n) && (i.preventDefault(), i.stopPropagation()), n) {
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+        case "8":
+        case "9":
+          b || h(Number.parseInt(n, 10));
+          break;
+        case " ":
+        case "k":
+          b || F(t.togglePlay());
+          break;
+        case "ArrowUp":
+          t.increaseVolume(0.1);
+          break;
+        case "ArrowDown":
+          t.decreaseVolume(0.1);
+          break;
+        case "m":
+          b || (t.muted = !t.muted);
+          break;
+        case "ArrowRight":
+          t.forward();
+          break;
+        case "ArrowLeft":
+          t.rewind();
+          break;
+        case "f":
+          t.fullscreen.toggle();
+          break;
+        case "c":
+          b || t.toggleCaptions();
+          break;
+        case "l":
+          t.loop = !t.loop;
+          break;
+      }
+      n === "Escape" && !t.fullscreen.usingNative && t.fullscreen.active && t.fullscreen.toggle(), this.lastKey = n;
+    } else
+      this.lastKey = null;
+  }
+  // Toggle menu
+  toggleMenu(i) {
+    d.toggleMenu.call(this.player, i);
+  }
+}
+function di(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var oe = { exports: {} }, mi = oe.exports, Fe;
+function pi() {
+  return Fe || (Fe = 1, (function(e, i) {
+    (function(t, s) {
+      e.exports = s();
+    })(mi, function() {
+      var t = function() {
+      }, s = {}, n = {}, r = {};
+      function l(h, g) {
+        h = h.push ? h : [h];
+        var C = [], w = h.length, x = w, P, f, k, M;
+        for (P = function(j, R) {
+          R.length && C.push(j), x--, x || g(C);
+        }; w--; ) {
+          if (f = h[w], k = n[f], k) {
+            P(f, k);
+            continue;
+          }
+          M = r[f] = r[f] || [], M.push(P);
+        }
+      }
+      function o(h, g) {
+        if (h) {
+          var C = r[h];
+          if (n[h] = g, !!C)
+            for (; C.length; )
+              C[0](h, g), C.splice(0, 1);
+        }
+      }
+      function c(h, g) {
+        h.call && (h = {
+          success: h
+        }), g.length ? (h.error || t)(g) : (h.success || t)(h);
+      }
+      function u(h, g, C, w) {
+        var x = document, P = C.async, f = (C.numRetries || 0) + 1, k = C.before || t, M = h.replace(/[\?|#].*$/, ""), j = h.replace(/^(css|img|module|nomodule)!/, ""), R, H, N;
+        if (w = w || 0, /(^css!|\.css$)/.test(M))
+          N = x.createElement("link"), N.rel = "stylesheet", N.href = j, R = "hideFocus" in N, R && N.relList && (R = 0, N.rel = "preload", N.as = "style");
+        else if (/(^img!|\.(png|gif|jpg|svg|webp)$)/.test(M))
+          N = x.createElement("img"), N.src = j;
+        else if (N = x.createElement("script"), N.src = j, N.async = P === void 0 ? !0 : P, H = "noModule" in N, /^module!/.test(M)) {
+          if (!H) return g(h, "l");
+          N.type = "module";
+        } else if (/^nomodule!/.test(M) && H) return g(h, "l");
+        N.onload = N.onerror = N.onbeforeload = function(Ie) {
+          var re = Ie.type[0];
+          if (R)
+            try {
+              N.sheet.cssText.length || (re = "e");
+            } catch (ft) {
+              ft.code != 18 && (re = "e");
+            }
+          if (re == "e") {
+            if (w += 1, w < f)
+              return u(h, g, C, w);
+          } else if (N.rel == "preload" && N.as == "style")
+            return N.rel = "stylesheet";
+          g(h, re, Ie.defaultPrevented);
+        }, k(h, N) !== !1 && x.head.appendChild(N);
+      }
+      function p(h, g, C) {
+        h = h.push ? h : [h];
+        var w = h.length, x = w, P = [], f, k;
+        for (f = function(M, j, R) {
+          if (j == "e" && P.push(M), j == "b")
+            if (R) P.push(M);
+            else return;
+          w--, w || g(P);
+        }, k = 0; k < x; k++) u(h[k], f, C);
+      }
+      function b(h, g, C) {
+        var w, x;
+        if (g && g.trim && (w = g), x = (w ? C : g) || {}, w) {
+          if (w in s)
+            throw "LoadJS";
+          s[w] = !0;
+        }
+        function P(f, k) {
+          p(h, function(M) {
+            c(x, M), f && c({
+              success: f,
+              error: k
+            }, M), o(w, M);
+          }, x);
+        }
+        if (x.returnPromise) return new Promise(P);
+        P();
+      }
+      return b.ready = function(g, C) {
+        return l(g, function(w) {
+          c(C, w);
+        }), b;
+      }, b.done = function(g) {
+        o(g, []);
+      }, b.reset = function() {
+        s = {}, n = {}, r = {};
+      }, b.isDefined = function(g) {
+        return g in s;
+      }, b;
+    });
+  })(oe)), oe.exports;
+}
+var fi = pi(), gi = /* @__PURE__ */ di(fi);
+function $e(e) {
+  return new Promise((i, t) => {
+    gi(e, {
+      success: i,
+      error: t
+    });
+  });
+}
+function bi(e) {
+  if (a.empty(e))
+    return null;
+  if (a.number(Number(e)))
+    return e;
+  const i = /^.*(vimeo.com\/|video\/)(\d+).*/, t = e.match(i);
+  return t ? t[2] : e;
+}
+function yi(e) {
+  const i = /^.*(vimeo.com\/|video\/)(\d+)(\?.*h=|\/)+([\d,a-f]+)/, t = e.match(i);
+  return t && t.length === 5 ? t[4] : null;
+}
+function Q(e) {
+  e && !this.embed.hasPlayed && (this.embed.hasPlayed = !0), this.media.paused === e && (this.media.paused = !e, v.call(this, this.media, e ? "play" : "pause"));
+}
+const Ee = {
+  setup() {
+    const e = this;
+    E(e.elements.wrapper, e.config.classNames.embed, !0), e.options.speed = e.config.speed.options, X.call(e), a.object(window.Vimeo) ? Ee.ready.call(e) : $e(e.config.urls.vimeo.sdk).then(() => {
+      Ee.ready.call(e);
+    }).catch((i) => {
+      e.debug.warn("Vimeo SDK (player.js) failed to load", i);
+    });
+  },
+  // API Ready
+  ready() {
+    const e = this, i = e.config.vimeo, {
+      premium: t,
+      referrerPolicy: s,
+      ...n
+    } = i;
+    let r = e.media.getAttribute("src"), l = "";
+    a.empty(r) ? (r = e.media.getAttribute(e.config.attributes.embed.id), l = e.media.getAttribute(e.config.attributes.embed.hash)) : l = yi(r);
+    const o = l ? {
+      h: l
+    } : {};
+    t && Object.assign(n, {
+      controls: !1,
+      sidedock: !1
+    });
+    const c = ht({
+      loop: e.config.loop.active,
+      autoplay: e.autoplay,
+      muted: e.muted,
+      gesture: "media",
+      playsinline: e.config.playsinline,
+      // hash has to be added to iframe-URL
+      ...o,
+      ...n
+    }), u = bi(r), p = y("iframe"), b = Ae(e.config.urls.vimeo.iframe, u, c);
+    if (p.setAttribute("src", b), p.setAttribute("allowfullscreen", ""), p.setAttribute("allow", ["autoplay", "fullscreen", "picture-in-picture", "encrypted-media", "accelerometer", "gyroscope"].join("; ")), a.empty(s) || p.setAttribute("referrerPolicy", s), t || !i.customControls)
+      p.setAttribute("data-poster", e.poster), e.media = ue(p, e.media);
+    else {
+      const f = y("div", {
+        class: e.config.classNames.embedContainer,
+        "data-poster": e.poster
+      });
+      f.appendChild(p), e.media = ue(f, e.media);
+    }
+    i.customControls || ne(Ae(e.config.urls.vimeo.api, b)).then((f) => {
+      a.empty(f) || !f.thumbnail_url || S.setPoster.call(e, f.thumbnail_url).catch(() => {
+      });
+    }), e.embed = new window.Vimeo.Player(p, {
+      autopause: e.config.autopause,
+      muted: e.muted
+    }), e.media.paused = !0, e.media.currentTime = 0, e.supported.ui && e.embed.disableTextTrack(), e.media.play = () => (Q.call(e, !0), e.embed.play()), e.media.pause = () => (Q.call(e, !1), e.embed.pause()), e.media.stop = () => {
+      e.pause(), e.currentTime = 0;
+    };
+    let {
+      currentTime: h
+    } = e.media;
+    Object.defineProperty(e.media, "currentTime", {
+      get() {
+        return h;
+      },
+      set(f) {
+        const {
+          embed: k,
+          media: M,
+          paused: j,
+          volume: R
+        } = e, H = j && !k.hasPlayed;
+        M.seeking = !0, v.call(e, M, "seeking"), Promise.resolve(H && k.setVolume(0)).then(() => k.setCurrentTime(f)).then(() => H && k.pause()).then(() => H && k.setVolume(R)).catch(() => {
+        });
+      }
+    });
+    let g = e.config.speed.selected;
+    Object.defineProperty(e.media, "playbackRate", {
+      get() {
+        return g;
+      },
+      set(f) {
+        e.embed.setPlaybackRate(f).then(() => {
+          g = f, v.call(e, e.media, "ratechange");
+        }).catch(() => {
+          e.options.speed = [1];
+        });
+      }
+    });
+    let {
+      volume: C
+    } = e.config;
+    Object.defineProperty(e.media, "volume", {
+      get() {
+        return C;
+      },
+      set(f) {
+        e.embed.setVolume(f).then(() => {
+          C = f, v.call(e, e.media, "volumechange");
+        });
+      }
+    });
+    let {
+      muted: w
+    } = e.config;
+    Object.defineProperty(e.media, "muted", {
+      get() {
+        return w;
+      },
+      set(f) {
+        const k = a.boolean(f) ? f : !1;
+        e.embed.setMuted(k ? !0 : e.config.muted).then(() => {
+          w = k, v.call(e, e.media, "volumechange");
+        });
+      }
+    });
+    let {
+      loop: x
+    } = e.config;
+    Object.defineProperty(e.media, "loop", {
+      get() {
+        return x;
+      },
+      set(f) {
+        const k = a.boolean(f) ? f : e.config.loop.active;
+        e.embed.setLoop(k).then(() => {
+          x = k;
+        });
+      }
+    });
+    let P;
+    e.embed.getVideoUrl().then((f) => {
+      P = f, d.setDownloadUrl.call(e);
+    }).catch((f) => {
+      this.debug.warn(f);
+    }), Object.defineProperty(e.media, "currentSrc", {
+      get() {
+        return P;
+      }
+    }), Object.defineProperty(e.media, "ended", {
+      get() {
+        return e.currentTime === e.duration;
+      }
+    }), Promise.all([e.embed.getVideoWidth(), e.embed.getVideoHeight()]).then((f) => {
+      const [k, M] = f;
+      e.embed.ratio = at(k, M), X.call(this);
+    }), e.embed.setAutopause(e.config.autopause).then((f) => {
+      e.config.autopause = f;
+    }), e.embed.getVideoTitle().then((f) => {
+      e.config.title = f, S.setTitle.call(this);
+    }), e.embed.getCurrentTime().then((f) => {
+      h = f, v.call(e, e.media, "timeupdate");
+    }), e.embed.getDuration().then((f) => {
+      e.media.duration = f, v.call(e, e.media, "durationchange");
+    }), e.embed.getTextTracks().then((f) => {
+      e.media.textTracks = f, A.setup.call(e);
+    }), e.embed.on("cuechange", ({
+      cues: f = []
+    }) => {
+      const k = f.map((M) => ri(M.text));
+      A.updateCues.call(e, k);
+    }), e.embed.on("loaded", () => {
+      e.embed.getPaused().then((f) => {
+        Q.call(e, !f), f || v.call(e, e.media, "playing");
+      }), a.element(e.embed.element) && e.supported.ui && e.embed.element.setAttribute("tabindex", -1);
+    }), e.embed.on("bufferstart", () => {
+      v.call(e, e.media, "waiting");
+    }), e.embed.on("bufferend", () => {
+      v.call(e, e.media, "playing");
+    }), e.embed.on("play", () => {
+      Q.call(e, !0), v.call(e, e.media, "playing");
+    }), e.embed.on("pause", () => {
+      Q.call(e, !1);
+    }), e.embed.on("timeupdate", (f) => {
+      e.media.seeking = !1, h = f.seconds, v.call(e, e.media, "timeupdate");
+    }), e.embed.on("progress", (f) => {
+      e.media.buffered = f.percent, v.call(e, e.media, "progress"), Number.parseInt(f.percent, 10) === 1 && v.call(e, e.media, "canplaythrough"), e.embed.getDuration().then((k) => {
+        k !== e.media.duration && (e.media.duration = k, v.call(e, e.media, "durationchange"));
+      });
+    }), e.embed.on("seeked", () => {
+      e.media.seeking = !1, v.call(e, e.media, "seeked");
+    }), e.embed.on("ended", () => {
+      e.media.paused = !0, v.call(e, e.media, "ended");
+    }), e.embed.on("error", (f) => {
+      e.media.error = f, v.call(e, e.media, "error");
+    }), i.customControls && setTimeout(() => S.build.call(e), 0);
+  }
+};
+function vi(e) {
+  if (a.empty(e))
+    return null;
+  const i = /^.*(youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=|&v=)([^#&?]*).*/, t = e.match(i);
+  return t && t[2] ? t[2] : e;
+}
+function J(e) {
+  e && !this.embed.hasPlayed && (this.embed.hasPlayed = !0), this.media.paused === e && (this.media.paused = !e, v.call(this, this.media, e ? "play" : "pause"));
+}
+function wi(e) {
+  if (e.noCookie)
+    return "https://www.youtube-nocookie.com";
+  if (window.location.protocol === "http:")
+    return "http://www.youtube.com";
+}
+const ce = {
+  setup() {
+    if (E(this.elements.wrapper, this.config.classNames.embed, !0), a.object(window.YT) && a.function(window.YT.Player))
+      ce.ready.call(this);
+    else {
+      const e = window.onYouTubeIframeAPIReady;
+      window.onYouTubeIframeAPIReady = () => {
+        a.function(e) && e(), ce.ready.call(this);
+      }, $e(this.config.urls.youtube.sdk).catch((i) => {
+        this.debug.warn("YouTube API failed to load", i);
+      });
+    }
+  },
+  // Get the media title
+  getTitle(e) {
+    const i = Ae(this.config.urls.youtube.api, e);
+    ne(i).then((t) => {
+      if (a.object(t)) {
+        const {
+          title: s,
+          height: n,
+          width: r
+        } = t;
+        this.config.title = s, S.setTitle.call(this), this.embed.ratio = at(r, n);
+      }
+      X.call(this);
+    }).catch(() => {
+      X.call(this);
+    });
+  },
+  // API ready
+  ready() {
+    const e = this, i = e.config.youtube, t = e.media && e.media.getAttribute("id");
+    if (!a.empty(t) && t.startsWith("youtube-"))
+      return;
+    let s = e.media.getAttribute("src");
+    a.empty(s) && (s = e.media.getAttribute(this.config.attributes.embed.id));
+    const n = vi(s), r = ti(e.provider), l = y("div", {
+      id: r,
+      "data-poster": i.customControls ? e.poster : void 0
+    });
+    if (e.media = ue(l, e.media), i.customControls) {
+      const o = (c) => `https://i.ytimg.com/vi/${n}/${c}default.jpg`;
+      le(o("maxres"), 121).catch(() => le(o("sd"), 121)).catch(() => le(o("hq"))).then((c) => S.setPoster.call(e, c.src)).then((c) => {
+        c.includes("maxres") || (e.elements.poster.style.backgroundSize = "cover");
+      }).catch(() => {
+      });
+    }
+    e.embed = new window.YT.Player(e.media, {
+      videoId: n,
+      host: wi(i),
+      playerVars: L({}, {
+        // Autoplay
+        autoplay: e.config.autoplay ? 1 : 0,
+        // iframe interface language
+        hl: e.config.hl,
+        // Only show controls if not fully supported or opted out
+        controls: e.supported.ui && i.customControls ? 0 : 1,
+        // Disable keyboard as we handle it
+        disablekb: 1,
+        // Allow iOS inline playback
+        playsinline: e.config.playsinline && !e.config.fullscreen.iosNative ? 1 : 0,
+        // Captions are flaky on YouTube
+        cc_load_policy: e.captions.active ? 1 : 0,
+        cc_lang_pref: e.config.captions.language,
+        // Tracking for stats
+        widget_referrer: window ? window.location.href : null
+      }, i),
+      events: {
+        onError(o) {
+          if (!e.media.error) {
+            const c = o.data, u = {
+              2: "The request contains an invalid parameter value. For example, this error occurs if you specify a video ID that does not have 11 characters, or if the video ID contains invalid characters, such as exclamation points or asterisks.",
+              5: "The requested content cannot be played in an HTML5 player or another error related to the HTML5 player has occurred.",
+              100: "The video requested was not found. This error occurs when a video has been removed (for any reason) or has been marked as private.",
+              101: "The owner of the requested video does not allow it to be played in embedded players.",
+              150: "The owner of the requested video does not allow it to be played in embedded players."
+            }[c] || "An unknown error occurred";
+            e.media.error = {
+              code: c,
+              message: u
+            }, v.call(e, e.media, "error");
+          }
+        },
+        onPlaybackRateChange(o) {
+          const c = o.target;
+          e.media.playbackRate = c.getPlaybackRate(), v.call(e, e.media, "ratechange");
+        },
+        onReady(o) {
+          if (a.function(e.media.play))
+            return;
+          const c = o.target;
+          ce.getTitle.call(e, n), e.media.play = () => {
+            J.call(e, !0), c.playVideo();
+          }, e.media.pause = () => {
+            J.call(e, !1), c.pauseVideo();
+          }, e.media.stop = () => {
+            c.stopVideo();
+          }, e.media.duration = c.getDuration(), e.media.paused = !0, e.media.currentTime = 0, Object.defineProperty(e.media, "currentTime", {
+            get() {
+              return Number(c.getCurrentTime());
+            },
+            set(h) {
+              e.paused && !e.embed.hasPlayed && e.embed.mute(), e.media.seeking = !0, v.call(e, e.media, "seeking"), c.seekTo(h);
+            }
+          }), Object.defineProperty(e.media, "playbackRate", {
+            get() {
+              return c.getPlaybackRate();
+            },
+            set(h) {
+              c.setPlaybackRate(h);
+            }
+          });
+          let {
+            volume: u
+          } = e.config;
+          Object.defineProperty(e.media, "volume", {
+            get() {
+              return u;
+            },
+            set(h) {
+              u = h, c.setVolume(u * 100), v.call(e, e.media, "volumechange");
+            }
+          });
+          let {
+            muted: p
+          } = e.config;
+          Object.defineProperty(e.media, "muted", {
+            get() {
+              return p;
+            },
+            set(h) {
+              const g = a.boolean(h) ? h : p;
+              p = g, c[g ? "mute" : "unMute"](), c.setVolume(u * 100), v.call(e, e.media, "volumechange");
+            }
+          }), Object.defineProperty(e.media, "currentSrc", {
+            get() {
+              return c.getVideoUrl();
+            }
+          }), Object.defineProperty(e.media, "ended", {
+            get() {
+              return e.currentTime === e.duration;
+            }
+          });
+          const b = c.getAvailablePlaybackRates();
+          e.options.speed = b.filter((h) => e.config.speed.options.includes(h)), e.supported.ui && i.customControls && e.media.setAttribute("tabindex", -1), v.call(e, e.media, "timeupdate"), v.call(e, e.media, "durationchange"), clearInterval(e.timers.buffering), e.timers.buffering = setInterval(() => {
+            e.media.buffered = c.getVideoLoadedFraction(), (e.media.lastBuffered === null || e.media.lastBuffered < e.media.buffered) && v.call(e, e.media, "progress"), e.media.lastBuffered = e.media.buffered, e.media.buffered === 1 && (clearInterval(e.timers.buffering), v.call(e, e.media, "canplaythrough"));
+          }, 200), i.customControls && setTimeout(() => S.build.call(e), 50);
+        },
+        onStateChange(o) {
+          const c = o.target;
+          switch (clearInterval(e.timers.playing), e.media.seeking && [1, 2].includes(o.data) && (e.media.seeking = !1, v.call(e, e.media, "seeked")), o.data) {
+            case -1:
+              v.call(e, e.media, "timeupdate"), e.media.buffered = c.getVideoLoadedFraction(), v.call(e, e.media, "progress");
+              break;
+            case 0:
+              J.call(e, !1), e.media.loop ? (c.stopVideo(), c.playVideo()) : v.call(e, e.media, "ended");
+              break;
+            case 1:
+              i.customControls && !e.config.autoplay && e.media.paused && !e.embed.hasPlayed ? e.media.pause() : (J.call(e, !0), v.call(e, e.media, "playing"), e.timers.playing = setInterval(() => {
+                v.call(e, e.media, "timeupdate");
+              }, 50), e.media.duration !== c.getDuration() && (e.media.duration = c.getDuration(), v.call(e, e.media, "durationchange")));
+              break;
+            case 2:
+              e.muted || e.embed.unMute(), J.call(e, !1);
+              break;
+            case 3:
+              v.call(e, e.media, "waiting");
+              break;
+          }
+          v.call(e, e.elements.container, "statechange", !1, {
+            code: o.data
+          });
+        }
+      }
+    });
+  }
+}, mt = {
+  // Setup media
+  setup() {
+    if (!this.media) {
+      this.debug.warn("No media element found!");
+      return;
+    }
+    E(this.elements.container, this.config.classNames.type.replace("{0}", this.type), !0), E(this.elements.container, this.config.classNames.provider.replace("{0}", this.provider), !0), this.isEmbed && E(this.elements.container, this.config.classNames.type.replace("{0}", "video"), !0), this.isVideo && (this.elements.wrapper = y("div", {
+      class: this.config.classNames.video
+    }), it(this.media, this.elements.wrapper), this.elements.poster = y("div", {
+      class: this.config.classNames.poster
+    }), this.elements.wrapper.appendChild(this.elements.poster)), this.isHTML5 ? z.setup.call(this) : this.isYouTube ? ce.setup.call(this) : this.isVimeo && Ee.setup.call(this);
+  }
+};
+function ki(e) {
+  e.manager && e.manager.destroy(), e.elements.displayContainer && e.elements.displayContainer.destroy(), e.elements.container.remove();
+}
+class Ti {
+  /**
+   * Ads constructor.
+   * @param {object} player
+   * @return {Ads}
+   */
+  constructor(i) {
+    m(this, "load", () => {
+      this.enabled && (!a.object(window.google) || !a.object(window.google.ima) ? $e(this.player.config.urls.googleIMA.sdk).then(() => {
+        this.ready();
+      }).catch(() => {
+        this.trigger("error", new Error("Google IMA SDK failed to load"));
+      }) : this.ready());
+    }), m(this, "ready", () => {
+      this.enabled || ki(this), this.startSafetyTimer(12e3, "ready()"), this.managerPromise.then(() => {
+        this.clearSafetyTimer("onAdsManagerLoaded()");
+      }), this.listeners(), this.setupIMA();
+    }), m(this, "setupIMA", () => {
+      this.elements.container = y("div", {
+        class: this.player.config.classNames.ads
+      }), this.player.elements.container.appendChild(this.elements.container), google.ima.settings.setVpaidMode(google.ima.ImaSdkSettings.VpaidMode.ENABLED), google.ima.settings.setLocale(this.player.config.ads.language), google.ima.settings.setDisableCustomPlaybackForIOS10Plus(this.player.config.playsinline), this.elements.displayContainer = new google.ima.AdDisplayContainer(this.elements.container, this.player.media), this.loader = new google.ima.AdsLoader(this.elements.displayContainer), this.loader.addEventListener(google.ima.AdsManagerLoadedEvent.Type.ADS_MANAGER_LOADED, (t) => this.onAdsManagerLoaded(t), !1), this.loader.addEventListener(google.ima.AdErrorEvent.Type.AD_ERROR, (t) => this.onAdError(t), !1), this.requestAds();
+    }), m(this, "requestAds", () => {
+      const {
+        container: t
+      } = this.player.elements;
+      try {
+        const s = new google.ima.AdsRequest();
+        s.adTagUrl = this.tagUrl, s.linearAdSlotWidth = t.offsetWidth, s.linearAdSlotHeight = t.offsetHeight, s.nonLinearAdSlotWidth = t.offsetWidth, s.nonLinearAdSlotHeight = t.offsetHeight, s.forceNonLinearFullSlot = !1, s.setAdWillPlayMuted(!this.player.muted), this.loader.requestAds(s);
+      } catch (s) {
+        this.onAdError(s);
+      }
+    }), m(this, "pollCountdown", (t = !1) => {
+      if (!t) {
+        clearInterval(this.countdownTimer), this.elements.container.removeAttribute("data-badge-text");
+        return;
+      }
+      const s = () => {
+        const n = ge(Math.max(this.manager.getRemainingTime(), 0)), r = `${O.get("advertisement", this.player.config)} - ${n}`;
+        this.elements.container.setAttribute("data-badge-text", r);
+      };
+      this.countdownTimer = setInterval(s, 100);
+    }), m(this, "onAdsManagerLoaded", (t) => {
+      if (!this.enabled)
+        return;
+      const s = new google.ima.AdsRenderingSettings();
+      s.restoreCustomPlaybackStateOnAdBreakComplete = !0, s.enablePreloading = !0, this.manager = t.getAdsManager(this.player, s), this.cuePoints = this.manager.getCuePoints(), this.manager.addEventListener(google.ima.AdErrorEvent.Type.AD_ERROR, (n) => this.onAdError(n)), Object.keys(google.ima.AdEvent.Type).forEach((n) => {
+        this.manager.addEventListener(google.ima.AdEvent.Type[n], (r) => this.onAdEvent(r));
+      }), this.trigger("loaded");
+    }), m(this, "addCuePoints", () => {
+      a.empty(this.cuePoints) || this.cuePoints.forEach((t) => {
+        if (t !== 0 && t !== -1 && t < this.player.duration) {
+          const s = this.player.elements.progress;
+          if (a.element(s)) {
+            const n = 100 / this.player.duration * t, r = y("span", {
+              class: this.player.config.classNames.cues
+            });
+            r.style.left = `${n.toString()}%`, s.appendChild(r);
+          }
+        }
+      });
+    }), m(this, "onAdEvent", (t) => {
+      const {
+        container: s
+      } = this.player.elements, n = t.getAd(), r = t.getAdData();
+      switch (((o) => {
+        v.call(this.player, this.player.media, `ads${o.replace(/_/g, "").toLowerCase()}`);
+      })(t.type), t.type) {
+        case google.ima.AdEvent.Type.LOADED:
+          this.trigger("loaded"), this.pollCountdown(!0), n.isLinear() || (n.width = s.offsetWidth, n.height = s.offsetHeight);
+          break;
+        case google.ima.AdEvent.Type.STARTED:
+          this.manager.setVolume(this.player.volume);
+          break;
+        case google.ima.AdEvent.Type.ALL_ADS_COMPLETED:
+          this.player.ended ? this.loadAds() : this.loader.contentComplete();
+          break;
+        case google.ima.AdEvent.Type.CONTENT_PAUSE_REQUESTED:
+          this.pauseContent();
+          break;
+        case google.ima.AdEvent.Type.CONTENT_RESUME_REQUESTED:
+          this.pollCountdown(), this.resumeContent();
+          break;
+        case google.ima.AdEvent.Type.LOG:
+          r.adError && this.player.debug.warn(`Non-fatal ad error: ${r.adError.getMessage()}`);
+          break;
+      }
+    }), m(this, "onAdError", (t) => {
+      this.cancel(), this.player.debug.warn("Ads error", t);
+    }), m(this, "listeners", () => {
+      const {
+        container: t
+      } = this.player.elements;
+      let s;
+      this.player.on("canplay", () => {
+        this.addCuePoints();
+      }), this.player.on("ended", () => {
+        this.loader.contentComplete();
+      }), this.player.on("timeupdate", () => {
+        s = this.player.currentTime;
+      }), this.player.on("seeked", () => {
+        const n = this.player.currentTime;
+        a.empty(this.cuePoints) || this.cuePoints.forEach((r, l) => {
+          s < r && r < n && (this.manager.discardAdBreak(), this.cuePoints.splice(l, 1));
+        });
+      }), window.addEventListener("resize", () => {
+        this.manager && this.manager.resize(t.offsetWidth, t.offsetHeight, google.ima.ViewMode.NORMAL);
+      });
+    }), m(this, "play", () => {
+      const {
+        container: t
+      } = this.player.elements;
+      this.managerPromise || this.resumeContent(), this.managerPromise.then(() => {
+        this.manager.setVolume(this.player.volume), this.elements.displayContainer.initialize();
+        try {
+          this.initialized || (this.manager.init(t.offsetWidth, t.offsetHeight, google.ima.ViewMode.NORMAL), this.manager.start()), this.initialized = !0;
+        } catch (s) {
+          this.onAdError(s);
+        }
+      }).catch(() => {
+      });
+    }), m(this, "resumeContent", () => {
+      this.elements.container.style.zIndex = "", this.playing = !1, F(this.player.media.play());
+    }), m(this, "pauseContent", () => {
+      this.elements.container.style.zIndex = 3, this.playing = !0, this.player.media.pause();
+    }), m(this, "cancel", () => {
+      this.initialized && this.resumeContent(), this.trigger("error"), this.loadAds();
+    }), m(this, "loadAds", () => {
+      this.managerPromise.then(() => {
+        this.manager && this.manager.destroy(), this.managerPromise = new Promise((t) => {
+          this.on("loaded", t), this.player.debug.log(this.manager);
+        }), this.initialized = !1, this.requestAds();
+      }).catch(() => {
+      });
+    }), m(this, "trigger", (t, ...s) => {
+      const n = this.events[t];
+      a.array(n) && n.forEach((r) => {
+        a.function(r) && r.apply(this, s);
+      });
+    }), m(this, "on", (t, s) => (a.array(this.events[t]) || (this.events[t] = []), this.events[t].push(s), this)), m(this, "startSafetyTimer", (t, s) => {
+      this.player.debug.log(`Safety timer invoked from: ${s}`), this.safetyTimer = setTimeout(() => {
+        this.cancel(), this.clearSafetyTimer("startSafetyTimer()");
+      }, t);
+    }), m(this, "clearSafetyTimer", (t) => {
+      a.nullOrUndefined(this.safetyTimer) || (this.player.debug.log(`Safety timer cleared from: ${t}`), clearTimeout(this.safetyTimer), this.safetyTimer = null);
+    }), this.player = i, this.config = i.config.ads, this.playing = !1, this.initialized = !1, this.elements = {
+      container: null,
+      displayContainer: null
+    }, this.manager = null, this.loader = null, this.cuePoints = null, this.events = {}, this.safetyTimer = null, this.countdownTimer = null, this.managerPromise = new Promise((t, s) => {
+      this.on("loaded", t), this.on("error", s);
+    }), this.load();
+  }
+  get enabled() {
+    const {
+      config: i
+    } = this;
+    return this.player.isHTML5 && this.player.isVideo && i.enabled && (!a.empty(i.publisherId) || a.url(i.tagUrl));
+  }
+  // Build the tag URL
+  get tagUrl() {
+    const {
+      config: i
+    } = this;
+    if (a.url(i.tagUrl))
+      return i.tagUrl;
+    const t = {
+      AV_PUBLISHERID: "58c25bb0073ef448b1087ad6",
+      AV_CHANNELID: "5a0458dc28a06145e4519d21",
+      AV_URL: window.location.hostname,
+      cb: Date.now(),
+      AV_WIDTH: 640,
+      AV_HEIGHT: 480,
+      AV_CDIM2: i.publisherId
+    };
+    return `https://go.aniview.com/api/adserver6/vast/?${ht(t)}`;
+  }
+}
+function pt(e = 0, i = 0, t = 255) {
+  return Math.min(Math.max(e, i), t);
+}
+function Ci(e) {
+  const i = [];
+  return e.split(/\r\n\r\n|\n\n|\r\r/).forEach((s) => {
+    const n = {};
+    s.split(/\r\n|\n|\r/).forEach((l) => {
+      if (a.number(n.startTime)) {
+        if (!a.empty(l.trim()) && a.empty(n.text)) {
+          const o = l.trim().split("#xywh=");
+          [n.text] = o, o[1] && ([n.x, n.y, n.w, n.h] = o[1].split(","));
+        }
+      } else {
+        const o = l.match(/(\d{2})?:?(\d{2}):(\d{2}).(\d{2,3})( ?--> ?)(\d{2})?:?(\d{2}):(\d{2}).(\d{2,3})/);
+        o && (n.startTime = Number(o[1] || 0) * 60 * 60 + Number(o[2]) * 60 + Number(o[3]) + +`0.${o[4]}`, n.endTime = Number(o[6] || 0) * 60 * 60 + Number(o[7]) * 60 + Number(o[8]) + +`0.${o[9]}`);
+      }
+    }), n.text && i.push(n);
+  }), i;
+}
+function Ue(e, i) {
+  const t = i.width / i.height, s = {};
+  return e > t ? (s.width = i.width, s.height = 1 / e * i.width) : (s.height = i.height, s.width = e * i.height), s;
+}
+class Se {
+  /**
+   * PreviewThumbnails constructor.
+   * @param {Plyr} player
+   * @return {PreviewThumbnails}
+   */
+  constructor(i) {
+    m(this, "load", () => {
+      this.player.elements.display.seekTooltip && (this.player.elements.display.seekTooltip.hidden = this.enabled), this.enabled && this.getThumbnails().then(() => {
+        this.enabled && (this.render(), this.determineContainerAutoSizing(), this.listeners(), this.loaded = !0);
+      });
+    }), m(this, "getThumbnails", () => new Promise((t) => {
+      const {
+        src: s
+      } = this.player.config.previewThumbnails;
+      if (a.empty(s))
+        throw new Error("Missing previewThumbnails.src config attribute");
+      const n = () => {
+        this.thumbnails.sort((r, l) => r.height - l.height), this.player.debug.log("Preview thumbnails", this.thumbnails), t();
+      };
+      if (a.function(s))
+        s((r) => {
+          this.thumbnails = r, n();
+        });
+      else {
+        const l = (a.string(s) ? [s] : s).map((o) => this.getThumbnail(o));
+        Promise.all(l).then(n);
+      }
+    })), m(this, "getThumbnail", (t) => new Promise((s) => {
+      ne(t, void 0, this.player.config.previewThumbnails.withCredentials).then((n) => {
+        const r = {
+          frames: Ci(n),
+          height: null,
+          urlPrefix: ""
+        };
+        !r.frames[0].text.startsWith("/") && !r.frames[0].text.startsWith("http://") && !r.frames[0].text.startsWith("https://") && (r.urlPrefix = t.substring(0, t.lastIndexOf("/") + 1));
+        const l = new Image();
+        l.onload = () => {
+          r.height = l.naturalHeight, r.width = l.naturalWidth, this.thumbnails.push(r), s();
+        }, l.src = r.urlPrefix + r.frames[0].text;
+      });
+    })), m(this, "startMove", (t) => {
+      if (this.loaded && !(!a.event(t) || !["touchmove", "mousemove"].includes(t.type)) && this.player.media.duration) {
+        if (t.type === "touchmove")
+          this.seekTime = this.player.media.duration * (this.player.elements.inputs.seek.value / 100);
+        else {
+          var s, n;
+          const r = this.player.elements.progress.getBoundingClientRect(), l = 100 / r.width * (t.pageX - r.left);
+          this.seekTime = this.player.media.duration * (l / 100), this.seekTime < 0 && (this.seekTime = 0), this.seekTime > this.player.media.duration - 1 && (this.seekTime = this.player.media.duration - 1), this.mousePosX = t.pageX, this.elements.thumb.time.textContent = ge(this.seekTime);
+          const o = (s = this.player.config.markers) === null || s === void 0 || (n = s.points) === null || n === void 0 ? void 0 : n.find(({
+            time: c
+          }) => c === Math.round(this.seekTime));
+          o && this.elements.thumb.time.insertAdjacentHTML("afterbegin", `${o.label}<br>`);
+        }
+        this.showImageAtCurrentTime();
+      }
+    }), m(this, "endMove", () => {
+      this.toggleThumbContainer(!1, !0);
+    }), m(this, "startScrubbing", (t) => {
+      (a.nullOrUndefined(t.button) || t.button === !1 || t.button === 0) && (this.mouseDown = !0, this.player.media.duration && (this.toggleScrubbingContainer(!0), this.toggleThumbContainer(!1, !0), this.showImageAtCurrentTime()));
+    }), m(this, "endScrubbing", () => {
+      this.mouseDown = !1, Math.ceil(this.lastTime) === Math.ceil(this.player.media.currentTime) ? this.toggleScrubbingContainer(!1) : xe.call(this.player, this.player.media, "timeupdate", () => {
+        this.mouseDown || this.toggleScrubbingContainer(!1);
+      });
+    }), m(this, "listeners", () => {
+      this.player.on("play", () => {
+        this.toggleThumbContainer(!1, !0);
+      }), this.player.on("seeked", () => {
+        this.toggleThumbContainer(!1);
+      }), this.player.on("timeupdate", () => {
+        this.lastTime = this.player.media.currentTime;
+      });
+    }), m(this, "render", () => {
+      this.elements.thumb.container = y("div", {
+        class: this.player.config.classNames.previewThumbnails.thumbContainer
+      }), this.elements.thumb.imageContainer = y("div", {
+        class: this.player.config.classNames.previewThumbnails.imageContainer
+      }), this.elements.thumb.container.appendChild(this.elements.thumb.imageContainer);
+      const t = y("div", {
+        class: this.player.config.classNames.previewThumbnails.timeContainer
+      });
+      this.elements.thumb.time = y("span", {}, "00:00"), t.appendChild(this.elements.thumb.time), this.elements.thumb.imageContainer.appendChild(t), a.element(this.player.elements.progress) && this.player.elements.progress.appendChild(this.elements.thumb.container), this.elements.scrubbing.container = y("div", {
+        class: this.player.config.classNames.previewThumbnails.scrubbingContainer
+      }), this.player.elements.wrapper.appendChild(this.elements.scrubbing.container);
+    }), m(this, "destroy", () => {
+      this.elements.thumb.container && this.elements.thumb.container.remove(), this.elements.scrubbing.container && this.elements.scrubbing.container.remove();
+    }), m(this, "showImageAtCurrentTime", () => {
+      this.mouseDown ? this.setScrubbingContainerSize() : this.setThumbContainerSizeAndPos();
+      const t = this.thumbnails[0].frames.findIndex((r) => this.seekTime >= r.startTime && this.seekTime <= r.endTime), s = t >= 0;
+      let n = 0;
+      this.mouseDown || this.toggleThumbContainer(s), s && (this.thumbnails.forEach((r, l) => {
+        this.loadedImages.includes(r.frames[t].text) && (n = l);
+      }), t !== this.showingThumb && (this.showingThumb = t, this.loadImage(n)));
+    }), m(this, "loadImage", (t = 0) => {
+      const s = this.showingThumb, n = this.thumbnails[t], {
+        urlPrefix: r
+      } = n, l = n.frames[s], o = n.frames[s].text, c = r + o;
+      if (!this.currentImageElement || this.currentImageElement.dataset.filename !== o) {
+        this.loadingImage && this.usingSprites && (this.loadingImage.onload = null);
+        const u = new Image();
+        u.src = c, u.dataset.index = s, u.dataset.filename = o, this.showingThumbFilename = o, this.player.debug.log(`Loading image: ${c}`), u.onload = () => this.showImage(u, l, t, s, o, !0), this.loadingImage = u, this.removeOldImages(u);
+      } else
+        this.showImage(this.currentImageElement, l, t, s, o, !1), this.currentImageElement.dataset.index = s, this.removeOldImages(this.currentImageElement);
+    }), m(this, "showImage", (t, s, n, r, l, o = !0) => {
+      this.player.debug.log(`Showing thumb: ${l}. num: ${r}. qual: ${n}. newimg: ${o}`), this.setImageSizeAndOffset(t, s), o && (this.currentImageContainer.appendChild(t), this.currentImageElement = t, this.loadedImages.includes(l) || this.loadedImages.push(l)), this.preloadNearby(r, !0).then(this.preloadNearby(r, !1)).then(this.getHigherQuality(n, t, s, l));
+    }), m(this, "removeOldImages", (t) => {
+      Array.from(this.currentImageContainer.children).forEach((s) => {
+        if (s.tagName.toLowerCase() !== "img")
+          return;
+        const n = this.usingSprites ? 500 : 1e3;
+        if (s.dataset.index !== t.dataset.index && !s.dataset.deleting) {
+          s.dataset.deleting = !0;
+          const {
+            currentImageContainer: r
+          } = this;
+          setTimeout(() => {
+            r.removeChild(s), this.player.debug.log(`Removing thumb: ${s.dataset.filename}`);
+          }, n);
+        }
+      });
+    }), m(this, "preloadNearby", (t, s = !0) => new Promise((n) => {
+      setTimeout(() => {
+        const r = this.thumbnails[0].frames[t].text;
+        if (this.showingThumbFilename === r) {
+          let l;
+          s ? l = this.thumbnails[0].frames.slice(t) : l = this.thumbnails[0].frames.slice(0, t).reverse();
+          let o = !1;
+          l.forEach((c) => {
+            const u = c.text;
+            if (u !== r && !this.loadedImages.includes(u)) {
+              o = !0, this.player.debug.log(`Preloading thumb filename: ${u}`);
+              const {
+                urlPrefix: p
+              } = this.thumbnails[0], b = p + u, h = new Image();
+              h.src = b, h.onload = () => {
+                this.player.debug.log(`Preloaded thumb filename: ${u}`), this.loadedImages.includes(u) || this.loadedImages.push(u), n();
+              };
+            }
+          }), o || n();
+        }
+      }, 300);
+    })), m(this, "getHigherQuality", (t, s, n, r) => {
+      if (t < this.thumbnails.length - 1) {
+        let l = s.naturalHeight;
+        this.usingSprites && (l = n.h), l < this.thumbContainerHeight && setTimeout(() => {
+          this.showingThumbFilename === r && (this.player.debug.log(`Showing higher quality thumb for: ${r}`), this.loadImage(t + 1));
+        }, 300);
+      }
+    }), m(this, "toggleThumbContainer", (t = !1, s = !1) => {
+      const n = this.player.config.classNames.previewThumbnails.thumbContainerShown;
+      this.elements.thumb.container.classList.toggle(n, t), !t && s && (this.showingThumb = null, this.showingThumbFilename = null);
+    }), m(this, "toggleScrubbingContainer", (t = !1) => {
+      const s = this.player.config.classNames.previewThumbnails.scrubbingContainerShown;
+      this.elements.scrubbing.container.classList.toggle(s, t), t || (this.showingThumb = null, this.showingThumbFilename = null);
+    }), m(this, "determineContainerAutoSizing", () => {
+      (this.elements.thumb.imageContainer.clientHeight > 20 || this.elements.thumb.imageContainer.clientWidth > 20) && (this.sizeSpecifiedInCSS = !0);
+    }), m(this, "setThumbContainerSizeAndPos", () => {
+      const {
+        imageContainer: t
+      } = this.elements.thumb;
+      if (this.sizeSpecifiedInCSS) {
+        if (t.clientHeight > 20 && t.clientWidth < 20) {
+          const s = Math.floor(t.clientHeight * this.thumbAspectRatio);
+          t.style.width = `${s}px`;
+        } else if (t.clientHeight < 20 && t.clientWidth > 20) {
+          const s = Math.floor(t.clientWidth / this.thumbAspectRatio);
+          t.style.height = `${s}px`;
+        }
+      } else {
+        const s = Math.floor(this.thumbContainerHeight * this.thumbAspectRatio);
+        t.style.height = `${this.thumbContainerHeight}px`, t.style.width = `${s}px`;
+      }
+      this.setThumbContainerPos();
+    }), m(this, "setThumbContainerPos", () => {
+      const t = this.player.elements.progress.getBoundingClientRect(), s = this.player.elements.container.getBoundingClientRect(), {
+        container: n
+      } = this.elements.thumb, r = s.left - t.left + 10, l = s.right - t.left - n.clientWidth - 10, o = this.mousePosX - t.left - n.clientWidth / 2, c = pt(o, r, l);
+      n.style.left = `${c}px`, n.style.setProperty("--preview-arrow-offset", `${o - c}px`);
+    }), m(this, "setScrubbingContainerSize", () => {
+      const {
+        width: t,
+        height: s
+      } = Ue(this.thumbAspectRatio, {
+        width: this.player.media.clientWidth,
+        height: this.player.media.clientHeight
+      });
+      this.elements.scrubbing.container.style.width = `${t}px`, this.elements.scrubbing.container.style.height = `${s}px`;
+    }), m(this, "setImageSizeAndOffset", (t, s) => {
+      if (!this.usingSprites) return;
+      const n = this.thumbContainerHeight / s.h;
+      t.style.height = `${t.naturalHeight * n}px`, t.style.width = `${t.naturalWidth * n}px`, t.style.left = `-${s.x * n}px`, t.style.top = `-${s.y * n}px`;
+    }), this.player = i, this.thumbnails = [], this.loaded = !1, this.lastMouseMoveTime = Date.now(), this.mouseDown = !1, this.loadedImages = [], this.elements = {
+      thumb: {},
+      scrubbing: {}
+    }, this.load();
+  }
+  get enabled() {
+    return this.player.isHTML5 && this.player.isVideo && this.player.config.previewThumbnails.enabled;
+  }
+  get currentImageContainer() {
+    return this.mouseDown ? this.elements.scrubbing.container : this.elements.thumb.imageContainer;
+  }
+  get usingSprites() {
+    return Object.keys(this.thumbnails[0].frames[0]).includes("w");
+  }
+  get thumbAspectRatio() {
+    return this.usingSprites ? this.thumbnails[0].frames[0].w / this.thumbnails[0].frames[0].h : this.thumbnails[0].width / this.thumbnails[0].height;
+  }
+  get thumbContainerHeight() {
+    if (this.mouseDown) {
+      const {
+        height: i
+      } = Ue(this.thumbAspectRatio, {
+        width: this.player.media.clientWidth,
+        height: this.player.media.clientHeight
+      });
+      return i;
+    }
+    return this.sizeSpecifiedInCSS ? this.elements.thumb.imageContainer.clientHeight : Math.floor(this.player.media.clientWidth / this.thumbAspectRatio / 4);
+  }
+  get currentImageElement() {
+    return this.mouseDown ? this.currentScrubbingImageElement : this.currentThumbnailImageElement;
+  }
+  set currentImageElement(i) {
+    this.mouseDown ? this.currentScrubbingImageElement = i : this.currentThumbnailImageElement = i;
+  }
+}
+const Pe = {
+  // Add elements to HTML5 media (source, tracks, etc)
+  insertElements(e, i) {
+    a.string(i) ? Re(e, this.media, {
+      src: i
+    }) : a.array(i) && i.forEach((t) => {
+      Re(e, this.media, t);
+    });
+  },
+  // Update source
+  // Sources are not checked for support so be careful
+  change(e) {
+    if (!tt(e, "sources.length")) {
+      this.debug.warn("Invalid source format");
+      return;
+    }
+    z.cancelRequests.call(this), this.destroy(() => {
+      this.options.quality = [], U(this.media), this.media = null, a.element(this.elements.container) && this.elements.container.removeAttribute("class");
+      const {
+        sources: i,
+        type: t
+      } = e, [{
+        provider: s = W.html5,
+        src: n
+      }] = i, r = s === "html5" ? t : "div", l = s === "html5" ? {} : {
+        src: n
+      };
+      Object.assign(this, {
+        provider: s,
+        type: t,
+        // Check for support
+        supported: $.check(t, s, this.config.playsinline),
+        // Create new element
+        media: y(r, l)
+      }), this.elements.container.appendChild(this.media), a.boolean(e.autoplay) && (this.config.autoplay = e.autoplay), this.isHTML5 && (this.config.crossorigin && this.media.setAttribute("crossorigin", ""), this.config.autoplay && this.media.setAttribute("autoplay", ""), a.empty(e.poster) || (this.poster = e.poster), this.config.loop.active && this.media.setAttribute("loop", ""), this.config.muted && this.media.setAttribute("muted", ""), this.config.playsinline && this.media.setAttribute("playsinline", "")), S.addStyleHook.call(this), this.isHTML5 && Pe.insertElements.call(this, "source", i), this.config.title = e.title, mt.setup.call(this), this.isHTML5 && Object.keys(e).includes("tracks") && Pe.insertElements.call(this, "track", e.tracks), (this.isHTML5 || this.isEmbed && !this.supported.ui) && S.build.call(this), this.isHTML5 && this.media.load(), a.empty(e.previewThumbnails) || (Object.assign(this.config.previewThumbnails, e.previewThumbnails), this.previewThumbnails && this.previewThumbnails.loaded && (this.previewThumbnails.destroy(), this.previewThumbnails = null), this.config.previewThumbnails.enabled && (this.previewThumbnails = new Se(this))), this.fullscreen.update();
+    }, !0);
+  }
+};
+class me {
+  constructor(i, t) {
+    if (m(this, "play", () => a.function(this.media.play) ? (this.ads && this.ads.enabled && this.ads.managerPromise.then(() => this.ads.play()).catch(() => F(this.media.play())), this.media.play()) : null), m(this, "pause", () => !this.playing || !a.function(this.media.pause) ? null : this.media.pause()), m(this, "togglePlay", (o) => (a.boolean(o) ? o : !this.playing) ? this.play() : this.pause()), m(this, "stop", () => {
+      this.isHTML5 ? (this.pause(), this.restart()) : a.function(this.media.stop) && this.media.stop();
+    }), m(this, "restart", () => {
+      this.currentTime = 0;
+    }), m(this, "rewind", (o) => {
+      this.currentTime -= a.number(o) ? o : this.config.seekTime;
+    }), m(this, "forward", (o) => {
+      this.currentTime += a.number(o) ? o : this.config.seekTime;
+    }), m(this, "increaseVolume", (o) => {
+      const c = this.media.muted ? 0 : this.volume;
+      this.volume = c + (a.number(o) ? o : 0);
+    }), m(this, "decreaseVolume", (o) => {
+      this.increaseVolume(-o);
+    }), m(this, "airplay", () => {
+      $.airplay && this.media.webkitShowPlaybackTargetPicker();
+    }), m(this, "toggleControls", (o) => {
+      if (this.supported.ui && !this.isAudio) {
+        const c = he(this.elements.container, this.config.classNames.hideControls), u = typeof o > "u" ? void 0 : !o, p = E(this.elements.container, this.config.classNames.hideControls, u);
+        if (p && a.array(this.config.controls) && this.config.controls.includes("settings") && !a.empty(this.config.settings) && d.toggleMenu.call(this, !1), p !== c) {
+          const b = p ? "controlshidden" : "controlsshown";
+          v.call(this, this.media, b);
+        }
+        return !p;
+      }
+      return !1;
+    }), m(this, "on", (o, c) => {
+      T.call(this, this.elements.container, o, c);
+    }), m(this, "once", (o, c) => {
+      xe.call(this, this.elements.container, o, c);
+    }), m(this, "off", (o, c) => {
+      fe(this.elements.container, o, c);
+    }), m(this, "destroy", (o, c = !1) => {
+      if (!this.ready)
+        return;
+      const u = () => {
+        document.body.style.overflow = "", this.embed = null, c ? (Object.keys(this.elements).length && (U(this.elements.buttons.play), U(this.elements.captions), U(this.elements.controls), U(this.elements.wrapper), this.elements.buttons.play = null, this.elements.captions = null, this.elements.controls = null, this.elements.wrapper = null), a.function(o) && o()) : (Kt.call(this), z.cancelRequests.call(this), ue(this.elements.original, this.elements.container), v.call(this, this.elements.original, "destroyed", !0), a.function(o) && o.call(this.elements.original), this.ready = !1, setTimeout(() => {
+          this.elements = null, this.media = null;
+        }, 200));
+      };
+      this.stop(), clearTimeout(this.timers.loading), clearTimeout(this.timers.controls), clearTimeout(this.timers.resized), this.isHTML5 ? (S.toggleNativeControls.call(this, !0), u()) : this.isYouTube ? (clearInterval(this.timers.buffering), clearInterval(this.timers.playing), this.embed !== null && a.function(this.embed.destroy) && this.embed.destroy(), u()) : this.isVimeo && (this.embed !== null && this.embed.unload().then(u), setTimeout(u, 200));
+    }), m(this, "supports", (o) => $.mime.call(this, o)), this.timers = {}, this.ready = !1, this.loading = !1, this.failed = !1, this.touch = $.touch, this.media = i, a.string(this.media) && (this.media = document.querySelectorAll(this.media)), (window.jQuery && this.media instanceof jQuery || a.nodeList(this.media) || a.array(this.media)) && (this.media = this.media[0]), this.config = L({}, dt, me.defaults, t || {}, (() => {
+      try {
+        return JSON.parse(this.media.getAttribute("data-plyr-config"));
+      } catch {
+        return {};
+      }
+    })()), this.elements = {
+      container: null,
+      fullscreen: null,
+      captions: null,
+      buttons: {},
+      display: {},
+      progress: {},
+      inputs: {},
+      settings: {
+        popup: null,
+        menu: null,
+        panels: {},
+        buttons: {}
+      }
+    }, this.captions = {
+      active: null,
+      currentTrack: -1,
+      meta: /* @__PURE__ */ new WeakMap()
+    }, this.fullscreen = {
+      active: !1
+    }, this.options = {
+      speed: [],
+      quality: []
+    }, this.debug = new ui(this.config.debug), this.debug.log("Config", this.config), this.debug.log("Support", $), a.nullOrUndefined(this.media) || !a.element(this.media)) {
+      this.debug.error("Setup failed: no suitable element passed");
+      return;
+    }
+    if (this.media.plyr) {
+      this.debug.warn("Target already setup");
+      return;
+    }
+    if (!this.config.enabled) {
+      this.debug.error("Setup failed: disabled by config");
+      return;
+    }
+    if (!$.check().api) {
+      this.debug.error("Setup failed: no support");
+      return;
+    }
+    const s = this.media.cloneNode(!0);
+    s.autoplay = !1, this.elements.original = s;
+    const n = this.media.tagName.toLowerCase();
+    let r = null, l = null;
+    switch (n) {
+      case "div":
+        if (r = this.media.querySelector("iframe"), a.element(r)) {
+          if (l = ut(r.getAttribute("src")), this.provider = ci(l.toString()), this.elements.container = this.media, this.media = r, this.elements.container.className = "", l.search.length) {
+            const o = ["1", "true"];
+            o.includes(l.searchParams.get("autoplay")) && (this.config.autoplay = !0), o.includes(l.searchParams.get("loop")) && (this.config.loop.active = !0), this.isYouTube ? (this.config.playsinline = o.includes(l.searchParams.get("playsinline")), this.config.youtube.hl = l.searchParams.get("hl")) : this.config.playsinline = !0;
+          }
+        } else
+          this.provider = this.media.getAttribute(this.config.attributes.embed.provider), this.media.removeAttribute(this.config.attributes.embed.provider);
+        if (a.empty(this.provider) || !Object.values(W).includes(this.provider)) {
+          this.debug.error("Setup failed: Invalid provider");
+          return;
+        }
+        this.type = ve.video;
+        break;
+      case "video":
+      case "audio":
+        this.type = n, this.provider = W.html5, this.media.hasAttribute("crossorigin") && (this.config.crossorigin = !0), this.media.hasAttribute("autoplay") && (this.config.autoplay = !0), (this.media.hasAttribute("playsinline") || this.media.hasAttribute("webkit-playsinline")) && (this.config.playsinline = !0), this.media.hasAttribute("muted") && (this.config.muted = !0), this.media.hasAttribute("loop") && (this.config.loop.active = !0);
+        break;
+      default:
+        this.debug.error("Setup failed: unsupported type");
+        return;
+    }
+    if (this.supported = $.check(this.type, this.provider), !this.supported.api) {
+      this.debug.error("Setup failed: no support");
+      return;
+    }
+    this.eventListeners = [], this.listeners = new hi(this), this.storage = new te(this), this.media.plyr = this, a.element(this.elements.container) || (this.elements.container = y("div"), it(this.media, this.elements.container)), S.migrateStyles.call(this), S.addStyleHook.call(this), mt.setup.call(this), this.config.debug && T.call(this, this.elements.container, this.config.events.join(" "), (o) => {
+      this.debug.log(`event: ${o.type}`);
+    }), this.fullscreen = new q(this), (this.isHTML5 || this.isEmbed && !this.supported.ui) && S.build.call(this), this.listeners.container(), this.listeners.global(), this.config.ads.enabled && (this.ads = new Ti(this)), this.isHTML5 && this.config.autoplay && this.once("canplay", () => F(this.play())), this.lastSeekTime = 0, this.config.previewThumbnails.enabled && (this.previewThumbnails = new Se(this));
+  }
+  // ---------------------------------------
+  // API
+  // ---------------------------------------
+  /**
+   * Types and provider helpers
+   */
+  get isHTML5() {
+    return this.provider === W.html5;
+  }
+  get isEmbed() {
+    return this.isYouTube || this.isVimeo;
+  }
+  get isYouTube() {
+    return this.provider === W.youtube;
+  }
+  get isVimeo() {
+    return this.provider === W.vimeo;
+  }
+  get isVideo() {
+    return this.type === ve.video;
+  }
+  get isAudio() {
+    return this.type === ve.audio;
+  }
+  /**
+   * Get playing state
+   */
+  get playing() {
+    return !!(this.ready && !this.paused && !this.ended);
+  }
+  /**
+   * Get paused state
+   */
+  get paused() {
+    return !!this.media.paused;
+  }
+  /**
+   * Get stopped state
+   */
+  get stopped() {
+    return !!(this.paused && this.currentTime === 0);
+  }
+  /**
+   * Get ended state
+   */
+  get ended() {
+    return !!this.media.ended;
+  }
+  /**
+   * Seek to a time
+   * @param {number} input - where to seek to in seconds. Defaults to 0 (the start)
+   */
+  set currentTime(i) {
+    if (!this.duration)
+      return;
+    const t = a.number(i) && i > 0;
+    this.media.currentTime = t ? Math.min(i, this.duration) : 0, this.debug.log(`Seeking to ${this.currentTime} seconds`);
+  }
+  /**
+   * Get current time
+   */
+  get currentTime() {
+    return Number(this.media.currentTime);
+  }
+  /**
+   * Get buffered
+   */
+  get buffered() {
+    const {
+      buffered: i
+    } = this.media;
+    return a.number(i) ? i : i && i.length && this.duration > 0 ? i.end(0) / this.duration : 0;
+  }
+  /**
+   * Get seeking status
+   */
+  get seeking() {
+    return !!this.media.seeking;
+  }
+  /**
+   * Get the duration of the current media
+   */
+  get duration() {
+    const i = Number.parseFloat(this.config.duration), t = (this.media || {}).duration, s = !a.number(t) || t === 1 / 0 ? 0 : t;
+    return i || s;
+  }
+  /**
+   * Set the player volume
+   * @param {number} value - must be between 0 and 1. Defaults to the value from local storage and config.volume if not set in storage
+   */
+  set volume(i) {
+    let t = i;
+    const s = 1, n = 0;
+    a.string(t) && (t = Number(t)), a.number(t) || (t = this.storage.get("volume")), a.number(t) || ({
+      volume: t
+    } = this.config), t > s && (t = s), t < n && (t = n), this.config.volume = t, this.media.volume = t, !a.empty(i) && this.muted && t > 0 && (this.muted = !1);
+  }
+  /**
+   * Get the current player volume
+   */
+  get volume() {
+    return Number(this.media.volume);
+  }
+  /**
+   * Set muted state
+   * @param {boolean} mute
+   */
+  set muted(i) {
+    let t = i;
+    a.boolean(t) || (t = this.storage.get("muted")), a.boolean(t) || (t = this.config.muted), this.config.muted = t, this.media.muted = t;
+  }
+  /**
+   * Get current muted state
+   */
+  get muted() {
+    return !!this.media.muted;
+  }
+  /**
+   * Check if the media has audio
+   */
+  get hasAudio() {
+    return !this.isHTML5 || this.isAudio ? !0 : !!this.media.mozHasAudio || !!this.media.webkitAudioDecodedByteCount || !!(this.media.audioTracks && this.media.audioTracks.length);
+  }
+  /**
+   * Set playback speed
+   * @param {number} input - the speed of playback (0.5-2.0)
+   */
+  set speed(i) {
+    let t = null;
+    a.number(i) && (t = i), a.number(t) || (t = this.storage.get("speed")), a.number(t) || (t = this.config.speed.selected);
+    const {
+      minimumSpeed: s,
+      maximumSpeed: n
+    } = this;
+    t = pt(t, s, n), this.config.speed.selected = t, setTimeout(() => {
+      this.media && (this.media.playbackRate = t);
+    }, 0);
+  }
+  /**
+   * Get current playback speed
+   */
+  get speed() {
+    return Number(this.media.playbackRate);
+  }
+  /**
+   * Get the minimum allowed speed
+   */
+  get minimumSpeed() {
+    return this.isYouTube ? Math.min(...this.options.speed) : this.isVimeo ? 0.5 : 0.0625;
+  }
+  /**
+   * Get the maximum allowed speed
+   */
+  get maximumSpeed() {
+    return this.isYouTube ? Math.max(...this.options.speed) : this.isVimeo ? 2 : 16;
+  }
+  /**
+   * Set playback quality
+   * Currently HTML5 & YouTube only
+   * @param {number} input - Quality level
+   */
+  set quality(i) {
+    const t = this.config.quality, s = this.options.quality;
+    if (!s.length)
+      return;
+    let n = [!a.empty(i) && Number(i), this.storage.get("quality"), t.selected, t.default].find(a.number), r = !0;
+    if (!s.includes(n)) {
+      const l = st(s, n);
+      this.debug.warn(`Unsupported quality option: ${n}, using ${l} instead`), n = l, r = !1;
+    }
+    t.selected = n, this.media.quality = n, r && this.storage.set({
+      quality: n
+    });
+  }
+  /**
+   * Get current quality level
+   */
+  get quality() {
+    return this.media.quality;
+  }
+  /**
+   * Toggle loop
+   * TODO: Finish fancy new logic. Set the indicator on load as user may pass loop as config
+   * @param {boolean} input - Whether to loop or not
+   */
+  set loop(i) {
+    const t = a.boolean(i) ? i : this.config.loop.active;
+    this.config.loop.active = t, this.media.loop = t;
+  }
+  /**
+   * Get current loop state
+   */
+  get loop() {
+    return !!this.media.loop;
+  }
+  /**
+   * Set new media source
+   * @param {object} input - The new source object (see docs)
+   */
+  set source(i) {
+    Pe.change.call(this, i);
+  }
+  /**
+   * Get current source
+   */
+  get source() {
+    return this.media.currentSrc;
+  }
+  /**
+   * Get a download URL (either source or custom)
+   */
+  get download() {
+    const {
+      download: i
+    } = this.config.urls;
+    return a.url(i) ? i : this.source;
+  }
+  /**
+   * Set the download URL
+   */
+  set download(i) {
+    a.url(i) && (this.config.urls.download = i, d.setDownloadUrl.call(this));
+  }
+  /**
+   * Set the poster image for a video
+   * @param {string} input - the URL for the new poster image
+   */
+  set poster(i) {
+    if (!this.isVideo) {
+      this.debug.warn("Poster can only be set for video");
+      return;
+    }
+    S.setPoster.call(this, i, !1).catch(() => {
+    });
+  }
+  /**
+   * Get the current poster image
+   */
+  get poster() {
+    return this.isVideo ? this.media.getAttribute("poster") || this.media.getAttribute("data-poster") : null;
+  }
+  /**
+   * Get the current aspect ratio in use
+   */
+  get ratio() {
+    if (!this.isVideo)
+      return null;
+    const i = de(Le.call(this));
+    return a.array(i) ? i.join(":") : i;
+  }
+  /**
+   * Set video aspect ratio
+   */
+  set ratio(i) {
+    if (!this.isVideo) {
+      this.debug.warn("Aspect ratio can only be set for video");
+      return;
+    }
+    if (!a.string(i) || !rt(i)) {
+      this.debug.error(`Invalid aspect ratio specified (${i})`);
+      return;
+    }
+    this.config.ratio = de(i), X.call(this);
+  }
+  /**
+   * Set the autoplay state
+   * @param {boolean} input - Whether to autoplay or not
+   */
+  set autoplay(i) {
+    this.config.autoplay = a.boolean(i) ? i : this.config.autoplay;
+  }
+  /**
+   * Get the current autoplay state
+   */
+  get autoplay() {
+    return !!this.config.autoplay;
+  }
+  /**
+   * Toggle captions
+   * @param {boolean} input - Whether to enable captions
+   */
+  toggleCaptions(i) {
+    A.toggle.call(this, i, !1);
+  }
+  /**
+   * Set the caption track by index
+   * @param {number} input - Caption index
+   */
+  set currentTrack(i) {
+    A.set.call(this, i, !1), A.setup.call(this);
+  }
+  /**
+   * Get the current caption track index (-1 if disabled)
+   */
+  get currentTrack() {
+    const {
+      toggled: i,
+      currentTrack: t
+    } = this.captions;
+    return i ? t : -1;
+  }
+  /**
+   * Set the wanted language for captions
+   * Since tracks can be added later it won't update the actual caption track until there is a matching track
+   * @param {string} input - Two character ISO language code (e.g. EN, FR, PT, etc)
+   */
+  set language(i) {
+    A.setLanguage.call(this, i, !1);
+  }
+  /**
+   * Get the current track's language
+   */
+  get language() {
+    return (A.getCurrentTrack.call(this) || {}).language;
+  }
+  /**
+   * Toggle picture-in-picture playback on WebKit/MacOS
+   * TODO: update player with state, support, enabled
+   * TODO: detect outside changes
+   */
+  set pip(i) {
+    if (!$.pip)
+      return;
+    const t = a.boolean(i) ? i : !this.pip;
+    a.function(this.media.webkitSetPresentationMode) && this.media.webkitSetPresentationMode(t ? ye.active : ye.inactive), a.function(this.media.requestPictureInPicture) && (!this.pip && t ? this.media.requestPictureInPicture() : this.pip && !t && document.exitPictureInPicture());
+  }
+  /**
+   * Get the current picture-in-picture state
+   */
+  get pip() {
+    return $.pip ? a.empty(this.media.webkitPresentationMode) ? this.media === document.pictureInPictureElement : this.media.webkitPresentationMode === ye.active : null;
+  }
+  /**
+   * Sets the preview thumbnails for the current source
+   */
+  setPreviewThumbnails(i) {
+    this.previewThumbnails && this.previewThumbnails.loaded && (this.previewThumbnails.destroy(), this.previewThumbnails = null), Object.assign(this.config.previewThumbnails, i), this.config.previewThumbnails.enabled && (this.previewThumbnails = new Se(this));
+  }
+  /**
+   * Check for support
+   * @param {string} type - Player type (audio/video)
+   * @param {string} provider - Provider (html5/youtube/vimeo)
+   */
+  static supported(i, t) {
+    return $.check(i, t);
+  }
+  /**
+   * Load an SVG sprite into the page
+   * @param {string} url - URL for the SVG sprite
+   * @param {string} [id] - Unique ID
+   */
+  static loadSprite(i, t) {
+    return ot(i, t);
+  }
+  /**
+   * Setup multiple instances
+   * @param {*} selector
+   * @param {object} options
+   */
+  static setup(i, t = {}) {
+    let s = null;
+    return a.string(i) ? s = Array.from(document.querySelectorAll(i)) : a.nodeList(i) ? s = Array.from(i) : a.array(i) && (s = i.filter(a.element)), a.empty(s) ? null : s.map((n) => new me(n, t));
+  }
+}
+me.defaults = Ut(dt);
+export {
+  me as default
+};