@tidal-music/player-web-components 0.1.0

package/dist/index-tM9JvbA8.js

@@ -0,0 +1,3267 @@
+let R = Object.freeze({
+  apiUrl: "https://api.tidal.com/v1",
+  appVersion: "TIDAL Player",
+  clientPlatform: "web",
+  desiredVolumeLevel: 1,
+  eventUrl: "https://et.tidal.com/api/events",
+  gatherEvents: !0,
+  loudnessNormalizationMode: "ALBUM",
+  outputDevicesEnabled: !1,
+  streamingWifiAudioQuality: "LOW"
+});
+function k(t) {
+  return R[t];
+}
+function G(t) {
+  return R = Object.freeze({
+    ...R,
+    ...t
+  }), Object.keys(t).forEach((e) => {
+    const r = e;
+    Me.dispatchEvent(new CustomEvent(r, { detail: t[r] }));
+  }), R;
+}
+const Me = new EventTarget();
+var ee = (t, e, r) => {
+  if (!e.has(t))
+    throw TypeError("Cannot " + r);
+}, T = (t, e, r) => (ee(t, e, "read from private field"), r ? r.call(t) : e.get(t)), F = (t, e, r) => {
+  if (e.has(t))
+    throw TypeError("Cannot add the same private member more than once");
+  e instanceof WeakSet ? e.add(t) : e.set(t, r);
+}, B = (t, e, r, s) => (ee(t, e, "write to private field"), s ? s.call(t, r) : e.set(t, r), r), A, C, x, D;
+class te {
+  constructor(e) {
+    F(this, A, void 0), F(this, C, void 0), F(this, x, !1), F(this, D, void 0), B(this, D, new URL(e)), B(this, A, performance.now());
+  }
+  now(e = performance.now()) {
+    if (!T(this, C) || !T(this, A))
+      throw new ReferenceError(
+        "Initialization has not been done yet. You need to call and await the synchronize method once."
+      );
+    return Number.parseInt(
+      (T(this, C) + Math.abs(T(this, A) - e)).toFixed(0),
+      10
+    );
+  }
+  /**
+   * Use this method to synchronize time with the server.
+   *
+   * @param url - server url
+   */
+  async synchronize() {
+    if (!T(this, x))
+      try {
+        const e = await fetch(T(this, D));
+        e.ok && e.headers.has("date") && (B(this, C, new Date(e.headers.get("date")).getTime()), B(this, x, !0));
+      } catch (e) {
+        console.error(e);
+      }
+  }
+  timestamp(e, r) {
+    let s;
+    if (r) {
+      if (s = performance.getEntriesByName(e).find((n) => "detail" in n && n.detail === r), !s)
+        throw new ReferenceError(
+          `There is no performance entry named "${e}" with detail "${r}"`
+        );
+    } else
+      s = performance.getEntriesByName(e).pop();
+    return s ? this.now(s.startTime) : void 0;
+  }
+}
+A = /* @__PURE__ */ new WeakMap(), C = /* @__PURE__ */ new WeakMap(), x = /* @__PURE__ */ new WeakMap(), D = /* @__PURE__ */ new WeakMap();
+new te("https://api.tidal.com/v1/ping");
+const b = new te("https://api.tidal.com/v1/ping"), K = (t, e, r) => {
+  for (const s of t) {
+    const n = s.addedNodes[0];
+    s.type === "childList" && n.id === e && r();
+  }
+};
+function Ee() {
+  const t = document.getElementById("tidal-player-root");
+  if (!t)
+    return Promise.reject("No player root");
+  if ("video-one" in t.children && "video-two" in t.children)
+    return Promise.resolve();
+  const e = [];
+  return "video-one" in t.children || e.push(
+    new Promise((r) => {
+      new MutationObserver(
+        (s) => K(s, "video-one", r)
+      ).observe(t, { childList: !0 });
+    })
+  ), "video-two" in t.children || e.push(
+    new Promise((r) => {
+      new MutationObserver(
+        (s) => K(s, "video-two", r)
+      ).observe(t, { childList: !0 });
+    })
+  ), Promise.all(e);
+}
+const E = document.createElement("video"), P = document.createElement("video"), re = (t) => {
+  t.setAttribute("crossorigin", "anonymous"), t.setAttribute("playsinline", "playsinline");
+};
+re(E);
+E.id = "video-one";
+re(P);
+P.id = "video-two";
+const U = "tidal-player-root";
+function Pe() {
+  let t = document.getElementById(U);
+  if (!t) {
+    const e = document.createElement("template");
+    e.id = U, document.body.appendChild(e), t = document.getElementById(U);
+  }
+  return Te();
+}
+function Te() {
+  const t = document.getElementById(
+    U
+  );
+  return t && (E.id in t.children || t.appendChild(E), P.id in t.children || t.appendChild(P)), Ee();
+}
+function Ie() {
+  return new Promise(
+    (t) => document.addEventListener(
+      "click",
+      () => {
+        E.readyState === HTMLMediaElement.HAVE_NOTHING && !E.src && E.load(), P.readyState === HTMLMediaElement.HAVE_NOTHING && !P.src && P.load(), t();
+      },
+      { once: !0 }
+    )
+  );
+}
+function Le(t) {
+  return new Promise((e) => setTimeout(() => e(), t));
+}
+function Oe(t, e) {
+  return new Promise((r) => {
+    t.addEventListener(e, (s) => r(s), !1);
+  });
+}
+class Ae extends EventTarget {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore - Setter
+  #e;
+  async dispatchAuthorized() {
+    const e = await this.#e.getCredentials();
+    e?.token && this.dispatchEvent(
+      new CustomEvent("authorized", {
+        detail: {
+          credentials: e
+        }
+      })
+    );
+  }
+  set credentialsProvider(e) {
+    this.#e = e, this.dispatchAuthorized().catch(console.error), this.#e.bus((r) => {
+      switch (r.detail.type) {
+        case "credentialsUpdated":
+          this.dispatchAuthorized().catch(console.error);
+          break;
+        default:
+          console.warn("Unhandled event from credentials provider: ", r);
+          break;
+      }
+    });
+  }
+  get credentialsProvider() {
+    return this.#e;
+  }
+}
+class W extends Error {
+  errorCode = null;
+  errorId = null;
+  referenceId;
+  constructor(e, r, s) {
+    super(`${e}: ${r} (${s})`), this.errorId = e, this.errorCode = r, this.referenceId = s;
+  }
+  toJSON() {
+    return {
+      errorCode: this.errorCode,
+      errorId: this.errorId,
+      referenceId: this.referenceId
+    };
+  }
+  toString() {
+    return JSON.stringify(this.toJSON());
+  }
+}
+async function N() {
+  if (v.credentialsProvider) {
+    const t = await v.credentialsProvider.getCredentials();
+    return !!(t.token && t.userId);
+  }
+  return await Oe(v, "authorized"), N();
+}
+const v = new Ae();
+async function Ce() {
+  const t = await N(), e = async () => {
+    const { Pushkin: s } = await Promise.resolve().then(() => Lt);
+    return s.refresh();
+  }, r = async () => (await Promise.resolve().then(() => ft)).start();
+  if (t) {
+    G({
+      gatherEvents: !0
+    });
+    try {
+      await Promise.all([e(), r()]);
+    } catch (s) {
+      console.error(s);
+    }
+  } else
+    G({
+      gatherEvents: !1
+    });
+}
+v.addEventListener("authorized", () => {
+  Ce().then().catch(console.error);
+});
+async function Y() {
+  return v.credentialsProvider ? (await v.credentialsProvider.getCredentials()).token ?? null : null;
+}
+class _e extends EventTarget {
+  dispatchError(e) {
+    this.dispatchEvent(
+      new CustomEvent("error", {
+        detail: e.toJSON()
+      })
+    );
+  }
+}
+const h = new _e();
+class Ne {
+  #e = /* @__PURE__ */ new Map();
+  #r = /* @__PURE__ */ new Map();
+  #s = /* @__PURE__ */ new Map();
+  /**
+   * Clones a session to re-use the media product and playback content for a new session.
+   *
+   * @param from - streamingSessionId to clone
+   * @param to - target streamingSessionId
+   */
+  clone(e, r) {
+    const s = this.getMediaProductTransition(e), n = this.getStreamInfo(e), o = this.getPlaybackInfo(e);
+    if (!s || !n || !o)
+      throw new Error(
+        `Cannot clone ${e}. Missing mediaProductTransition or streamInfo.`
+      );
+    this.saveMediaProductTransition(r, {
+      ...s,
+      playbackContext: {
+        ...s.playbackContext,
+        playbackSessionId: r
+      }
+    }), this.saveStreamInfo(r, {
+      ...n,
+      streamingSessionId: r
+    }), this.savePlaybackInfo(r, {
+      ...o,
+      streamingSessionId: r
+    });
+  }
+  deleteMediaProductTransition(e) {
+    this.#e.delete(e);
+  }
+  /**
+   * Removed cached playbackInfo, streamInfo and mediaProductTransition for session.
+   * For re-using playbackInfo etc for other sessions make sure to run clone before deletion!
+   *
+   * @see {@link StreamingSessionStore.clone}
+   */
+  deleteSession(e) {
+    this.deleteMediaProductTransition(e), this.#r.delete(e), this.deleteStreamInfo(e);
+  }
+  deleteStreamInfo(e) {
+    this.#s.delete(e);
+  }
+  getMediaProductTransition(e) {
+    return e ? this.#e.get(e) : void 0;
+  }
+  getPlaybackInfo(e) {
+    return e ? this.#r.get(e) : void 0;
+  }
+  getStreamInfo(e) {
+    return e ? this.#s.get(e) : void 0;
+  }
+  hasMediaProductTransition(e) {
+    return this.#e.has(e);
+  }
+  hasPlaybackInfo(e) {
+    return this.#r.has(e);
+  }
+  hasStreamInfo(e) {
+    return this.#s.has(e);
+  }
+  overwriteDuration(e, r) {
+    const s = this.#e.get(e);
+    s && (s.playbackContext.actualDuration = r, this.saveMediaProductTransition(e, s));
+  }
+  saveMediaProductTransition(e, r) {
+    this.#e.set(
+      e,
+      r
+    );
+  }
+  savePlaybackInfo(e, r) {
+    this.#r.set(e, r);
+  }
+  saveStreamInfo(e, r) {
+    this.#s.set(e, r);
+  }
+}
+const Q = new Ne();
+class Fe {
+  activePlayer;
+  preloadPlayer;
+  get preloadedMediaProduct() {
+    return Q.getMediaProductTransition(
+      this.preloadedStreamingSessionId
+    )?.mediaProduct ?? void 0;
+  }
+  get preloadedStreamingSessionId() {
+    return this.preloadPlayer?.preloadedStreamingSessionId ?? void 0;
+  }
+}
+const p = new Fe();
+let Be;
+const Re = [
+  {
+    itemTypes: ["track", "video"],
+    player: "shaka",
+    qualities: ["HIGH", "LOSSLESS", "LOW", "HI_RES_LOSSLESS"]
+  }
+];
+let q = Re;
+const w = {
+  browser: void 0,
+  native: void 0,
+  shaka: void 0
+};
+async function xe() {
+  await Promise.all(
+    q.map((t) => {
+      const e = w[t.player];
+      return e ? e.reset() : Promise.resolve();
+    })
+  ), p.activePlayer = void 0, p.preloadPlayer = void 0;
+}
+function De(t) {
+  t.name !== "nativePlayer" && w.native && w.native.abandon(), p.activePlayer = t;
+}
+function Ue() {
+  h.removeEventListener("ended", Be);
+}
+async function We() {
+  const { default: t } = await import("./nativePlayer-U375Dfm5-hUK7oXzY.js");
+  return w.native || (w.native = new t()), w.native;
+}
+async function ze() {
+  const { default: t } = await import("./browserPlayer-oNOpDVm6-UW0N6pFH.js");
+  return w.browser || (w.browser = new t()), w.browser;
+}
+async function Ve() {
+  const { default: t } = await import("./shakaPlayer-izGFLVQr--XUsjgT2.js");
+  return w.shaka || (w.shaka = new t()), w.shaka;
+}
+async function He(t, e) {
+  const r = q.filter((n) => n.itemTypes.includes(t)).filter(
+    (n) => t === "track" && n.qualities && e ? n.qualities.includes(e) : !0
+  );
+  r.length === 0 && console.error(
+    `No player found to handle audio quality "${String(
+      e
+    )}" for product type "${t}" in player config: `,
+    q
+  );
+  const { player: s } = r[0];
+  switch (s) {
+    case "shaka":
+      return Ve();
+    case "browser":
+      return ze();
+    case "native":
+      return We();
+    default:
+      throw new Error("No player found.");
+  }
+}
+function qe() {
+  return p.activePlayer?.getPosition() ?? 0;
+}
+function Qe() {
+  return p.activePlayer?.currentMediaProduct ?? null;
+}
+function $e() {
+  const t = p.activePlayer;
+  if (t) {
+    const e = Q.getMediaProductTransition(
+      t.currentStreamingSessionId
+    );
+    if (e)
+      return e.playbackContext;
+  }
+}
+function se() {
+  return p.activePlayer?.playbackState ?? "IDLE";
+}
+function $(t) {
+  return new Promise((e, r) => {
+    t.oncomplete = t.onsuccess = () => e(t.result), t.onabort = t.onerror = () => r(t.error);
+  });
+}
+function je(t, e) {
+  const r = indexedDB.open(t);
+  r.onupgradeneeded = () => r.result.createObjectStore(e);
+  const s = $(r);
+  return (n, o) => s.then((a) => o(a.transaction(e, n).objectStore(e)));
+}
+let V;
+function ie() {
+  return V || (V = je("keyval-store", "keyval")), V;
+}
+function ne(t, e = ie()) {
+  return e("readonly", (r) => $(r.get(t)));
+}
+function ae(t, e, r = ie()) {
+  return r("readwrite", (s) => (s.put(e, t), $(s.transaction)));
+}
+async function L(t, e) {
+  let r = /* @__PURE__ */ new Map(), s;
+  if (!k("gatherEvents"))
+    return (n) => Promise.resolve(void 0);
+  try {
+    s = await ne(t), s && (r = new Map(s));
+  } catch (n) {
+    console.error(n);
+  }
+  return async (n) => {
+    const o = r.get(n.streamingSessionId) || e, a = {
+      ...o,
+      ...n
+    };
+    for (const c of Object.keys(n)) {
+      const d = c;
+      Array.isArray(n[d]) && (a[d] = [
+        ...o[d] || [],
+        ...n[d] || []
+      ]);
+    }
+    r.set(n.streamingSessionId, a);
+    try {
+      await ae(t, [...r]);
+    } catch (c) {
+      console.error(c);
+    }
+    return {
+      name: t,
+      payload: a
+    };
+  };
+}
+const Ge = {
+  endReason: "COMPLETE",
+  endTimestamp: 0,
+  errorCode: null,
+  errorMessage: null,
+  startTimestamp: 0,
+  streamingSessionId: ""
+}, Ke = await L(
+  "drm_license_fetch",
+  Ge
+);
+function Yt(t) {
+  return Ke(t);
+}
+const Ye = {
+  endReason: "COMPLETE",
+  endTimestamp: 0,
+  errorCode: null,
+  errorMessage: null,
+  startTimestamp: 0,
+  streamingSessionId: ""
+}, Je = await L(
+  "playback_info_fetch",
+  Ye
+);
+function H(t) {
+  return Je(t);
+}
+function Jt(t) {
+  switch (t) {
+    case "bluetooth":
+      return "BLUETOOTH";
+    case "displayPort":
+      return "DISPLAY_PORT";
+    case "mqa":
+      return "MQA";
+    case "builtIn":
+      return "BUILT_IN";
+    case "hdmi":
+      return "HDMI";
+    case "usb":
+      return "USB";
+    case "systemDefault":
+      return "SYSTEM_DEFAULT";
+    case "windowsCommunication":
+    case "airplay":
+    default:
+      return;
+  }
+}
+const Xe = {
+  actualAssetPresentation: "FULL",
+  actualAudioMode: "STEREO",
+  actualProductId: null,
+  actualQuality: "LOSSLESS",
+  actualStartTimestamp: 0,
+  actualStreamType: "ON_DEMAND",
+  adaptations: [],
+  cdm: "WIDEVINE",
+  cdmVersion: null,
+  endReason: "COMPLETE",
+  endTimestamp: 0,
+  errorCode: null,
+  errorMessage: null,
+  hasAds: !1,
+  idealStartTimestamp: 0,
+  outputDevice: null,
+  productType: "TRACK",
+  stalls: [],
+  streamingSessionId: ""
+}, Ze = await L(
+  "playback_statistics",
+  Xe
+);
+function J(t) {
+  return Ze(t);
+}
+const et = {
+  streamingSessionId: "",
+  timestamp: 0
+}, tt = await L(
+  "streaming_session_end",
+  et
+);
+function rt(t) {
+  return tt(t);
+}
+const st = {
+  "Amazon Silk": "amazon_silk",
+  "Android Browser": "android",
+  Bada: "bada",
+  BlackBerry: "blackberry",
+  Chrome: "chrome",
+  Chromium: "chromium",
+  Electron: "electron",
+  Epiphany: "epiphany",
+  Firefox: "firefox",
+  Focus: "focus",
+  Generic: "generic",
+  "Google Search": "google_search",
+  Googlebot: "googlebot",
+  "Internet Explorer": "ie",
+  "K-Meleon": "k_meleon",
+  Maxthon: "maxthon",
+  "Microsoft Edge": "edge",
+  "MZ Browser": "mz",
+  "NAVER Whale Browser": "naver",
+  Opera: "opera",
+  "Opera Coast": "opera_coast",
+  PhantomJS: "phantomjs",
+  Puffin: "puffin",
+  QupZilla: "qupzilla",
+  QQ: "qq",
+  QQLite: "qqlite",
+  Safari: "safari",
+  Sailfish: "sailfish",
+  "Samsung Internet for Android": "samsung_internet",
+  SeaMonkey: "seamonkey",
+  Sleipnir: "sleipnir",
+  Swing: "swing",
+  Tizen: "tizen",
+  "UC Browser": "uc",
+  Vivaldi: "vivaldi",
+  "WebOS Browser": "webos",
+  WeChat: "wechat",
+  "Yandex Browser": "yandex",
+  Roku: "roku"
+}, oe = {
+  amazon_silk: "Amazon Silk",
+  android: "Android Browser",
+  bada: "Bada",
+  blackberry: "BlackBerry",
+  chrome: "Chrome",
+  chromium: "Chromium",
+  electron: "Electron",
+  epiphany: "Epiphany",
+  firefox: "Firefox",
+  focus: "Focus",
+  generic: "Generic",
+  googlebot: "Googlebot",
+  google_search: "Google Search",
+  ie: "Internet Explorer",
+  k_meleon: "K-Meleon",
+  maxthon: "Maxthon",
+  edge: "Microsoft Edge",
+  mz: "MZ Browser",
+  naver: "NAVER Whale Browser",
+  opera: "Opera",
+  opera_coast: "Opera Coast",
+  phantomjs: "PhantomJS",
+  puffin: "Puffin",
+  qupzilla: "QupZilla",
+  qq: "QQ Browser",
+  qqlite: "QQ Browser Lite",
+  safari: "Safari",
+  sailfish: "Sailfish",
+  samsung_internet: "Samsung Internet for Android",
+  seamonkey: "SeaMonkey",
+  sleipnir: "Sleipnir",
+  swing: "Swing",
+  tizen: "Tizen",
+  uc: "UC Browser",
+  vivaldi: "Vivaldi",
+  webos: "WebOS Browser",
+  wechat: "WeChat",
+  yandex: "Yandex Browser"
+}, m = {
+  tablet: "tablet",
+  mobile: "mobile",
+  desktop: "desktop",
+  tv: "tv"
+}, g = {
+  WindowsPhone: "Windows Phone",
+  Windows: "Windows",
+  MacOS: "macOS",
+  iOS: "iOS",
+  Android: "Android",
+  WebOS: "WebOS",
+  BlackBerry: "BlackBerry",
+  Bada: "Bada",
+  Tizen: "Tizen",
+  Linux: "Linux",
+  ChromeOS: "Chrome OS",
+  PlayStation4: "PlayStation 4",
+  Roku: "Roku"
+}, S = {
+  EdgeHTML: "EdgeHTML",
+  Blink: "Blink",
+  Trident: "Trident",
+  Presto: "Presto",
+  Gecko: "Gecko",
+  WebKit: "WebKit"
+};
+class i {
+  /**
+   * Get first matched item for a string
+   * @param {RegExp} regexp
+   * @param {String} ua
+   * @return {Array|{index: number, input: string}|*|boolean|string}
+   */
+  static getFirstMatch(e, r) {
+    const s = r.match(e);
+    return s && s.length > 0 && s[1] || "";
+  }
+  /**
+   * Get second matched item for a string
+   * @param regexp
+   * @param {String} ua
+   * @return {Array|{index: number, input: string}|*|boolean|string}
+   */
+  static getSecondMatch(e, r) {
+    const s = r.match(e);
+    return s && s.length > 1 && s[2] || "";
+  }
+  /**
+   * Match a regexp and return a constant or undefined
+   * @param {RegExp} regexp
+   * @param {String} ua
+   * @param {*} _const Any const that will be returned if regexp matches the string
+   * @return {*}
+   */
+  static matchAndReturnConst(e, r, s) {
+    if (e.test(r))
+      return s;
+  }
+  static getWindowsVersionName(e) {
+    switch (e) {
+      case "NT":
+        return "NT";
+      case "XP":
+        return "XP";
+      case "NT 5.0":
+        return "2000";
+      case "NT 5.1":
+        return "XP";
+      case "NT 5.2":
+        return "2003";
+      case "NT 6.0":
+        return "Vista";
+      case "NT 6.1":
+        return "7";
+      case "NT 6.2":
+        return "8";
+      case "NT 6.3":
+        return "8.1";
+      case "NT 10.0":
+        return "10";
+      default:
+        return;
+    }
+  }
+  /**
+   * Get macOS version name
+   *    10.5 - Leopard
+   *    10.6 - Snow Leopard
+   *    10.7 - Lion
+   *    10.8 - Mountain Lion
+   *    10.9 - Mavericks
+   *    10.10 - Yosemite
+   *    10.11 - El Capitan
+   *    10.12 - Sierra
+   *    10.13 - High Sierra
+   *    10.14 - Mojave
+   *    10.15 - Catalina
+   *
+   * @example
+   *   getMacOSVersionName("10.14") // 'Mojave'
+   *
+   * @param  {string} version
+   * @return {string} versionName
+   */
+  static getMacOSVersionName(e) {
+    const r = e.split(".").splice(0, 2).map((s) => parseInt(s, 10) || 0);
+    if (r.push(0), r[0] === 10)
+      switch (r[1]) {
+        case 5:
+          return "Leopard";
+        case 6:
+          return "Snow Leopard";
+        case 7:
+          return "Lion";
+        case 8:
+          return "Mountain Lion";
+        case 9:
+          return "Mavericks";
+        case 10:
+          return "Yosemite";
+        case 11:
+          return "El Capitan";
+        case 12:
+          return "Sierra";
+        case 13:
+          return "High Sierra";
+        case 14:
+          return "Mojave";
+        case 15:
+          return "Catalina";
+        default:
+          return;
+      }
+  }
+  /**
+   * Get Android version name
+   *    1.5 - Cupcake
+   *    1.6 - Donut
+   *    2.0 - Eclair
+   *    2.1 - Eclair
+   *    2.2 - Froyo
+   *    2.x - Gingerbread
+   *    3.x - Honeycomb
+   *    4.0 - Ice Cream Sandwich
+   *    4.1 - Jelly Bean
+   *    4.4 - KitKat
+   *    5.x - Lollipop
+   *    6.x - Marshmallow
+   *    7.x - Nougat
+   *    8.x - Oreo
+   *    9.x - Pie
+   *
+   * @example
+   *   getAndroidVersionName("7.0") // 'Nougat'
+   *
+   * @param  {string} version
+   * @return {string} versionName
+   */
+  static getAndroidVersionName(e) {
+    const r = e.split(".").splice(0, 2).map((s) => parseInt(s, 10) || 0);
+    if (r.push(0), !(r[0] === 1 && r[1] < 5)) {
+      if (r[0] === 1 && r[1] < 6)
+        return "Cupcake";
+      if (r[0] === 1 && r[1] >= 6)
+        return "Donut";
+      if (r[0] === 2 && r[1] < 2)
+        return "Eclair";
+      if (r[0] === 2 && r[1] === 2)
+        return "Froyo";
+      if (r[0] === 2 && r[1] > 2)
+        return "Gingerbread";
+      if (r[0] === 3)
+        return "Honeycomb";
+      if (r[0] === 4 && r[1] < 1)
+        return "Ice Cream Sandwich";
+      if (r[0] === 4 && r[1] < 4)
+        return "Jelly Bean";
+      if (r[0] === 4 && r[1] >= 4)
+        return "KitKat";
+      if (r[0] === 5)
+        return "Lollipop";
+      if (r[0] === 6)
+        return "Marshmallow";
+      if (r[0] === 7)
+        return "Nougat";
+      if (r[0] === 8)
+        return "Oreo";
+      if (r[0] === 9)
+        return "Pie";
+    }
+  }
+  /**
+   * Get version precisions count
+   *
+   * @example
+   *   getVersionPrecision("1.10.3") // 3
+   *
+   * @param  {string} version
+   * @return {number}
+   */
+  static getVersionPrecision(e) {
+    return e.split(".").length;
+  }
+  /**
+   * Calculate browser version weight
+   *
+   * @example
+   *   compareVersions('1.10.2.1',  '1.8.2.1.90')    // 1
+   *   compareVersions('1.010.2.1', '1.09.2.1.90');  // 1
+   *   compareVersions('1.10.2.1',  '1.10.2.1');     // 0
+   *   compareVersions('1.10.2.1',  '1.0800.2');     // -1
+   *   compareVersions('1.10.2.1',  '1.10',  true);  // 0
+   *
+   * @param {String} versionA versions versions to compare
+   * @param {String} versionB versions versions to compare
+   * @param {boolean} [isLoose] enable loose comparison
+   * @return {Number} comparison result: -1 when versionA is lower,
+   * 1 when versionA is bigger, 0 when both equal
+   */
+  /* eslint consistent-return: 1 */
+  static compareVersions(e, r, s = !1) {
+    const n = i.getVersionPrecision(e), o = i.getVersionPrecision(r);
+    let a = Math.max(n, o), c = 0;
+    const d = i.map([e, r], (l) => {
+      const y = a - i.getVersionPrecision(l), M = l + new Array(y + 1).join(".0");
+      return i.map(M.split("."), (f) => new Array(20 - f.length).join("0") + f).reverse();
+    });
+    for (s && (c = a - Math.min(n, o)), a -= 1; a >= c; ) {
+      if (d[0][a] > d[1][a])
+        return 1;
+      if (d[0][a] === d[1][a]) {
+        if (a === c)
+          return 0;
+        a -= 1;
+      } else if (d[0][a] < d[1][a])
+        return -1;
+    }
+  }
+  /**
+   * Array::map polyfill
+   *
+   * @param  {Array} arr
+   * @param  {Function} iterator
+   * @return {Array}
+   */
+  static map(e, r) {
+    const s = [];
+    let n;
+    if (Array.prototype.map)
+      return Array.prototype.map.call(e, r);
+    for (n = 0; n < e.length; n += 1)
+      s.push(r(e[n]));
+    return s;
+  }
+  /**
+   * Array::find polyfill
+   *
+   * @param  {Array} arr
+   * @param  {Function} predicate
+   * @return {Array}
+   */
+  static find(e, r) {
+    let s, n;
+    if (Array.prototype.find)
+      return Array.prototype.find.call(e, r);
+    for (s = 0, n = e.length; s < n; s += 1) {
+      const o = e[s];
+      if (r(o, s))
+        return o;
+    }
+  }
+  /**
+   * Object::assign polyfill
+   *
+   * @param  {Object} obj
+   * @param  {Object} ...objs
+   * @return {Object}
+   */
+  static assign(e, ...r) {
+    const s = e;
+    let n, o;
+    if (Object.assign)
+      return Object.assign(e, ...r);
+    for (n = 0, o = r.length; n < o; n += 1) {
+      const a = r[n];
+      typeof a == "object" && a !== null && Object.keys(a).forEach((c) => {
+        s[c] = a[c];
+      });
+    }
+    return e;
+  }
+  /**
+   * Get short version/alias for a browser name
+   *
+   * @example
+   *   getBrowserAlias('Microsoft Edge') // edge
+   *
+   * @param  {string} browserName
+   * @return {string}
+   */
+  static getBrowserAlias(e) {
+    return st[e];
+  }
+  /**
+   * Get short version/alias for a browser name
+   *
+   * @example
+   *   getBrowserAlias('edge') // Microsoft Edge
+   *
+   * @param  {string} browserAlias
+   * @return {string}
+   */
+  static getBrowserTypeByAlias(e) {
+    return oe[e] || "";
+  }
+}
+const u = /version\/(\d+(\.?_?\d+)+)/i, it = [
+  /* Googlebot */
+  {
+    test: [/googlebot/i],
+    describe(t) {
+      const e = {
+        name: "Googlebot"
+      }, r = i.getFirstMatch(/googlebot\/(\d+(\.\d+))/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  /* Opera < 13.0 */
+  {
+    test: [/opera/i],
+    describe(t) {
+      const e = {
+        name: "Opera"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/(?:opera)[\s/](\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  /* Opera > 13.0 */
+  {
+    test: [/opr\/|opios/i],
+    describe(t) {
+      const e = {
+        name: "Opera"
+      }, r = i.getFirstMatch(/(?:opr|opios)[\s/](\S+)/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/SamsungBrowser/i],
+    describe(t) {
+      const e = {
+        name: "Samsung Internet for Android"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/(?:SamsungBrowser)[\s/](\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/Whale/i],
+    describe(t) {
+      const e = {
+        name: "NAVER Whale Browser"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/(?:whale)[\s/](\d+(?:\.\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/MZBrowser/i],
+    describe(t) {
+      const e = {
+        name: "MZ Browser"
+      }, r = i.getFirstMatch(/(?:MZBrowser)[\s/](\d+(?:\.\d+)+)/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/focus/i],
+    describe(t) {
+      const e = {
+        name: "Focus"
+      }, r = i.getFirstMatch(/(?:focus)[\s/](\d+(?:\.\d+)+)/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/swing/i],
+    describe(t) {
+      const e = {
+        name: "Swing"
+      }, r = i.getFirstMatch(/(?:swing)[\s/](\d+(?:\.\d+)+)/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/coast/i],
+    describe(t) {
+      const e = {
+        name: "Opera Coast"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/(?:coast)[\s/](\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/opt\/\d+(?:.?_?\d+)+/i],
+    describe(t) {
+      const e = {
+        name: "Opera Touch"
+      }, r = i.getFirstMatch(/(?:opt)[\s/](\d+(\.?_?\d+)+)/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/yabrowser/i],
+    describe(t) {
+      const e = {
+        name: "Yandex Browser"
+      }, r = i.getFirstMatch(/(?:yabrowser)[\s/](\d+(\.?_?\d+)+)/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/ucbrowser/i],
+    describe(t) {
+      const e = {
+        name: "UC Browser"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/(?:ucbrowser)[\s/](\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/Maxthon|mxios/i],
+    describe(t) {
+      const e = {
+        name: "Maxthon"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/(?:Maxthon|mxios)[\s/](\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/epiphany/i],
+    describe(t) {
+      const e = {
+        name: "Epiphany"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/(?:epiphany)[\s/](\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/puffin/i],
+    describe(t) {
+      const e = {
+        name: "Puffin"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/(?:puffin)[\s/](\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/sleipnir/i],
+    describe(t) {
+      const e = {
+        name: "Sleipnir"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/(?:sleipnir)[\s/](\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/k-meleon/i],
+    describe(t) {
+      const e = {
+        name: "K-Meleon"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/(?:k-meleon)[\s/](\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/micromessenger/i],
+    describe(t) {
+      const e = {
+        name: "WeChat"
+      }, r = i.getFirstMatch(/(?:micromessenger)[\s/](\d+(\.?_?\d+)+)/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/qqbrowser/i],
+    describe(t) {
+      const e = {
+        name: /qqbrowserlite/i.test(t) ? "QQ Browser Lite" : "QQ Browser"
+      }, r = i.getFirstMatch(/(?:qqbrowserlite|qqbrowser)[/](\d+(\.?_?\d+)+)/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/msie|trident/i],
+    describe(t) {
+      const e = {
+        name: "Internet Explorer"
+      }, r = i.getFirstMatch(/(?:msie |rv:)(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/\sedg\//i],
+    describe(t) {
+      const e = {
+        name: "Microsoft Edge"
+      }, r = i.getFirstMatch(/\sedg\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/edg([ea]|ios)/i],
+    describe(t) {
+      const e = {
+        name: "Microsoft Edge"
+      }, r = i.getSecondMatch(/edg([ea]|ios)\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/vivaldi/i],
+    describe(t) {
+      const e = {
+        name: "Vivaldi"
+      }, r = i.getFirstMatch(/vivaldi\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/seamonkey/i],
+    describe(t) {
+      const e = {
+        name: "SeaMonkey"
+      }, r = i.getFirstMatch(/seamonkey\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/sailfish/i],
+    describe(t) {
+      const e = {
+        name: "Sailfish"
+      }, r = i.getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/silk/i],
+    describe(t) {
+      const e = {
+        name: "Amazon Silk"
+      }, r = i.getFirstMatch(/silk\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/phantom/i],
+    describe(t) {
+      const e = {
+        name: "PhantomJS"
+      }, r = i.getFirstMatch(/phantomjs\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/slimerjs/i],
+    describe(t) {
+      const e = {
+        name: "SlimerJS"
+      }, r = i.getFirstMatch(/slimerjs\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
+    describe(t) {
+      const e = {
+        name: "BlackBerry"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/blackberry[\d]+\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/(web|hpw)[o0]s/i],
+    describe(t) {
+      const e = {
+        name: "WebOS Browser"
+      }, r = i.getFirstMatch(u, t) || i.getFirstMatch(/w(?:eb)?[o0]sbrowser\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/bada/i],
+    describe(t) {
+      const e = {
+        name: "Bada"
+      }, r = i.getFirstMatch(/dolfin\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/tizen/i],
+    describe(t) {
+      const e = {
+        name: "Tizen"
+      }, r = i.getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.?_?\d+)+)/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/qupzilla/i],
+    describe(t) {
+      const e = {
+        name: "QupZilla"
+      }, r = i.getFirstMatch(/(?:qupzilla)[\s/](\d+(\.?_?\d+)+)/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/firefox|iceweasel|fxios/i],
+    describe(t) {
+      const e = {
+        name: "Firefox"
+      }, r = i.getFirstMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/electron/i],
+    describe(t) {
+      const e = {
+        name: "Electron"
+      }, r = i.getFirstMatch(/(?:electron)\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/MiuiBrowser/i],
+    describe(t) {
+      const e = {
+        name: "Miui"
+      }, r = i.getFirstMatch(/(?:MiuiBrowser)[\s/](\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/chromium/i],
+    describe(t) {
+      const e = {
+        name: "Chromium"
+      }, r = i.getFirstMatch(/(?:chromium)[\s/](\d+(\.?_?\d+)+)/i, t) || i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/chrome|crios|crmo/i],
+    describe(t) {
+      const e = {
+        name: "Chrome"
+      }, r = i.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  {
+    test: [/GSA/i],
+    describe(t) {
+      const e = {
+        name: "Google Search"
+      }, r = i.getFirstMatch(/(?:GSA)\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  /* Android Browser */
+  {
+    test(t) {
+      const e = !t.test(/like android/i), r = t.test(/android/i);
+      return e && r;
+    },
+    describe(t) {
+      const e = {
+        name: "Android Browser"
+      }, r = i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  /* PlayStation 4 */
+  {
+    test: [/playstation 4/i],
+    describe(t) {
+      const e = {
+        name: "PlayStation 4"
+      }, r = i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  /* Safari */
+  {
+    test: [/safari|applewebkit/i],
+    describe(t) {
+      const e = {
+        name: "Safari"
+      }, r = i.getFirstMatch(u, t);
+      return r && (e.version = r), e;
+    }
+  },
+  /* Something else */
+  {
+    test: [/.*/i],
+    describe(t) {
+      const e = /^(.*)\/(.*) /, r = /^(.*)\/(.*)[ \t]\((.*)/, s = t.search("\\(") !== -1 ? r : e;
+      return {
+        name: i.getFirstMatch(s, t),
+        version: i.getSecondMatch(s, t)
+      };
+    }
+  }
+], nt = [
+  /* Roku */
+  {
+    test: [/Roku\/DVP/],
+    describe(t) {
+      const e = i.getFirstMatch(/Roku\/DVP-(\d+\.\d+)/i, t);
+      return {
+        name: g.Roku,
+        version: e
+      };
+    }
+  },
+  /* Windows Phone */
+  {
+    test: [/windows phone/i],
+    describe(t) {
+      const e = i.getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i, t);
+      return {
+        name: g.WindowsPhone,
+        version: e
+      };
+    }
+  },
+  /* Windows */
+  {
+    test: [/windows /i],
+    describe(t) {
+      const e = i.getFirstMatch(/Windows ((NT|XP)( \d\d?.\d)?)/i, t), r = i.getWindowsVersionName(e);
+      return {
+        name: g.Windows,
+        version: e,
+        versionName: r
+      };
+    }
+  },
+  /* Firefox on iPad */
+  {
+    test: [/Macintosh(.*?) FxiOS(.*?)\//],
+    describe(t) {
+      const e = {
+        name: g.iOS
+      }, r = i.getSecondMatch(/(Version\/)(\d[\d.]+)/, t);
+      return r && (e.version = r), e;
+    }
+  },
+  /* macOS */
+  {
+    test: [/macintosh/i],
+    describe(t) {
+      const e = i.getFirstMatch(/mac os x (\d+(\.?_?\d+)+)/i, t).replace(/[_\s]/g, "."), r = i.getMacOSVersionName(e), s = {
+        name: g.MacOS,
+        version: e
+      };
+      return r && (s.versionName = r), s;
+    }
+  },
+  /* iOS */
+  {
+    test: [/(ipod|iphone|ipad)/i],
+    describe(t) {
+      const e = i.getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i, t).replace(/[_\s]/g, ".");
+      return {
+        name: g.iOS,
+        version: e
+      };
+    }
+  },
+  /* Android */
+  {
+    test(t) {
+      const e = !t.test(/like android/i), r = t.test(/android/i);
+      return e && r;
+    },
+    describe(t) {
+      const e = i.getFirstMatch(/android[\s/-](\d+(\.\d+)*)/i, t), r = i.getAndroidVersionName(e), s = {
+        name: g.Android,
+        version: e
+      };
+      return r && (s.versionName = r), s;
+    }
+  },
+  /* WebOS */
+  {
+    test: [/(web|hpw)[o0]s/i],
+    describe(t) {
+      const e = i.getFirstMatch(/(?:web|hpw)[o0]s\/(\d+(\.\d+)*)/i, t), r = {
+        name: g.WebOS
+      };
+      return e && e.length && (r.version = e), r;
+    }
+  },
+  /* BlackBerry */
+  {
+    test: [/blackberry|\bbb\d+/i, /rim\stablet/i],
+    describe(t) {
+      const e = i.getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i, t) || i.getFirstMatch(/blackberry\d+\/(\d+([_\s]\d+)*)/i, t) || i.getFirstMatch(/\bbb(\d+)/i, t);
+      return {
+        name: g.BlackBerry,
+        version: e
+      };
+    }
+  },
+  /* Bada */
+  {
+    test: [/bada/i],
+    describe(t) {
+      const e = i.getFirstMatch(/bada\/(\d+(\.\d+)*)/i, t);
+      return {
+        name: g.Bada,
+        version: e
+      };
+    }
+  },
+  /* Tizen */
+  {
+    test: [/tizen/i],
+    describe(t) {
+      const e = i.getFirstMatch(/tizen[/\s](\d+(\.\d+)*)/i, t);
+      return {
+        name: g.Tizen,
+        version: e
+      };
+    }
+  },
+  /* Linux */
+  {
+    test: [/linux/i],
+    describe() {
+      return {
+        name: g.Linux
+      };
+    }
+  },
+  /* Chrome OS */
+  {
+    test: [/CrOS/],
+    describe() {
+      return {
+        name: g.ChromeOS
+      };
+    }
+  },
+  /* Playstation 4 */
+  {
+    test: [/PlayStation 4/],
+    describe(t) {
+      const e = i.getFirstMatch(/PlayStation 4[/\s](\d+(\.\d+)*)/i, t);
+      return {
+        name: g.PlayStation4,
+        version: e
+      };
+    }
+  }
+], at = [
+  /* Googlebot */
+  {
+    test: [/googlebot/i],
+    describe() {
+      return {
+        type: "bot",
+        vendor: "Google"
+      };
+    }
+  },
+  /* Huawei */
+  {
+    test: [/huawei/i],
+    describe(t) {
+      const e = i.getFirstMatch(/(can-l01)/i, t) && "Nova", r = {
+        type: m.mobile,
+        vendor: "Huawei"
+      };
+      return e && (r.model = e), r;
+    }
+  },
+  /* Nexus Tablet */
+  {
+    test: [/nexus\s*(?:7|8|9|10).*/i],
+    describe() {
+      return {
+        type: m.tablet,
+        vendor: "Nexus"
+      };
+    }
+  },
+  /* iPad */
+  {
+    test: [/ipad/i],
+    describe() {
+      return {
+        type: m.tablet,
+        vendor: "Apple",
+        model: "iPad"
+      };
+    }
+  },
+  /* Firefox on iPad */
+  {
+    test: [/Macintosh(.*?) FxiOS(.*?)\//],
+    describe() {
+      return {
+        type: m.tablet,
+        vendor: "Apple",
+        model: "iPad"
+      };
+    }
+  },
+  /* Amazon Kindle Fire */
+  {
+    test: [/kftt build/i],
+    describe() {
+      return {
+        type: m.tablet,
+        vendor: "Amazon",
+        model: "Kindle Fire HD 7"
+      };
+    }
+  },
+  /* Another Amazon Tablet with Silk */
+  {
+    test: [/silk/i],
+    describe() {
+      return {
+        type: m.tablet,
+        vendor: "Amazon"
+      };
+    }
+  },
+  /* Tablet */
+  {
+    test: [/tablet(?! pc)/i],
+    describe() {
+      return {
+        type: m.tablet
+      };
+    }
+  },
+  /* iPod/iPhone */
+  {
+    test(t) {
+      const e = t.test(/ipod|iphone/i), r = t.test(/like (ipod|iphone)/i);
+      return e && !r;
+    },
+    describe(t) {
+      const e = i.getFirstMatch(/(ipod|iphone)/i, t);
+      return {
+        type: m.mobile,
+        vendor: "Apple",
+        model: e
+      };
+    }
+  },
+  /* Nexus Mobile */
+  {
+    test: [/nexus\s*[0-6].*/i, /galaxy nexus/i],
+    describe() {
+      return {
+        type: m.mobile,
+        vendor: "Nexus"
+      };
+    }
+  },
+  /* Mobile */
+  {
+    test: [/[^-]mobi/i],
+    describe() {
+      return {
+        type: m.mobile
+      };
+    }
+  },
+  /* BlackBerry */
+  {
+    test(t) {
+      return t.getBrowserName(!0) === "blackberry";
+    },
+    describe() {
+      return {
+        type: m.mobile,
+        vendor: "BlackBerry"
+      };
+    }
+  },
+  /* Bada */
+  {
+    test(t) {
+      return t.getBrowserName(!0) === "bada";
+    },
+    describe() {
+      return {
+        type: m.mobile
+      };
+    }
+  },
+  /* Windows Phone */
+  {
+    test(t) {
+      return t.getBrowserName() === "windows phone";
+    },
+    describe() {
+      return {
+        type: m.mobile,
+        vendor: "Microsoft"
+      };
+    }
+  },
+  /* Android Tablet */
+  {
+    test(t) {
+      const e = Number(String(t.getOSVersion()).split(".")[0]);
+      return t.getOSName(!0) === "android" && e >= 3;
+    },
+    describe() {
+      return {
+        type: m.tablet
+      };
+    }
+  },
+  /* Android Mobile */
+  {
+    test(t) {
+      return t.getOSName(!0) === "android";
+    },
+    describe() {
+      return {
+        type: m.mobile
+      };
+    }
+  },
+  /* desktop */
+  {
+    test(t) {
+      return t.getOSName(!0) === "macos";
+    },
+    describe() {
+      return {
+        type: m.desktop,
+        vendor: "Apple"
+      };
+    }
+  },
+  /* Windows */
+  {
+    test(t) {
+      return t.getOSName(!0) === "windows";
+    },
+    describe() {
+      return {
+        type: m.desktop
+      };
+    }
+  },
+  /* Linux */
+  {
+    test(t) {
+      return t.getOSName(!0) === "linux";
+    },
+    describe() {
+      return {
+        type: m.desktop
+      };
+    }
+  },
+  /* PlayStation 4 */
+  {
+    test(t) {
+      return t.getOSName(!0) === "playstation 4";
+    },
+    describe() {
+      return {
+        type: m.tv
+      };
+    }
+  },
+  /* Roku */
+  {
+    test(t) {
+      return t.getOSName(!0) === "roku";
+    },
+    describe() {
+      return {
+        type: m.tv
+      };
+    }
+  }
+], ot = [
+  /* EdgeHTML */
+  {
+    test(t) {
+      return t.getBrowserName(!0) === "microsoft edge";
+    },
+    describe(t) {
+      if (/\sedg\//i.test(t))
+        return {
+          name: S.Blink
+        };
+      const e = i.getFirstMatch(/edge\/(\d+(\.?_?\d+)+)/i, t);
+      return {
+        name: S.EdgeHTML,
+        version: e
+      };
+    }
+  },
+  /* Trident */
+  {
+    test: [/trident/i],
+    describe(t) {
+      const e = {
+        name: S.Trident
+      }, r = i.getFirstMatch(/trident\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  /* Presto */
+  {
+    test(t) {
+      return t.test(/presto/i);
+    },
+    describe(t) {
+      const e = {
+        name: S.Presto
+      }, r = i.getFirstMatch(/presto\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  /* Gecko */
+  {
+    test(t) {
+      const e = t.test(/gecko/i), r = t.test(/like gecko/i);
+      return e && !r;
+    },
+    describe(t) {
+      const e = {
+        name: S.Gecko
+      }, r = i.getFirstMatch(/gecko\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  },
+  /* Blink */
+  {
+    test: [/(apple)?webkit\/537\.36/i],
+    describe() {
+      return {
+        name: S.Blink
+      };
+    }
+  },
+  /* WebKit */
+  {
+    test: [/(apple)?webkit/i],
+    describe(t) {
+      const e = {
+        name: S.WebKit
+      }, r = i.getFirstMatch(/webkit\/(\d+(\.?_?\d+)+)/i, t);
+      return r && (e.version = r), e;
+    }
+  }
+];
+class X {
+  /**
+   * Create instance of Parser
+   *
+   * @param {String} UA User-Agent string
+   * @param {Boolean} [skipParsing=false] parser can skip parsing in purpose of performance
+   * improvements if you need to make a more particular parsing
+   * like {@link Parser#parseBrowser} or {@link Parser#parsePlatform}
+   *
+   * @throw {Error} in case of empty UA String
+   *
+   * @constructor
+   */
+  constructor(e, r = !1) {
+    if (e == null || e === "")
+      throw new Error("UserAgent parameter can't be empty");
+    this._ua = e, this.parsedResult = {}, r !== !0 && this.parse();
+  }
+  /**
+   * Get UserAgent string of current Parser instance
+   * @return {String} User-Agent String of the current <Parser> object
+   *
+   * @public
+   */
+  getUA() {
+    return this._ua;
+  }
+  /**
+   * Test a UA string for a regexp
+   * @param {RegExp} regex
+   * @return {Boolean}
+   */
+  test(e) {
+    return e.test(this._ua);
+  }
+  /**
+   * Get parsed browser object
+   * @return {Object}
+   */
+  parseBrowser() {
+    this.parsedResult.browser = {};
+    const e = i.find(it, (r) => {
+      if (typeof r.test == "function")
+        return r.test(this);
+      if (r.test instanceof Array)
+        return r.test.some((s) => this.test(s));
+      throw new Error("Browser's test function is not valid");
+    });
+    return e && (this.parsedResult.browser = e.describe(this.getUA())), this.parsedResult.browser;
+  }
+  /**
+   * Get parsed browser object
+   * @return {Object}
+   *
+   * @public
+   */
+  getBrowser() {
+    return this.parsedResult.browser ? this.parsedResult.browser : this.parseBrowser();
+  }
+  /**
+   * Get browser's name
+   * @return {String} Browser's name or an empty string
+   *
+   * @public
+   */
+  getBrowserName(e) {
+    return e ? String(this.getBrowser().name).toLowerCase() || "" : this.getBrowser().name || "";
+  }
+  /**
+   * Get browser's version
+   * @return {String} version of browser
+   *
+   * @public
+   */
+  getBrowserVersion() {
+    return this.getBrowser().version;
+  }
+  /**
+   * Get OS
+   * @return {Object}
+   *
+   * @example
+   * this.getOS();
+   * {
+   *   name: 'macOS',
+   *   version: '10.11.12'
+   * }
+   */
+  getOS() {
+    return this.parsedResult.os ? this.parsedResult.os : this.parseOS();
+  }
+  /**
+   * Parse OS and save it to this.parsedResult.os
+   * @return {*|{}}
+   */
+  parseOS() {
+    this.parsedResult.os = {};
+    const e = i.find(nt, (r) => {
+      if (typeof r.test == "function")
+        return r.test(this);
+      if (r.test instanceof Array)
+        return r.test.some((s) => this.test(s));
+      throw new Error("Browser's test function is not valid");
+    });
+    return e && (this.parsedResult.os = e.describe(this.getUA())), this.parsedResult.os;
+  }
+  /**
+   * Get OS name
+   * @param {Boolean} [toLowerCase] return lower-cased value
+   * @return {String} name of the OS — macOS, Windows, Linux, etc.
+   */
+  getOSName(e) {
+    const { name: r } = this.getOS();
+    return e ? String(r).toLowerCase() || "" : r || "";
+  }
+  /**
+   * Get OS version
+   * @return {String} full version with dots ('10.11.12', '5.6', etc)
+   */
+  getOSVersion() {
+    return this.getOS().version;
+  }
+  /**
+   * Get parsed platform
+   * @return {{}}
+   */
+  getPlatform() {
+    return this.parsedResult.platform ? this.parsedResult.platform : this.parsePlatform();
+  }
+  /**
+   * Get platform name
+   * @param {Boolean} [toLowerCase=false]
+   * @return {*}
+   */
+  getPlatformType(e = !1) {
+    const { type: r } = this.getPlatform();
+    return e ? String(r).toLowerCase() || "" : r || "";
+  }
+  /**
+   * Get parsed platform
+   * @return {{}}
+   */
+  parsePlatform() {
+    this.parsedResult.platform = {};
+    const e = i.find(at, (r) => {
+      if (typeof r.test == "function")
+        return r.test(this);
+      if (r.test instanceof Array)
+        return r.test.some((s) => this.test(s));
+      throw new Error("Browser's test function is not valid");
+    });
+    return e && (this.parsedResult.platform = e.describe(this.getUA())), this.parsedResult.platform;
+  }
+  /**
+   * Get parsed engine
+   * @return {{}}
+   */
+  getEngine() {
+    return this.parsedResult.engine ? this.parsedResult.engine : this.parseEngine();
+  }
+  /**
+   * Get engines's name
+   * @return {String} Engines's name or an empty string
+   *
+   * @public
+   */
+  getEngineName(e) {
+    return e ? String(this.getEngine().name).toLowerCase() || "" : this.getEngine().name || "";
+  }
+  /**
+   * Get parsed platform
+   * @return {{}}
+   */
+  parseEngine() {
+    this.parsedResult.engine = {};
+    const e = i.find(ot, (r) => {
+      if (typeof r.test == "function")
+        return r.test(this);
+      if (r.test instanceof Array)
+        return r.test.some((s) => this.test(s));
+      throw new Error("Browser's test function is not valid");
+    });
+    return e && (this.parsedResult.engine = e.describe(this.getUA())), this.parsedResult.engine;
+  }
+  /**
+   * Parse full information about the browser
+   * @returns {Parser}
+   */
+  parse() {
+    return this.parseBrowser(), this.parseOS(), this.parsePlatform(), this.parseEngine(), this;
+  }
+  /**
+   * Get parsed result
+   * @return {ParsedResult}
+   */
+  getResult() {
+    return i.assign({}, this.parsedResult);
+  }
+  /**
+   * Check if parsed browser matches certain conditions
+   *
+   * @param {Object} checkTree It's one or two layered object,
+   * which can include a platform or an OS on the first layer
+   * and should have browsers specs on the bottom-laying layer
+   *
+   * @returns {Boolean|undefined} Whether the browser satisfies the set conditions or not.
+   * Returns `undefined` when the browser is no described in the checkTree object.
+   *
+   * @example
+   * const browser = Bowser.getParser(window.navigator.userAgent);
+   * if (browser.satisfies({chrome: '>118.01.1322' }))
+   * // or with os
+   * if (browser.satisfies({windows: { chrome: '>118.01.1322' } }))
+   * // or with platforms
+   * if (browser.satisfies({desktop: { chrome: '>118.01.1322' } }))
+   */
+  satisfies(e) {
+    const r = {};
+    let s = 0;
+    const n = {};
+    let o = 0;
+    if (Object.keys(e).forEach((a) => {
+      const c = e[a];
+      typeof c == "string" ? (n[a] = c, o += 1) : typeof c == "object" && (r[a] = c, s += 1);
+    }), s > 0) {
+      const a = Object.keys(r), c = i.find(a, (l) => this.isOS(l));
+      if (c) {
+        const l = this.satisfies(r[c]);
+        if (l !== void 0)
+          return l;
+      }
+      const d = i.find(
+        a,
+        (l) => this.isPlatform(l)
+      );
+      if (d) {
+        const l = this.satisfies(r[d]);
+        if (l !== void 0)
+          return l;
+      }
+    }
+    if (o > 0) {
+      const a = Object.keys(n), c = i.find(a, (d) => this.isBrowser(d, !0));
+      if (c !== void 0)
+        return this.compareVersion(n[c]);
+    }
+  }
+  /**
+   * Check if the browser name equals the passed string
+   * @param browserName The string to compare with the browser name
+   * @param [includingAlias=false] The flag showing whether alias will be included into comparison
+   * @returns {boolean}
+   */
+  isBrowser(e, r = !1) {
+    const s = this.getBrowserName().toLowerCase();
+    let n = e.toLowerCase();
+    const o = i.getBrowserTypeByAlias(n);
+    return r && o && (n = o.toLowerCase()), n === s;
+  }
+  compareVersion(e) {
+    let r = [0], s = e, n = !1;
+    const o = this.getBrowserVersion();
+    if (typeof o == "string")
+      return e[0] === ">" || e[0] === "<" ? (s = e.substr(1), e[1] === "=" ? (n = !0, s = e.substr(2)) : r = [], e[0] === ">" ? r.push(1) : r.push(-1)) : e[0] === "=" ? s = e.substr(1) : e[0] === "~" && (n = !0, s = e.substr(1)), r.indexOf(
+        i.compareVersions(o, s, n)
+      ) > -1;
+  }
+  isOS(e) {
+    return this.getOSName(!0) === String(e).toLowerCase();
+  }
+  isPlatform(e) {
+    return this.getPlatformType(!0) === String(e).toLowerCase();
+  }
+  isEngine(e) {
+    return this.getEngineName(!0) === String(e).toLowerCase();
+  }
+  /**
+   * Is anything? Check if the browser is called "anything",
+   * the OS called "anything" or the platform called "anything"
+   * @param {String} anything
+   * @param [includingAlias=false] The flag showing whether alias will be included into comparison
+   * @returns {Boolean}
+   */
+  is(e, r = !1) {
+    return this.isBrowser(e, r) || this.isOS(e) || this.isPlatform(e);
+  }
+  /**
+   * Check if any of the given values satisfies this.is(anything)
+   * @param {String[]} anythings
+   * @returns {Boolean}
+   */
+  some(e = []) {
+    return e.some((r) => this.is(r));
+  }
+}
+/*!
+ * Bowser - a browser detector
+ * https://github.com/lancedikson/bowser
+ * MIT License | (c) Dustin Diaz 2012-2015
+ * MIT License | (c) Denis Demchenko 2015-2019
+ */
+class ct {
+  /**
+   * Creates a {@link Parser} instance
+   *
+   * @param {String} UA UserAgent string
+   * @param {Boolean} [skipParsing=false] Will make the Parser postpone parsing until you ask it
+   * explicitly. Same as `skipParsing` for {@link Parser}.
+   * @returns {Parser}
+   * @throws {Error} when UA is not a String
+   *
+   * @example
+   * const parser = Bowser.getParser(window.navigator.userAgent);
+   * const result = parser.getResult();
+   */
+  static getParser(e, r = !1) {
+    if (typeof e != "string")
+      throw new Error("UserAgent should be a string");
+    return new X(e, r);
+  }
+  /**
+   * Creates a {@link Parser} instance and runs {@link Parser.getResult} immediately
+   *
+   * @param UA
+   * @return {ParsedResult}
+   *
+   * @example
+   * const result = Bowser.parse(window.navigator.userAgent);
+   */
+  static parse(e) {
+    return new X(e).getResult();
+  }
+  static get BROWSER_MAP() {
+    return oe;
+  }
+  static get ENGINE_MAP() {
+    return S;
+  }
+  static get OS_MAP() {
+    return g;
+  }
+  static get PLATFORMS_MAP() {
+    return m;
+  }
+}
+const O = ct.parse(navigator.userAgent), dt = {
+  abTestGroup: null,
+  abTestName: null,
+  browser: O.browser.name ?? null,
+  browserVersion: O.browser.version ?? null,
+  hardwarePlatform: O.browser.name === "Electron" ? "DESKTOP" : "WEB",
+  isOfflineModeStart: !1,
+  mobileNetworkType: null,
+  networkType: "WIFI",
+  operatingSystem: O.os.name ?? null,
+  operatingSystemVersion: O.os.version ?? null,
+  screenHeight: window.screen.height,
+  screenWidth: window.screen.width,
+  sessionProductId: "",
+  sessionProductType: "TRACK",
+  sessionTags: [],
+  sessionType: "PLAYBACK",
+  startReason: "IMPLICIT",
+  streamingSessionId: "",
+  timestamp: 0
+}, lt = await L(
+  "streaming_session_start",
+  dt
+);
+function ut(t) {
+  return lt(t);
+}
+function ce(t) {
+  const e = `(${t.toString()})();`, r = new Blob([e], { type: "text/javascript" });
+  return URL.createObjectURL(r);
+}
+let _;
+async function ht(t) {
+  const e = await ne(t.data.eventName), r = new Map(e);
+  r.delete(t.data.streamingSessionId), await ae(t.data.eventName, [...r]);
+}
+async function mt() {
+  if (!_) {
+    const { beacon: t } = await import("./worker-qh_9Fyf6-Li0uY2-a.js");
+    _ = new Worker(ce(t)), _.addEventListener("message", (e) => {
+      ht(e);
+    });
+  }
+}
+function pt(t) {
+  return t != null;
+}
+async function de(t, e) {
+  if (t) {
+    const r = (await Promise.all(e.events)).filter(pt);
+    e.events = r;
+    const { clientId: s, token: n } = await v.credentialsProvider.getCredentials();
+    if (!n)
+      throw new Error("No accessToken");
+    const o = {
+      ...e,
+      accessToken: n,
+      apiUrl: k("apiUrl"),
+      appVersion: k("appVersion"),
+      clientId: s,
+      clientPlatform: k("clientPlatform"),
+      eventUrl: k("eventUrl"),
+      ts: b.now()
+    };
+    return t.postMessage(JSON.stringify(o)), o;
+  } else
+    console.warn("Event beacon is not running.");
+}
+const ft = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  commit: de,
+  start: mt,
+  get worker() {
+    return _;
+  },
+  workerize: ce
+}, Symbol.toStringTag, { value: "Module" }));
+async function gt(t) {
+  if (await N())
+    return t();
+}
+function le(t) {
+  return gt(
+    () => de(_, {
+      type: "streaming_metrics",
+      ...t
+    })
+  );
+}
+function wt(t = !0) {
+  const e = t && "crypto" in window && "getRandomValues" in crypto;
+  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(
+    /[018]/g,
+    (r) => (r ^ (e ? crypto.getRandomValues(new Uint8Array(1))[0] : Math.floor(256 * Math.random())) & 15 >> r / 4).toString(16)
+  );
+}
+function yt(t) {
+  return JSON.parse(atob(t));
+}
+function bt(t, e) {
+  if ("codecs" in t)
+    switch (t.codecs) {
+      case "aac":
+        return "aac";
+      case "mp4a.40.2":
+        return "mp4a.40.2";
+      case "aac+":
+        return "aac+";
+      case "mp4a.40.5":
+        return "mp4a.40.5";
+      case "flac":
+        return "flac";
+      case "mqa":
+        return "mqa";
+      case "mp3":
+        return "mp3";
+    }
+  else if (e)
+    switch (e) {
+      case "LOW":
+        return "mp4a.40.5";
+      case "HIGH":
+        return "mp4a.40.2";
+      case "LOSSLESS":
+      case "HI_RES":
+      case "HI_RES_LOSSLESS":
+        return "flac";
+    }
+  return "none";
+}
+function vt(t) {
+  switch (t) {
+    case "mp3":
+      return "mp3";
+    case "aac":
+    case "aac+":
+    case "mp4a.40.2":
+    case "mp4a.40.5":
+      return "aac";
+    case "flac":
+    case "mqa":
+      return t;
+    default:
+      return;
+  }
+}
+function St(t) {
+  const e = /codecs=(["'])?((?:.(?!\1|>))*.?)\1?/.exec(t);
+  if (e === null)
+    return;
+  const r = e[2];
+  if (r.includes("mp4a") || r.includes("aac"))
+    return "aac";
+  if (r === "mqa" || r === "flac")
+    return r;
+}
+function kt(t) {
+  const { prefetched: e, streamingSessionId: r } = t, s = "albumReplayGain" in t ? {
+    albumPeakAmplitude: t.albumPeakAmplitude,
+    albumReplayGain: t.albumReplayGain,
+    trackPeakAmplitude: t.trackPeakAmplitude,
+    trackReplayGain: t.trackReplayGain
+  } : {}, n = "audioQuality" in t ? t.audioQuality : t.videoQuality, o = {
+    id: String(
+      "videoId" in t ? t.videoId : t.trackId
+    ),
+    type: "trackId" in t ? "track" : "video"
+  };
+  if (t.manifestMimeType === "application/vnd.tidal.bts" || t.manifestMimeType === "application/vnd.tidal.emu") {
+    const a = yt(t.manifest), c = a.urls[0], d = bt(
+      a,
+      "audioQuality" in t ? t.audioQuality : null
+    );
+    let l;
+    return "keyId" in a && (l = a.keyId), "licenseSecurityToken" in t && (l = t.licenseSecurityToken), {
+      ...s,
+      bitDepth: "bitDepth" in t ? t.bitDepth ?? void 0 : void 0,
+      codec: vt(d),
+      prefetched: e,
+      quality: n,
+      sampleRate: "sampleRate" in t ? t.sampleRate ?? void 0 : void 0,
+      securityToken: l,
+      streamFormat: d,
+      streamUrl: c,
+      streamingSessionId: r,
+      ...o,
+      expires: t.expires
+    };
+  }
+  if (t.manifestMimeType === "application/dash+xml") {
+    const a = `data:${t.manifestMimeType};base64,${t.manifest}`, c = atob(t.manifest);
+    return {
+      ...s,
+      bitDepth: "bitDepth" in t ? t.bitDepth ?? void 0 : void 0,
+      codec: St(c),
+      prefetched: e,
+      quality: n,
+      sampleRate: "sampleRate" in t ? t.sampleRate ?? void 0 : void 0,
+      securityToken: t.licenseSecurityToken,
+      streamUrl: a,
+      streamingSessionId: r,
+      ...o,
+      expires: t.expires
+    };
+  }
+  throw new TypeError(
+    `${t.manifestMimeType} not supported as playback info manifest mime type.`
+  );
+}
+const ue = async (t, e = {}, r = 3) => {
+  let s, n;
+  try {
+    s = await fetch(t, e);
+  } catch (c) {
+    if (r === 0)
+      throw c;
+    n = null;
+  }
+  if (s?.ok)
+    return s;
+  const o = s && s.status >= 500 && s.status <= 599, a = n === null || o || s?.status === 429;
+  if (r > 0 && a) {
+    const c = 500 * Math.abs(4 - r);
+    return console.debug(
+      `Retrying request for ${Math.abs(
+        4 - r
+      )}th time in ${c}ms`
+    ), await Le(c), ue(t, e, r - 1);
+  }
+  if (!s)
+    throw new Error("Retries exchaused. Cannot fetch playbackinfo.");
+  return s;
+};
+function Mt(t, e) {
+  switch (e) {
+    case 4032:
+    case 4035:
+      return "PEContentNotAvailableInLocation";
+    case 4033:
+      return "PEContentNotAvailableForSubscription";
+    case 4010:
+      return "PEMonthlyStreamQuotaExceeded";
+  }
+  return t >= 500 && t < 600 || t === 429 ? "PERetryable" : t >= 400 && t < 500 ? "PENotAllowed" : "EUnexpected";
+}
+async function Et(t) {
+  const {
+    accessToken: e,
+    audioQuality: r,
+    clientId: s,
+    mediaProduct: n,
+    prefetch: o,
+    streamingSessionId: a
+  } = t, c = k("apiUrl"), d = new URL(
+    `${c}/${n.productType}s/${n.productId}/playbackinfo`
+  ), l = d.searchParams;
+  n.productType === "video" ? l.set("videoquality", "HIGH") : l.set("audioquality", r), l.set("playbackmode", "STREAM"), l.set("assetpresentation", "FULL");
+  const y = new Headers();
+  o && y.set("x-tidal-prefetch", "true"), s && y.set("x-tidal-token", s), e && y.set("authorization", "Bearer " + e), a && y.set("x-tidal-streamingsessionid", a);
+  let M;
+  try {
+    M = await ue(
+      d.toString(),
+      {
+        headers: y,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - It is a thing.
+        importance: "high"
+      },
+      3
+    );
+  } catch {
+    throw new W("PENetwork", "NPBI0");
+  }
+  const f = await M.json();
+  if ("status" in f) {
+    const ke = `A${f.subStatus}`;
+    throw new W(Mt(f.status, f.subStatus), ke);
+  }
+  const ve = "trackId" in f, Se = "videoId" in f;
+  if (!ve && !Se)
+    throw new W("EUnexpected", "B9999");
+  return {
+    ...f,
+    prefetched: o
+  };
+}
+async function Pt(t) {
+  const { streamingSessionId: e } = t, r = [];
+  performance.mark("streaming_metrics:playback_info_fetch:startTimestamp", {
+    detail: e
+  });
+  try {
+    const s = await Et(t);
+    if (s === void 0)
+      throw new Error("Playback info was fetched, but undefined.");
+    H({
+      endReason: "COMPLETE",
+      streamingSessionId: e
+    }).catch(console.error), s.expires = Date.now() + 36e5;
+    const n = "adInfo" in s;
+    return "trackId" in s ? J({
+      actualAssetPresentation: s.assetPresentation,
+      actualAudioMode: s.audioMode,
+      actualProductId: String(s.trackId),
+      actualQuality: s.audioQuality,
+      actualStreamType: void 0,
+      hasAds: n,
+      productType: "TRACK",
+      streamingSessionId: e
+    }).catch(console.error) : J({
+      actualAssetPresentation: s.assetPresentation,
+      actualAudioMode: void 0,
+      actualProductId: String(s.videoId),
+      actualQuality: s.videoQuality,
+      actualStreamType: s.streamType,
+      hasAds: n,
+      productType: "VIDEO",
+      streamingSessionId: e
+    }).catch(console.error), performance.mark("streaming_metrics:playback_info_fetch:endTimestamp", {
+      detail: e
+    }), s;
+  } catch (s) {
+    throw performance.mark("streaming_metrics:playback_info_fetch:endTimestamp", {
+      detail: e
+    }), H({
+      endReason: "ERROR",
+      errorCode: s.message,
+      errorMessage: s.stack,
+      streamingSessionId: e
+    }).catch(console.error), r.push(
+      rt({
+        streamingSessionId: e,
+        timestamp: b.timestamp(
+          "streaming_metrics:playback_info_fetch:endTimestamp"
+        )
+      })
+    ), s;
+  } finally {
+    r.push(
+      H({
+        endTimestamp: b.timestamp(
+          "streaming_metrics:playback_info_fetch:endTimestamp"
+        ),
+        startTimestamp: b.timestamp(
+          "streaming_metrics:playback_info_fetch:startTimestamp"
+        ),
+        streamingSessionId: e
+      })
+    ), le({
+      events: r
+    }).catch(console.error), performance.clearMarks(
+      "streaming_metrics:playback_info_fetch:endTimestamp"
+    ), performance.clearMarks(
+      "streaming_metrics:playback_info_fetch:startTimestamp"
+    );
+  }
+}
+class he {
+  /**
+   * The current time position to restore playback from when connection is back online.
+   */
+  static #e = 0;
+  static #r = !1;
+  /**
+   * The media product to restore when connection is back online.
+   */
+  static #s = null;
+  static #t;
+  static #i;
+  static #n;
+  static disable() {
+    this.#r && (this.#t && window.removeEventListener("offline", this.#t, !1), this.#i && window.removeEventListener("online", this.#i, !1), this.#i = void 0, this.#t = void 0, this.#r = !1);
+  }
+  static enable() {
+    this.#r || (this.#i = () => this.#o(), this.#t = () => this.#a(), window.addEventListener("offline", this.#t, !1), window.addEventListener("online", this.#i, !1), this.#r = !0);
+  }
+  static #a() {
+    const { activePlayer: e } = p;
+    !e || !e.hasStarted() || (this.#s = e.currentMediaProduct, this.#n = this.#d.bind(this), h.addEventListener(
+      "playback-state-change",
+      this.#n
+    ));
+  }
+  static #o() {
+    const { activePlayer: e } = p;
+    !e || !e.hasStarted() || (e.playbackState !== "PLAYING" && this.#s && (h.dispatchEvent(
+      new CustomEvent("load", {
+        detail: {
+          currentTime: this.#e,
+          mediaProduct: this.#s
+        }
+      })
+    ), this.#c()), h.removeEventListener(
+      "playback-state-change",
+      this.#n
+    ));
+  }
+  static #c() {
+    this.#s = null, this.#e = 0;
+  }
+  static #d() {
+    const { activePlayer: e } = p;
+    e && (this.#e = e.currentTime);
+  }
+}
+const Tt = "streaming-privileges-revoked";
+function It(t) {
+  return new CustomEvent(Tt, {
+    detail: t
+  });
+}
+let I;
+async function me(t) {
+  const e = k("apiUrl"), r = await fetch(e + "/rt/connect", {
+    headers: new Headers({
+      Authorization: "Bearer " + t,
+      "Content-Type": "application/json"
+    }),
+    method: "POST"
+  }), { url: s } = await r.json();
+  return s;
+}
+function pe(t) {
+  return new Promise((e) => {
+    t.addEventListener("open", () => e(), { once: !0 });
+  });
+}
+class z {
+  #e;
+  #r;
+  #s;
+  #t;
+  constructor() {
+    this.#t = void 0, this.#r = this.#i(), h.addEventListener("user-action", () => {
+      this.connected && this.userAction().then().catch(console.error);
+    });
+  }
+  /**
+   * Call this method to ensure pushkin is running.
+   */
+  static async ensure() {
+    await N() && (I ? I.connected || await I.reconnect() : I = new z());
+  }
+  /**
+   * Call this method when credentials changes to re-setup pushkin with the new credentials
+   */
+  static async refresh() {
+    if (!await N())
+      return;
+    const e = await Y();
+    I && e && I.reconnect().catch(console.error);
+  }
+  async #i() {
+    const e = await Y();
+    if (!e)
+      throw new Error("No access token to connect to Pushkin.");
+    const r = await me(e);
+    r && (this.#t = new WebSocket(r), await pe(this.#t), this.#s = (s) => this.#o(s.data), this.#e = () => this.#a(), this.#t.addEventListener("message", this.#s, !1), this.#t.addEventListener("closed", this.#e, !1), window.addEventListener("online", () => this.#a(), {
+      once: !0
+    }));
+  }
+  async #n(e) {
+    if (!this.#t)
+      throw new Error(
+        "No socket connected. Did you forget to call connect method in Pushkin service first?"
+      );
+    this.#t.readyState !== WebSocket.OPEN && await this.#r, this.#t.send(JSON.stringify(e));
+  }
+  #a() {
+    this.#r = this.#i();
+  }
+  #o(e) {
+    const r = JSON.parse(e);
+    switch (r.type) {
+      case "PRIVILEGED_SESSION_NOTIFICATION": {
+        h.dispatchEvent(
+          It(
+            String(r.payload.clientDisplayName)
+          )
+        ), p.activePlayer?.pause();
+        break;
+      }
+      case "RECONNECT":
+        this.reconnect().catch(console.error);
+        break;
+      default:
+        console.warn("Unhandled event from Pushkin: ", r);
+        break;
+    }
+  }
+  reconnect() {
+    return this.#t ? (this.#s && this.#t.removeEventListener("message", this.#s), this.#e && this.#t.removeEventListener("closed", this.#e), this.#t.close(), this.#r = this.#i(), this.#r) : Promise.resolve();
+  }
+  /**
+   * Call this method to tell Pushkin a user action happened, so it can
+   * make good qualified guesses if you're the session with allowed playback-
+   */
+  async userAction() {
+    this.connected || await this.reconnect();
+    try {
+      await this.#n({
+        payload: {
+          startedAt: b.now()
+        },
+        type: "USER_ACTION"
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+  get connected() {
+    return this.#t && this.#t.readyState === WebSocket.OPEN;
+  }
+}
+const Lt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Pushkin: z,
+  fetchWebSocketURL: me,
+  socketOpen: pe
+}, Symbol.toStringTag, { value: "Module" }));
+async function Ot() {
+  Ue(), he.disable(), await xe();
+}
+const At = {
+  actions: [],
+  actualAssetPresentation: "PREVIEW",
+  actualAudioMode: "STEREO",
+  actualProductId: "",
+  actualQuality: "LOW",
+  endAssetPosition: -1,
+  endTimestamp: -1,
+  isPostPaywall: !1,
+  playbackSessionId: "",
+  productType: "TRACK",
+  requestedProductId: "",
+  sourceId: "",
+  sourceType: "",
+  startAssetPosition: -1,
+  startTimestamp: -1
+}, fe = await L(
+  "playback_session",
+  At
+);
+function Xt(t) {
+  return fe(t);
+}
+function Zt(t, e) {
+  return fe({
+    actions: [e],
+    streamingSessionId: t
+  });
+}
+async function ge(t, e = 0, r = !1) {
+  if (await b.synchronize(), z.ensure().catch(console.error), p.activePlayer?.nextItem && p.activePlayer.nextItem.mediaProduct.productId === t.productId) {
+    const f = p.activePlayer;
+    return performance.mark(
+      "streaming_metrics:playback_statistics:idealStartTimestamp",
+      { detail: p.preloadedStreamingSessionId }
+    ), await f.reset({ keepPreload: !0 }), t.referenceId && p.preloadedStreamingSessionId && f.overwriteMediaProduct(
+      p.preloadedStreamingSessionId,
+      t
+    ), f.skipToPreloadedMediaProduct();
+  }
+  const s = Ot(), n = wt();
+  le({
+    events: [
+      ut({
+        sessionProductId: t.productId,
+        sessionProductType: t.productType === "track" ? "TRACK" : "VIDEO",
+        sessionType: "PLAYBACK",
+        startReason: "EXPLICIT",
+        streamingSessionId: n,
+        timestamp: b.now()
+      })
+    ]
+  }).catch(console.error), performance.mark(
+    "streaming_metrics:playback_statistics:idealStartTimestamp",
+    { detail: n }
+  );
+  const { clientId: o, token: a } = await v.credentialsProvider.getCredentials(), c = k("streamingWifiAudioQuality");
+  let d = null;
+  try {
+    d = await Pt({
+      accessToken: a,
+      audioQuality: c,
+      clientId: o,
+      mediaProduct: t,
+      prefetch: r,
+      streamingSessionId: n
+    });
+  } catch (f) {
+    f instanceof W && h.dispatchError(f), document.location.href.includes("localhost") && console.error(f);
+  }
+  if (!d)
+    return;
+  const l = kt(d);
+  Q.saveStreamInfo(
+    l.streamingSessionId,
+    l
+  ), await s, he.enable();
+  const y = "trackId" in d ? d.audioQuality : void 0, M = await He(
+    t.productType,
+    y
+  );
+  return De(M), M.load(
+    {
+      assetPosition: e,
+      mediaProduct: t,
+      playbackInfo: d,
+      streamInfo: l
+    },
+    "explicit"
+  );
+}
+h.addEventListener("load", (t) => {
+  if (t instanceof CustomEvent) {
+    const { currentTime: e, mediaProduct: r } = t.detail;
+    ge(r, e).then().catch(console.error);
+  }
+});
+function Ct() {
+  return p.activePlayer?.pause();
+}
+async function _t() {
+  await b.synchronize();
+  const { activePlayer: t } = p;
+  return t ? (h.dispatchEvent(new CustomEvent("user-action")), t.play()) : Promise.reject(new Error("No active player"));
+}
+async function Nt(t) {
+  const { activePlayer: e } = p;
+  return e?.seek(t);
+}
+function er(t) {
+  v.credentialsProvider = t;
+}
+const Ft = "active-device-changed";
+function tr(t) {
+  return new CustomEvent(Ft, {
+    detail: t
+  });
+}
+const Bt = "active-device-mode-changed";
+function rr(t) {
+  return new CustomEvent(Bt, {
+    detail: t
+  });
+}
+const Rt = "active-device-pass-through-changed";
+function sr(t) {
+  return new CustomEvent(Rt, {
+    detail: t
+  });
+}
+b.synchronize().then().catch(console.error);
+function we() {
+  const { activePlayer: t } = p;
+  if (!t)
+    return null;
+  switch (t.name) {
+    case "shakaPlayer":
+      return t.mediaElement;
+    case "browserPlayer":
+      return t.mediaElement;
+    default:
+      return null;
+  }
+}
+Pe().then().catch(console.error);
+Ie().then().catch(console.error);
+const j = String.raw, xt = String.raw;
+function ye(t) {
+  if (t === void 0)
+    return "0:00";
+  const e = parseInt(String(t), 10), r = Math.floor(e / 3600), s = Math.floor((e - r * 3600) / 60), n = e - r * 3600 - s * 60;
+  let o = "";
+  if (r !== 0) {
+    const a = s < 10 ? `0${s}` : String(s);
+    o = `${r}:${a}:`;
+  } else
+    o = `${s}:`;
+  return o += n < 10 ? `0${n}` : String(n), o;
+}
+function be(t = 0) {
+  const e = typeof t == "number" ? t : parseInt(t, 10), r = Math.floor(e / 3600) % 24, s = Math.floor(e / 60) % 60, n = e % 60, o = (c, d) => {
+    if (c === 0 && d !== 1)
+      return "";
+    let l;
+    switch (d) {
+      case 0:
+        l = "H";
+        break;
+      case 1:
+        l = "M";
+        break;
+      default:
+        l = "S";
+        break;
+    }
+    return `${l}${c}`;
+  };
+  return `P${[r, s, n].map(o).join("")}`;
+}
+const Dt = "tidal-current-time";
+class Ut extends HTMLElement {
+  #e = void 0;
+  #r = /* @__PURE__ */ new Set();
+  #s;
+  #t;
+  #i;
+  constructor() {
+    super(), this.#i = (e) => this.renderTime(e.target.currentTime), this.#t = () => this.renderTime(0), this.#s = this.#n.bind(this);
+  }
+  #n() {
+    const e = we();
+    e && this.#e && !this.#r.has(e) && (e.addEventListener("timeupdate", this.#i, !1), this.#r.add(e));
+  }
+  connectedCallback() {
+    const e = this.attachShadow({ mode: "open" });
+    e.innerHTML = "<time></time>";
+    const r = e.querySelector("time");
+    this.#e === void 0 && r !== null && (this.#e = r), this.renderTime(qe()), h.addEventListener(
+      "media-product-transition",
+      this.#s,
+      !1
+    ), h.addEventListener("ended", this.#t, !1);
+  }
+  disconnectedCallback() {
+    for (let e of this.#r)
+      e.removeEventListener(
+        "timeupdate",
+        this.#i,
+        !1
+      );
+    h.removeEventListener(
+      "media-product-transition",
+      this.#s,
+      !1
+    ), h.removeEventListener("ended", this.#t, !1);
+  }
+  renderTime(e) {
+    const r = Math.floor(e);
+    this.#e && (this.#e.textContent = ye(r), this.#e.setAttribute("datetime", be(r)));
+  }
+}
+customElements.define(Dt, Ut);
+const Wt = "tidal-duration-time";
+class zt extends HTMLElement {
+  #e;
+  #r = !1;
+  #s;
+  constructor() {
+    super(), this.#s = (e) => {
+      const r = e;
+      this.renderTime(r.detail.playbackContext.actualDuration);
+    }, this.#t();
+  }
+  #t() {
+    this.#r || (h.addEventListener(
+      "media-product-transition",
+      this.#s,
+      !1
+    ), this.#r = !0);
+  }
+  #i() {
+    const e = this.attachShadow({ mode: "open" });
+    this.#e = document.createElement("time"), e.appendChild(this.#e);
+  }
+  connectedCallback() {
+    this.#t(), this.#i();
+    const e = parseInt(String(this.textContent), 10), r = Number.isNaN(e) ? 0 : e;
+    this.renderTime($e()?.actualDuration ?? r);
+  }
+  disconnectedCallback() {
+    h.removeEventListener(
+      "media-product-transition",
+      this.#s,
+      !1
+    ), this.#r = !1;
+  }
+  renderTime(e) {
+    const r = parseInt(e.toFixed(0), 10);
+    this.#e && (this.#e.textContent = ye(r), this.#e.setAttribute("datetime", be(r)));
+  }
+}
+customElements.define(Wt, zt);
+const Vt = "tidal-play-trigger";
+class Ht extends HTMLElement {
+  #e;
+  #r = !1;
+  constructor() {
+    super(), this.#e = (e) => {
+      e.preventDefault(), this.#s().catch(console.error);
+    }, this.#i();
+  }
+  static get observedAttributes() {
+    return ["product-id", "product-type"];
+  }
+  async #s() {
+    await this.#t(), se() === "PLAYING" ? Ct() : await _t();
+  }
+  #t() {
+    const e = Qe()?.productId ?? void 0;
+    if (this.mediaProduct && this.mediaProduct.productId !== e)
+      return ge(this.mediaProduct, 0);
+  }
+  #i() {
+    this.#r || this.addEventListener("click", this.#e, { passive: !0 });
+  }
+  #n() {
+    const e = this.attachShadow({ mode: "closed" }), r = document.createElement("style");
+    r.textContent = j`
+      :host {
+        display: contents;
+      }
+    `;
+    const s = document.createElement("slot");
+    e.appendChild(r), e.appendChild(s);
+  }
+  connectedCallback() {
+    this.#i(), this.#n();
+  }
+  disconnectedCallback() {
+    this.removeEventListener("click", this.#e, {
+      passive: !0
+    }), this.#r = !1;
+  }
+  get mediaProduct() {
+    const e = this.getAttribute("product-id");
+    if (!e)
+      return;
+    const r = this.getAttribute("product-type") === "video" ? "video" : "track";
+    return {
+      productId: e,
+      productType: r,
+      sourceId: "",
+      sourceType: ""
+    };
+  }
+}
+customElements.define(Vt, Ht);
+const qt = j`
+  :host {
+    display: inline-block;
+  }
+
+  #wrapper {
+    width: 100%;
+    height: 100%;
+    contain: strict;
+    background-color: rgba(255, 255, 255, 0.2);
+    cursor: pointer;
+  }
+
+  #indicator {
+    width: 100%;
+    height: 100%;
+    transform: none;
+    will-change: transform;
+    background-color: currentColor;
+    pointer-events: none;
+  }
+`, Z = {
+  NO_DURATION: "You need to set duration before you can start/stop the progress bar."
+};
+class Qt extends HTMLElement {
+  #e;
+  #r = 1;
+  #s = null;
+  #t;
+  #i;
+  #n = /* @__PURE__ */ new Set();
+  #a = null;
+  #o;
+  constructor() {
+    super(), this.#t = (e) => {
+      const r = e;
+      if (this.duration = r.detail.playbackContext.actualDuration, se() === "PLAYING")
+        try {
+          this.start();
+        } catch (s) {
+          console.warn(s);
+        }
+    }, this.#i = (e) => {
+      const r = e;
+      try {
+        r.detail.state === "PLAYING" ? this.start() : this.stop();
+      } catch (s) {
+        console.warn(s);
+      }
+    }, this.#o = (e) => {
+      (e instanceof MouseEvent || e instanceof PointerEvent) && this.handleClick(e);
+    }, this.#c();
+  }
+  #c() {
+    this.#n.has("media-product-transition") || (h.addEventListener(
+      "media-product-transition",
+      this.#t,
+      !1
+    ), this.#n.add("media-product-transition")), this.#n.has("playback-state-change") || (h.addEventListener(
+      "playback-state-change",
+      this.#i
+    ), this.#n.add("playback-state-change")), this.#a && !this.#n.has("wrapper-click") && (this.#a.addEventListener("click", this.#o, !1), this.#n.add("wrapper-click"));
+  }
+  #d() {
+    const e = this.attachShadow({ mode: "closed" });
+    e.innerHTML = xt`
+      <style>
+        ${qt}
+      </style>
+      <div id="wrapper">
+        <div id="indicator"></div>
+      </div>
+    `, this.#a = e.querySelector("#wrapper"), this.#s = e.querySelector("#indicator");
+  }
+  /**
+   * Renders the progress bar to a shadow DOM, caches references to the wrapper
+   * && indicator elements and adds a click handler to the wrapper element for
+   * handling the seeking.
+   */
+  connectedCallback() {
+    this.#d(), this.#c();
+  }
+  disconnectedCallback() {
+    h.removeEventListener(
+      "media-product-transition",
+      this.#t,
+      !1
+    ), h.removeEventListener(
+      "playback-state-change",
+      this.#i
+    ), this.#a?.addEventListener("click", this.#o, !1), this.#n.clear();
+  }
+  /**
+   * Calculates where in the progress bar the person clicked
+   * in percent.
+   *
+   * @param {MouseEvent} mouse
+   */
+  getMousePositionAsPercent(e) {
+    if (this.#a) {
+      const r = this.#a.getBoundingClientRect(), s = {
+        left: Math.abs(r.left + window.pageXOffset - e.pageX),
+        width: Math.round(r.width)
+      };
+      return s.left / s.width;
+    }
+    return 0;
+  }
+  /**
+   * Handle clicking the progress bar wrapper. Calculate the percentate
+   * to seek to and emits a progress-bar:seek CustomEvent to be listened
+   * to outside this component to react to the click.
+   *
+   * @param {MouseEvent | PointerEvent} event
+   */
+  handleClick(e) {
+    const r = this.getMousePositionAsPercent(e), s = this.#r * r;
+    this.currentTime = s, Nt(s / 1e3);
+  }
+  /**
+   * Starts the animation if duration is defined.
+   *
+   * @throws Will throw an error if duration is not set.
+   */
+  start() {
+    if (!this.#e)
+      throw new Error(Z.NO_DURATION);
+    this.#e.play();
+  }
+  /**
+   * Stops the animation if duration is defined.
+   *
+   * @throws Will throw an error if duration is not set.
+   */
+  stop() {
+    if (!this.#e)
+      throw new Error(Z.NO_DURATION);
+    this.#e.pause();
+  }
+  /**
+   * Set current time with milliseconds.
+   *
+   * @memberof ProgressBar
+   */
+  set currentTime(e) {
+    this.#e && (this.#e.currentTime = e);
+  }
+  /**
+   * Setting this recrates the animation with the new duraton and pauses the animation.
+   */
+  set duration(e) {
+    this.#r = e * 1e3;
+    const r = [
+      {
+        transform: "translateX(-100%)"
+      },
+      {
+        transform: "translateX(0%)"
+      }
+    ];
+    this.#e = this.#s?.animate(r, {
+      duration: this.#r,
+      iterations: 1
+    }), this.#e?.pause();
+  }
+  /**
+   * Setting this stops the animations, updates the playback rate and plays it again.
+   */
+  set playbackRate(e) {
+    this.stop(), this.#e && (this.#e.playbackRate = e), this.start();
+  }
+}
+const $t = "tidal-progress-bar";
+customElements.define($t, Qt);
+const jt = j`
+  :host {
+    position: relative;
+    display: block;
+    width: 100%;
+    aspect-ratio: 16/9;
+    background-color: black;
+  }
+
+  ::slotted(video) {
+    display: block;
+    width: 100%;
+    height: 100%;
+    z-index: 1;
+    position: relative;
+    background-color: black;
+  }
+`, Gt = "tidal-video-view";
+class Kt extends HTMLElement {
+  #e = !1;
+  #r;
+  #s;
+  constructor() {
+    super(), this.#r = (e) => {
+      e.detail.mediaProduct.productType === "video" && this.mountPlayer();
+    }, this.#s = (e) => {
+      const r = e;
+      this.setAttribute(
+        "playback-state",
+        r.detail.state.toLocaleLowerCase()
+      );
+    }, this.#t();
+  }
+  #t() {
+    this.#e || (h.addEventListener(
+      "media-product-transition",
+      this.#r,
+      !1
+    ), h.addEventListener(
+      "playback-state-change",
+      this.#s,
+      !1
+    ));
+  }
+  connectedCallback() {
+    this.#t();
+    const e = this.attachShadow({ mode: "closed" }), r = document.createElement("style");
+    r.textContent = jt;
+    const s = document.createElement("slot");
+    e.appendChild(r), e.appendChild(s);
+  }
+  disconnectedCallback() {
+    h.removeEventListener(
+      "media-product-transition",
+      this.#r,
+      !1
+    ), h.removeEventListener(
+      "playback-state-change",
+      this.#s,
+      !1
+    ), this.#e = !0;
+  }
+  mountPlayer() {
+    const e = we();
+    e && (this.innerHTML = "", this.appendChild(e));
+  }
+}
+customElements.define(Gt, Kt);
+export {
+  E as A,
+  ge as B,
+  Me as F,
+  Zt as G,
+  W as H,
+  Te as N,
+  P as O,
+  b as P,
+  Jt as Q,
+  Le as R,
+  v as S,
+  Yt as U,
+  er as X,
+  L as _,
+  Xt as a,
+  k as b,
+  gt as c,
+  _ as d,
+  Dt as e,
+  Wt as f,
+  wt as g,
+  ct as h,
+  sr as i,
+  le as j,
+  Q as k,
+  p as l,
+  Vt as m,
+  J as n,
+  rt as o,
+  $t as p,
+  Gt as q,
+  rr as s,
+  tr as t,
+  de as w,
+  h as y
+};