@tidal-music/player-web-components 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import { CredentialsProvider } from '@tidal-music/common';
+import { events } from '@tidal-music/player';
+import { setCredentialsProvider } from '@tidal-music/player';
+
+export { CredentialsProvider }
+
+export { events }
+
+export { setCredentialsProvider }
+
+export declare const TidalCurrentTime = "tidal-current-time";
+
+export declare const TidalDurationTime = "tidal-duration-time";
+
+export declare const TidalPlayButton = "tidal-play-trigger";
+
+export declare const TidalProgressBar = "tidal-progress-bar";
+
+export declare const TidalVideoView = "tidal-video-view";
+
+export { }

package/dist/index.js

@@ -0,0 +1,10 @@
+import { e as i, f as s, m as r, p as d, q as t, y as l, X as o } from "./index-tM9JvbA8.js";
+export {
+  i as TidalCurrentTime,
+  s as TidalDurationTime,
+  r as TidalPlayButton,
+  d as TidalProgressBar,
+  t as TidalVideoView,
+  l as events,
+  o as setCredentialsProvider
+};

package/dist/nativePlayer-U375Dfm5-hUK7oXzY.js

@@ -0,0 +1,362 @@
+import { b as m, y as s, H as u, n as k, P as p, k as o, l as g, s as P, t as S, i as b } from "./index-tM9JvbA8.js";
+import { Y as f, V as y, O as L } from "./basePlayer-a-avZASH-Ux-6s9Ex.js";
+const E = "active-device-disconnected";
+function w() {
+  return new CustomEvent(E);
+}
+const D = {
+  file_checksum_mismatch: "NPO02",
+  no_such_file: "NPO01",
+  unreadable_file: "NPO03"
+}, N = {
+  devicedisconnected: "NPD01",
+  deviceexclusivemodenotallowed: "NPD02",
+  deviceformatnotsupported: "NPD03",
+  devicelocked: "NPD04",
+  devicenotfound: "NPD05",
+  deviceunknownerror: "NPD00"
+};
+let i;
+class A extends f {
+  #s = "default";
+  /**
+   * A Boolean which is true if the media contained in the element has finished playing.
+   *
+   * (Native player sends multiple "complete" events.
+   * This variable should be set to true on the first call
+   * to be able to ignore subsequent onces; until reset
+   * for a new media product.)
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/ended
+   */
+  #i;
+  #r = !0;
+  #e;
+  #a;
+  name = "nativePlayer";
+  playbackEngineHandlerAttached = !1;
+  constructor() {
+    super(), m("outputDevicesEnabled") && (async () => (i = (await import("./output-devices-NXuo75MQ-_vYYuqUm.js")).outputDevices, this.#e.listDevices()))(), this.#e = // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    window.NativePlayerComponent.Player(), this.playbackState = "IDLE", this.registerEventListeners(), this.#e.setVolume(100);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  #t(e) {
+    s.dispatchError(
+      new u("EUnexpected", N[e])
+    );
+  }
+  #d(e) {
+    this.debugLog("handleMediaError", e.target);
+    const t = e.target, a = D[t.errorCode];
+    this.currentStreamingSessionId && k({
+      errorCode: a,
+      errorMessage: JSON.stringify(e.target),
+      streamingSessionId: this.currentStreamingSessionId
+    }), s.dispatchError(new u("EUnexpected", a));
+  }
+  #n(e) {
+    switch (this.debugLog("handleNativePlayerStateChange", e), e) {
+      case "paused":
+      case "ready":
+        this.playbackState = "NOT_PLAYING";
+        break;
+      case "active":
+        this.playbackState = "PLAYING";
+        break;
+      case "seeking":
+      case "idle":
+        this.playbackState = "STALLED";
+        break;
+      case "uninitialized":
+        this.playbackState = "IDLE";
+        break;
+      case "stopped":
+        this.playbackState = "NOT_PLAYING";
+        break;
+      default:
+        this.debugLog("No handling for state", e);
+        break;
+    }
+  }
+  async #o() {
+    this.debugLog("handleNetworkError");
+    const e = p.timestamp(
+      "streaming_metrics:playback_statistics:actualStartTimestamp"
+    );
+    if ((e !== void 0 ? Math.abs(p.now() - e) : 0) >= 36e5) {
+      const t = structuredClone(this.currentMediaProduct), a = this.currentTime;
+      this.finishCurrentMediaProduct("error"), t && (await this.hardReload(t, a), await this.play());
+      return;
+    }
+    await Promise.race([
+      this.mediaStateChange("idle"),
+      new Promise((t) => {
+        window.addEventListener("online", () => t("online"));
+      })
+    ]) === "idle" && s.dispatchError(new u("PENetwork", "NPN01"));
+  }
+  /**
+   * Clean up native player before leaving for another player.
+   */
+  abandon() {
+    i && i.deviceMode === "exclusive" && this.#e.selectSystemDevice();
+  }
+  getPosition() {
+    return this.currentTime;
+  }
+  /**
+   * We cannot run multiple instances of native player so this function is
+   * for catching duration for a preloaded item in native player.
+   *
+   * I.e. wait for player to load it and emit mediaduration event, then we
+   * can gather the duration data and send a media product transition.
+   */
+  async handleAutomaticTransitionToPreloadedMediaProduct() {
+    await this.nativeEvent("mediaduration"), this.#a = void 0;
+    const e = o.getMediaProductTransition(
+      this.preloadedStreamingSessionId
+    );
+    if (!e) {
+      console.warn(
+        "No media product transition saved for next item. Stopping playback."
+      ), this.playbackState = "NOT_PLAYING";
+      return;
+    }
+    const { mediaProduct: t, playbackContext: a } = e, r = {
+      ...a,
+      actualDuration: this.#i
+    };
+    this.preloadedStreamingSessionId && o.saveMediaProductTransition(
+      this.preloadedStreamingSessionId,
+      {
+        mediaProduct: t,
+        playbackContext: r
+      }
+    ), await this.mediaStateChange("active"), s.dispatchEvent(
+      y(t, r)
+    ), this.currentStreamingSessionId = this.preloadedStreamingSessionId, this.mediaProductStarted(this.currentStreamingSessionId);
+  }
+  async load(e, t) {
+    this.debugLog("load", e), this.currentTime = e.assetPosition, this.startAssetPosition = e.assetPosition, await this.reset(), this.#r = !1;
+    const { assetPosition: a, mediaProduct: r, playbackInfo: h, streamInfo: d } = e, { securityToken: c, streamFormat: n, streamUrl: l } = d;
+    this.currentStreamingSessionId = d.streamingSessionId, t === "explicit" && (this.playbackState = "NOT_PLAYING");
+    const I = this.nativeEvent("mediaduration");
+    if (n)
+      this.#e.load(l, n, c);
+    else
+      throw new Error("Stream format is undefined.");
+    if (await I, this.currentStreamingSessionId !== d.streamingSessionId)
+      return;
+    this.debugLog("load() duration is", this.#i), a !== 0 && a < this.#i ? (async () => {
+      await this.mediaStateChange("active"), await this.seek(a), this.currentTime = a;
+    })().catch(console.error) : this.currentTime = 0;
+    const v = L({
+      assetPosition: a,
+      duration: this.#i,
+      playbackInfo: h,
+      streamInfo: d
+    });
+    o.saveMediaProductTransition(
+      d.streamingSessionId,
+      { mediaProduct: r, playbackContext: v }
+    ), this.debugLog("load() mediaProductTransition"), s.dispatchEvent(
+      y(r, v)
+    ), this.debugLog("load() pb NOT_PLAYING"), this.debugLog("load() done");
+  }
+  mediaStateChange(e) {
+    return new Promise((t) => {
+      this.#e.addEventListener(
+        "mediastate",
+        (a) => {
+          a.target === e && t(a.target);
+        }
+      );
+    });
+  }
+  nativeEvent(e) {
+    return new Promise((t) => {
+      this.#e.addEventListener(
+        e,
+        (a) => t(a)
+      );
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async next(e) {
+    this.debugLog("next", e), this.hasNextItem() && await this.unloadPreloadedMediaProduct();
+    const { mediaProduct: t, playbackInfo: a, streamInfo: r } = e, { securityToken: h, streamFormat: d, streamUrl: c, streamingSessionId: n } = r;
+    this.preloadedStreamingSessionId = n, this.debugLog("preloading", c, "for", n), d ? this.#e.preload(c, d, h) : console.error("Stream format undefined for preload."), this.debugLog("preloading done");
+    const l = L({
+      assetPosition: 0,
+      duration: 0,
+      // TODO: Cannot get duration here, try to solve in some other way...
+      playbackInfo: a,
+      streamInfo: r
+    });
+    o.saveMediaProductTransition(n, {
+      mediaProduct: t,
+      playbackContext: l
+    }), this.#a = e;
+  }
+  pause() {
+    this.#e.pause();
+  }
+  async play() {
+    if (this.debugLog("play"), await this.maybeHardReload(), this.playbackState === "IDLE") {
+      this.debugLog("play()", this.playbackState, "returning early");
+      return;
+    }
+    this.setStateToXIfNotYInZMs(1e3, "PLAYING", "STALLED"), await this.updateOutputDevice(), this.mediaProductStarted(this.currentStreamingSessionId), this.debugLog("nativePlayer", "play()"), this.#e.play();
+  }
+  async playbackEngineEndedHandler(e) {
+    if (this.isActivePlayer) {
+      const { reason: t } = e.detail;
+      t === "completed" && (this.hasNextItem() ? await this.handleAutomaticTransitionToPreloadedMediaProduct() : (g.preloadedStreamingSessionId ? this.debugLog(
+        `Switching player from ${this.name} to ${g.preloadPlayer?.name}`
+      ) : this.debugLog("No next item queued."), this.playbackState = "NOT_PLAYING"));
+    }
+  }
+  registerEventListeners() {
+    this.debugLog("registerEventListeners"), this.#e.addEventListener("mediacurrenttime", (e) => {
+      this.currentTime = Number(e.target);
+    }), this.#e.addEventListener(
+      "mediastate",
+      (e) => {
+        e.target === "completed" ? this.finishCurrentMediaProduct("completed") : this.#n(e.target);
+      }
+    ), this.#e.addEventListener(
+      "devices",
+      (e) => {
+        i ? i.addNativeDevices(e.target) : console.error("Output devices not loaded.");
+      }
+    ), this.#e.addEventListener("devicedisconnected", () => {
+      s.dispatchEvent(w()), this.#t("devicedisconnected");
+    }), this.#e.addEventListener(
+      "deviceexclusivemodenotallowed",
+      () => this.#t("deviceexclusivemodenotallowed")
+    ), this.#e.addEventListener(
+      "deviceformatnotsupported",
+      () => this.#t("deviceformatnotsupported")
+    ), this.#e.addEventListener(
+      "devicelocked",
+      () => this.#t("devicelocked")
+    ), this.#e.addEventListener(
+      "devicenotfound",
+      () => this.#t("devicenotfound")
+    ), this.#e.addEventListener(
+      "deviceunknownerror",
+      () => this.#t("deviceunknownerror")
+    ), this.#e.addEventListener(
+      "mediaduration",
+      (e) => {
+        this.#i = Number(e.target);
+      }
+    ), this.#e.addEventListener(
+      "mediaerror",
+      (e) => this.#d(e)
+    ), this.#e.addEventListener("mediamaxconnectionsreached", () => {
+      this.#o().catch(console.error);
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async reset({ keepPreload: e } = { keepPreload: !1 }) {
+    this.#r || (this.debugLog("reset"), e || await this.unloadPreloadedMediaProduct(), this.#e.stop(), this.playbackState !== "IDLE" && this.hasStarted() && this.finishCurrentMediaProduct("skip"), this.detachPlaybackEngineEndedHandler(), this.currentStreamingSessionId = void 0, e || (this.preloadedStreamingSessionId = void 0), this.playbackState = "IDLE", this.#r = !0);
+  }
+  async seek(e) {
+    this.hasStarted() || await this.mediaStateChange("active"), this.seekStart(), this.currentTime = e, this.#e.seek(e), this.seekEnd();
+  }
+  // Handles track "skip next" and progressions between shaka and native player
+  async skipToPreloadedMediaProduct() {
+    this.debugLog(
+      "skipToPreloadedMediaProduct",
+      this.preloadedStreamingSessionId
+    );
+    const e = this.currentStreamingSessionId === void 0;
+    if (this.preloadedStreamingSessionId && this.#a) {
+      const t = o.getMediaProductTransition(
+        this.preloadedStreamingSessionId
+      );
+      t && (this.#a.mediaProduct = t.mediaProduct), await this.load(this.#a, "implicit"), await this.updateOutputDevice(), e && (this.playbackState = "PLAYING"), this.playbackState === "IDLE" && (this.playbackState = "NOT_PLAYING");
+      return;
+    }
+    console.warn("No preloaded item in native player.");
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async unloadPreloadedMediaProduct() {
+    this.debugLog(
+      "unloadPreloadedMediaProduct",
+      this.preloadedStreamingSessionId
+    ), this.hasNextItem() && (this.cleanUpStoredPreloadInfo(), "cancelPreload" in this.#e ? this.#e.cancelPreload() : console.warn("cancelPreload not available. Update native player."));
+  }
+  updateDeviceMode() {
+    this.updateOutputDevice()?.catch(console.error), i && s.dispatchEvent(
+      P(i.deviceMode)
+    );
+  }
+  updateOutputDevice() {
+    if (!i || (this.debugLog("updateOutputDevice", i.activeDevice), !i.activeDevice))
+      return Promise.resolve();
+    const { nativeDeviceId: e } = i.activeDevice;
+    if (this.outputDeviceType = i.activeDevice.type, e === "default")
+      this.#s !== "default" && (this.#e.selectSystemDevice(), s.dispatchEvent(S("default")), this.#s = "default");
+    else if (e) {
+      const t = i.getNativeDevice(e);
+      t && (this.#e.selectDevice(t, i.deviceMode), s.dispatchEvent(
+        S(i.activeDevice.id)
+      ), s.dispatchEvent(
+        P(i.deviceMode)
+      ), this.#s = e);
+    } else
+      console.warn(`Device with sinkId ${e} not found.`);
+    return Promise.resolve();
+  }
+  /**
+   * WIMPWC-7901
+   * This is a temporary fix as there is currently no way to enable
+   * the MQA decoder in Native Player after disabling it.
+   *
+   * Switching devices forces the Native Player to use the new device settings.
+   * By default `device.passThrough` is `undefined`, that's why we check explicitly for `false`.
+   *
+   * TODO: Refactor when `this._player.enableMQADecoder();` works....
+   */
+  updatePassThrough() {
+    if (!i)
+      return;
+    const { activeDevice: e } = i;
+    if (i.passThrough === !0) {
+      this.#e.disableMQADecoder(), s.dispatchEvent(b(!0));
+      return;
+    }
+    if (i.passThrough === !1)
+      if (this.#e.selectSystemDevice(), e.nativeDeviceId) {
+        const t = i.getNativeDevice(
+          e.nativeDeviceId
+        );
+        t && this.#e.selectDevice(
+          t,
+          i.deviceMode
+        );
+      } else
+        console.error(
+          "Passthrough could not be properly disabled since the nativeDeviceId is missing for",
+          e
+        );
+    this.#e.enableMQADecoder(), s.dispatchEvent(b(!1));
+  }
+  // eslint-disable-next-line class-methods-use-this
+  get ready() {
+    return Promise.resolve();
+  }
+  // eslint-disable-next-line class-methods-use-this
+  get volume() {
+    return m("desiredVolumeLevel");
+  }
+  set volume(e) {
+    this.debugLog("Setting volume to", e), this.#e.setVolume(e * 100);
+  }
+}
+export {
+  A as default
+};

package/dist/output-devices-NXuo75MQ-_vYYuqUm.js

@@ -0,0 +1,236 @@
+import { h as V, y as S, l as b, g as T } from "./index-tM9JvbA8.js";
+import { l as W } from "./_commonjsHelpers-f3sTPFkQ-YKQV-mq1.js";
+var q = function() {
+  function s(e, t, n, i, a) {
+    return e < t || n < t ? e > n ? n + 1 : e + 1 : i === a ? t : t + 1;
+  }
+  return function(e, t) {
+    if (e === t)
+      return 0;
+    if (e.length > t.length) {
+      var n = e;
+      e = t, t = n;
+    }
+    for (var i = e.length, a = t.length; i > 0 && e.charCodeAt(i - 1) === t.charCodeAt(a - 1); )
+      i--, a--;
+    for (var c = 0; c < i && e.charCodeAt(c) === t.charCodeAt(c); )
+      c++;
+    if (i -= c, a -= c, i === 0 || a < 3)
+      return a;
+    var o = 0, r, d, h, l, f, v, m, p, D, C, E, A, u = [];
+    for (r = 0; r < i; r++)
+      u.push(r + 1), u.push(e.charCodeAt(c + r));
+    for (var P = u.length - 1; o < a - 3; )
+      for (D = t.charCodeAt(c + (d = o)), C = t.charCodeAt(c + (h = o + 1)), E = t.charCodeAt(c + (l = o + 2)), A = t.charCodeAt(c + (f = o + 3)), v = o += 4, r = 0; r < P; r += 2)
+        m = u[r], p = u[r + 1], d = s(m, d, h, D, p), h = s(d, h, l, C, p), l = s(h, l, f, E, p), v = s(l, f, v, A, p), u[r] = v, f = l, l = h, h = d, d = m;
+    for (; o < a; )
+      for (D = t.charCodeAt(c + (d = o)), v = ++o, r = 0; r < P; r += 2)
+        m = u[r], u[r] = v = s(m, d, v, D, u[r + 1]), d = m;
+    return v;
+  };
+}();
+const O = /* @__PURE__ */ W(q);
+function M(s) {
+  return new CustomEvent("device-change", {
+    detail: {
+      devices: s
+    }
+  });
+}
+const g = V.parse(navigator.userAgent);
+class w {
+  controllableVolume;
+  id;
+  name;
+  nativeDeviceId;
+  type;
+  webDeviceId;
+  constructor({
+    controllableVolume: e,
+    name: t,
+    nativeDeviceId: n,
+    type: i,
+    webDeviceId: a
+  }) {
+    this.name = t, this.id = n === "default" && a === "default" ? "default" : T(), this.nativeDeviceId = n, this.webDeviceId = a, this.type = i, this.controllableVolume = e !== !1;
+  }
+}
+function y(s) {
+  if (B(s))
+    return "windowsCommunication";
+  if ("id" in s && s.id === "BuiltInSpeakerDevice")
+    return "builtIn";
+  if ("type" in s) {
+    if (s.type === "airplay")
+      return "airplay";
+    if (s.type === "mqa")
+      return "mqa";
+  }
+  if ("label" in s) {
+    const e = s.label.toLowerCase();
+    if (e.includes("bluetooth"))
+      return "bluetooth";
+    if (e.includes("displayport"))
+      return "displayPort";
+    if (e.includes("hdmi"))
+      return "hdmi";
+    if (e.includes("usb"))
+      return "usb";
+    if (e.includes("built-in"))
+      return "builtIn";
+    if (e.includes("airplay"))
+      return "airplay";
+  }
+}
+function I(s, e) {
+  const t = e.toLowerCase();
+  let n = s;
+  return t.includes("mac") && (n = s.split("(")[0].trim()), n;
+}
+function B(s) {
+  let e;
+  return "label" in s && (e = s.label), "name" in s && (e = s.name), e !== void 0 && e.startsWith("Communications");
+}
+function L(s, e) {
+  if (e = I(e, g.os.name || ""), [...s].length === 0 || e === "")
+    return;
+  const t = [...s].filter((i) => i.name === e)[0];
+  if (t)
+    return t;
+  const n = [...s].filter((i) => e.includes(i.name) || i.name.includes(e)).map((i) => ({
+    device: i,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    distance: O(i.name, e)
+  })).sort((i, a) => i.distance - a.distance).reverse();
+  if (n.length > 0) {
+    const i = n.pop();
+    if (i && i.distance <= 16)
+      return i.device;
+  }
+}
+class N {
+  #i;
+  #s;
+  #n = "shared";
+  #e;
+  #t;
+  #a = void 0;
+  #r;
+  outputDevices;
+  constructor() {
+    this.#t = /* @__PURE__ */ new Set(), this.#r = /* @__PURE__ */ new Set(), this.#e = new EventTarget(), this.#s = new w({
+      name: "System Default",
+      nativeDeviceId: "default",
+      type: "systemDefault",
+      webDeviceId: "default"
+    }), this.#i = this.#s, this.outputDevices = /* @__PURE__ */ new Set([this.#s]), this.hydrateWebDevices().then().catch(console.error), navigator.mediaDevices.addEventListener("devicechange", () => {
+      this.hydrateWebDevices().then().catch(console.error);
+    }), this.#e.addEventListener("native-devices", (e) => {
+      this.#t = new Set(e.detail), this.queueUpdate().then().catch(console.error);
+    }), this.#e.addEventListener("web-devices", (e) => {
+      this.#r = new Set(e.detail), this.queueUpdate().then().catch(console.error);
+    });
+  }
+  addNativeDevices(e) {
+    this.#e.dispatchEvent(
+      new CustomEvent("native-devices", {
+        detail: e
+      })
+    );
+  }
+  addWebDevices(e) {
+    e = e.filter((t) => t.deviceId !== "default"), this.#e.dispatchEvent(
+      new CustomEvent("web-devices", {
+        detail: e
+      })
+    );
+  }
+  emitDeviceChange() {
+    S.dispatchEvent(M([...this.outputDevices]));
+  }
+  getNativeDevice(e) {
+    return [...this.#t].find((t) => t.id === e);
+  }
+  async hydrateWebDevices() {
+    const e = (await navigator.mediaDevices.enumerateDevices()).filter((t) => t.kind === "audiooutput");
+    this.addWebDevices(e);
+  }
+  mergeDevices() {
+    [...this.outputDevices].filter((e) => e.id !== "default").forEach((e) => {
+      e.nativeDeviceId = void 0, e.webDeviceId = void 0;
+    }), this.#t.forEach((e) => {
+      const t = L(this.outputDevices, e.name);
+      t ? (t.nativeDeviceId = e.id, t.controllableVolume = e.controllableVolume, t.type = y(e) || t.type) : this.outputDevices.add(
+        new w({
+          controllableVolume: e.controllableVolume,
+          name: I(e.name, g.os.name || ""),
+          nativeDeviceId: e.id,
+          type: y(e)
+        })
+      );
+    }), this.#r.forEach((e) => {
+      const t = L(this.outputDevices, e.label);
+      t ? (t.webDeviceId = e.deviceId, t.type = y(e) || t.type) : this.outputDevices.add(
+        new w({
+          name: I(e.label, g.os.name || ""),
+          type: y(e),
+          webDeviceId: e.deviceId
+        })
+      );
+    }), [...this.outputDevices].filter(
+      (e) => e.webDeviceId === void 0 && e.nativeDeviceId === void 0 || e.type === "airplay" || e.type === "windowsCommunication"
+    ).forEach((e) => this.outputDevices.delete(e));
+  }
+  async queueUpdate() {
+    const e = new Promise(
+      (i) => this.#e.addEventListener(
+        "native-devices",
+        (a) => i(a.detail),
+        { once: !0 }
+      )
+    ), t = new Promise(
+      (i) => this.#e.addEventListener(
+        "web-devices",
+        (a) => i(a.detail),
+        { once: !0 }
+      )
+    ), n = (i) => new Promise((a) => setTimeout(() => a(), i));
+    await Promise.any([e, t, n(1e3)]), this.mergeDevices(), this.emitDeviceChange();
+  }
+  set activeDevice(e) {
+    this.#i = e, this.#a = !1, this.#n = "shared", b.activePlayer?.updateOutputDevice()?.catch(console.error);
+  }
+  get activeDevice() {
+    return this.#i;
+  }
+  /**
+   * Set the current device mode for the output device.
+   */
+  set deviceMode(e) {
+    const { activeDevice: t } = this, { activePlayer: n } = b;
+    t && n && n.name === "nativePlayer" && this.deviceMode !== e && (this.#n = e, n.updateDeviceMode());
+  }
+  get deviceMode() {
+    return this.#n;
+  }
+  /**
+   * Set to true to disable software MQA decoder.
+   */
+  set passThrough(e) {
+    const { activeDevice: t } = this, { activePlayer: n } = b;
+    t && n && n.name === "nativePlayer" && this.passThrough !== e && (this.#a = e, n.updatePassThrough());
+  }
+  get passThrough() {
+    return !!this.#a;
+  }
+}
+const $ = new N();
+export {
+  w as OutputDevice,
+  N as OutputDevices,
+  y as findOutputType,
+  L as getOutputDeviceByName,
+  B as isWindowsCommunicationsDevice,
+  I as marshalLabel,
+  $ as outputDevices
+};