@tidal-music/player-web-components 0.2.1 → 0.3.0

package/dist/active-device-changed-BDbOSq7P-DQ6vFR_K.js

@@ -0,0 +1,7 @@
+//#region ../player/dist/active-device-changed-BDbOSq7P.js
+var e = "active-device-changed";
+function t(t) {
+	return new CustomEvent(e, { detail: t });
+}
+//#endregion
+export { t };

package/dist/active-device-mode-changed-OmLVES_4-zwN5exje.js

@@ -0,0 +1,7 @@
+//#region ../player/dist/active-device-mode-changed-OmLVES_4.js
+var e = "active-device-mode-changed";
+function t(t) {
+	return new CustomEvent(e, { detail: t });
+}
+//#endregion
+export { t };

package/dist/audio-context-store-Bf50rcqa-DUuCXOzU.js

@@ -0,0 +1,36 @@
+//#region ../player/dist/audio-context-store-Bf50rcqa.js
+var e = (e, t, n) => {
+	for (let r of e) {
+		let e = r.addedNodes[0];
+		r.type === "childList" && e.id === t && n();
+	}
+};
+function t() {
+	let t = document.getElementById("tidal-player-root");
+	if (!t) return Promise.reject("No player root");
+	if ("video-one" in t.children) return Promise.resolve();
+	let n = [];
+	return "video-one" in t.children || n.push(new Promise((n) => {
+		new MutationObserver((t) => e(t, "video-one", n)).observe(t, { childList: !0 });
+	})), Promise.all(n);
+}
+var n = document.createElement("video"), r = document.createElement("video"), i = (e) => {
+	e.setAttribute("crossorigin", "anonymous"), e.setAttribute("playsinline", "playsinline");
+};
+i(n), n.id = "video-one", i(r), r.id = "video-two";
+var a = "tidal-player-root";
+function o() {
+	let e = document.getElementById(a);
+	return e && !(e instanceof HTMLDivElement) && (e.remove(), e = null), e || (e = document.createElement("div"), e.id = a, e.style.position = "absolute", e.style.width = "0", e.style.height = "0", e.style.overflow = "hidden", document.body.appendChild(e)), s();
+}
+function s() {
+	let e = document.getElementById(a);
+	return e && (e.contains(n) || e.appendChild(n), e.contains(r) || e.appendChild(r)), t();
+}
+function c() {
+	return new Promise((e) => document.addEventListener("click", () => {
+		n.readyState === HTMLMediaElement.HAVE_NOTHING && !n.src && n.load(), r.readyState === HTMLMediaElement.HAVE_NOTHING && !r.src && r.load(), e();
+	}, { once: !0 }));
+}
+//#endregion
+export { s as a, r as i, n, o as r, c as t };

package/dist/basePlayer-D9LFxFnB-BNIKxMHD.js

@@ -0,0 +1,380 @@
+import { a as e, i as t, l as n, o as r, t as i, u as a } from "./state-BT7sE_jc-iVaBwnBC.js";
+import { t as o } from "./pushkin-C7W2HCqN-BHqS8oLX.js";
+import { a as s, c, d as l, f as u, i as d, l as f, o as p, s as m, t as h, u as g } from "./load-L6Urw8gV-CQAMBwcN.js";
+//#region ../player/dist/basePlayer-D9LFxFnB.js
+function _(e, t) {
+	return new CustomEvent("media-product-transition", { detail: {
+		mediaProduct: e,
+		playbackContext: t
+	} });
+}
+var v = ({ assetPosition: e, duration: t, playbackInfo: n, streamInfo: r }) => ({
+	actualAssetPresentation: n.assetPresentation,
+	actualAudioMode: "audioMode" in n ? n.audioMode : null,
+	actualAudioQuality: "audioQuality" in n ? n.audioQuality : null,
+	actualDuration: t,
+	actualProductId: String("videoId" in n ? n.videoId : n.trackId),
+	actualStreamType: "streamType" in n ? n.streamType : null,
+	actualVideoQuality: "videoQuality" in n ? n.videoQuality : null,
+	assetPosition: e,
+	bandwidth: null,
+	bitDepth: r.bitDepth ?? null,
+	codec: r.codec ?? null,
+	playbackSessionId: r.streamingSessionId,
+	previewReason: n.previewReason ?? void 0,
+	sampleRate: r.sampleRate ?? null
+});
+function y(e, t) {
+	return new CustomEvent("ended", { detail: {
+		mediaProduct: t,
+		reason: e
+	} });
+}
+function b(e) {
+	return new CustomEvent("playback-state-change", { detail: { state: e } });
+}
+function x() {
+	return new CustomEvent("preload-request");
+}
+function S(e) {
+	return Math.min(10 ** ((4 + e) / 20), 1 / 1);
+}
+var C = 500;
+function w(e) {
+	if (typeof e == "string") return T(e);
+	if (!e || typeof e != "object") return e;
+	if (e instanceof Error) return {
+		message: e.message,
+		name: e.name,
+		stack: e.stack
+	};
+	if (e instanceof Event || e instanceof Element) return e;
+	if (Array.isArray(e)) return e.map(w);
+	let t = {};
+	for (let [n, r] of Object.entries(e)) {
+		if (E(n)) {
+			t[n] = typeof r == "string" ? `[redacted ${n}, ${r.length} chars]` : `[redacted ${n}]`;
+			continue;
+		}
+		t[n] = w(r);
+	}
+	return t;
+}
+function T(e) {
+	if (e.startsWith("data:")) return `[redacted data URL, ${e.length} chars]`;
+	if (e.startsWith("http://") || e.startsWith("https://")) {
+		let t = e.indexOf("?");
+		if (t !== -1) return `${e.slice(0, t)}?[redacted query, ${e.length - t - 1} chars]`;
+	}
+	return e.length > C ? `${e.slice(0, C)}...[truncated ${e.length} chars]` : e;
+}
+function E(e) {
+	return e === "manifest" || e === "streamUrl" ? !0 : /token/i.test(e);
+}
+function D(e) {
+	switch (e) {
+		case "completed": return "COMPLETE";
+		case "error": return "ERROR";
+		default: return "OTHER";
+	}
+}
+var O = class {
+	#e;
+	#t;
+	#n;
+	#r = void 0;
+	#i;
+	#a = "IDLE";
+	#o;
+	#s;
+	name;
+	constructor() {
+		n.addEventListener("desiredVolumeLevel", () => {
+			this.isActivePlayer && this.updateVolumeLevel();
+		});
+	}
+	#c() {
+		let t = a("crossfadeInMs") / 1e3;
+		this.duration && Math.abs(this.#t - this.duration + t) <= 15 && this.#r === !1 && (this.debugLog("maybeDispatchPreloadRequest", {
+			crossfadeInS: t,
+			currentTime: this.#t,
+			duration: this.duration
+		}, Math.abs(this.#t - this.duration + t)), this.#r = !0, e.dispatchEvent(x()));
+	}
+	#l({ endAssetPosition: n, endReason: r, isSeamlessTransition: a = !1, streamingSessionId: s }) {
+		this.debugLog("mediaProductEnded"), !a && i.preloadedStreamingSessionId && performance.mark("streaming_metrics:playback_statistics:idealStartTimestamp", {
+			detail: i.preloadedStreamingSessionId,
+			startTime: o.now()
+		});
+		let c = t.getMediaProductTransition(s);
+		!a && c && e.dispatchEvent(y(r, c.mediaProduct)), this.eventTrackingStreamingEnded(s, {
+			endAssetPosition: n,
+			endReason: r
+		}), t.deleteSession(s), this.currentStreamingSessionId === s && (this.currentStreamingSessionId = void 0), a || this.updateVolumeLevelForNextProduct();
+	}
+	adjustedVolume(e) {
+		let t = a("desiredVolumeLevel"), n = a("loudnessNormalizationMode"), r = t;
+		return n === "ALBUM" && e.albumReplayGain && (r *= S(e.albumReplayGain)), n === "TRACK" && e.trackReplayGain && (r *= S(e.trackReplayGain)), this.debugLog("adjustedVolume", `Volume adjusted from ${t} to ${r}`), parseFloat(r.toFixed(2));
+	}
+	attachPlaybackEngineEndedHandler() {
+		this.#n || (this.#n = this.playbackEngineEndedHandler.bind(this), e.addEventListener("ended", this.#n));
+	}
+	cleanUpStoredPreloadInfo() {
+		this.preloadedStreamingSessionId && this.preloadedStreamingSessionId !== this.currentStreamingSessionId && (t.deleteSession(this.preloadedStreamingSessionId), this.preloadedStreamingSessionId = void 0);
+	}
+	get currentMediaProduct() {
+		return t.getMediaProductTransition(this.currentStreamingSessionId)?.mediaProduct ?? null;
+	}
+	set currentStreamingSessionId(e) {
+		this.#e = e;
+	}
+	get currentStreamingSessionId() {
+		return this.#e;
+	}
+	set currentTime(e) {
+		this.#t = e, this.#c();
+	}
+	get currentTime() {
+		return this.#t;
+	}
+	debugLog(...e) {
+		(document.location.hostname === "localhost" || document.location.hostname === "dev.tidal.com") && document.location.hash.includes("debug") && console.debug(`[%cPlayerSDK${this.name ? `%c${i.activePlayer?.name === this.name ? "⚯" : "⚮"}%c` + this.name : ""}${this.#e ? "%c::%c" + this.#e?.split("-").pop() : ""}%c]`, "color:#00d6ff", ...this.name ? ["color:inherit", "color:#b7fa34"] : [], ...this.#e ? ["color:inherit", "color:#d947ff"] : [], "color:inherit", ...e.map(w));
+	}
+	detachPlaybackEngineEndedHandler() {
+		this.#n &&= (e.removeEventListener("ended", this.#n), void 0);
+	}
+	get duration() {
+		let e = t.getMediaProductTransition(this.currentStreamingSessionId);
+		return e ? e.playbackContext.actualDuration : null;
+	}
+	eventTrackingStreamingEnded(e, { endAssetPosition: t, endReason: n }) {
+		let r = o.now();
+		u([d({
+			endAssetPosition: t,
+			endTimestamp: r,
+			streamingSessionId: e
+		})]).catch(console.error), l([s({
+			endReason: D(n),
+			endTimestamp: r,
+			streamingSessionId: e
+		}), g({
+			streamingSessionId: e,
+			timestamp: r
+		})]).catch(console.error);
+	}
+	eventTrackingStreamingStarted(e) {
+		if (!e) return;
+		performance.mark("streaming_metrics:playback_statistics:actualStartTimestamp", {
+			detail: e,
+			startTime: o.now()
+		}), performance.measure("idealStartTimestamp -> actualStartTimestamp", {
+			detail: e,
+			end: "streaming_metrics:playback_statistics:actualStartTimestamp",
+			start: "streaming_metrics:playback_statistics:idealStartTimestamp"
+		});
+		try {
+			s({
+				actualStartTimestamp: o.timestamp("streaming_metrics:playback_statistics:actualStartTimestamp", e),
+				idealStartTimestamp: o.timestamp("streaming_metrics:playback_statistics:idealStartTimestamp", e),
+				outputDevice: this.#i,
+				streamingSessionId: e
+			});
+		} catch (e) {
+			console.error(e, "actualStartTimestamp or idealStartTimestamp is missing for this streaming session");
+		} finally {
+			performance.clearMarks("streaming_metrics:playback_statistics:actualStartTimestamp"), performance.clearMarks("streaming_metrics:playback_statistics:idealStartTimestamp");
+		}
+		let n = t.getMediaProductTransition(e);
+		if (!n) {
+			t.hasStartedStreamInfo(e) ? console.error(`A media product transition for streaming session #${e} has not been saved and could thus not be found for play log reporting.`) : (t.deleteStreamInfo(e), console.warn(`Streaming session #${e} has been discarded due to a new load. This could mean you have a bug in your code where you call load on Player more than once time in a very short time frame.`));
+			return;
+		}
+		let { mediaProduct: r, playbackContext: i } = n, a = o.now();
+		d({
+			actualAssetPresentation: i.actualAssetPresentation,
+			actualAudioMode: "actualAudioMode" in i ? i.actualAudioMode : null,
+			actualProductId: i.actualProductId,
+			actualQuality: i.actualAudioQuality || i.actualVideoQuality,
+			extras: r.extras,
+			isPostPaywall: p(i.actualAssetPresentation, r),
+			playbackSessionId: e,
+			productType: f(r.productType),
+			requestedProductId: r.productId,
+			sourceId: r.sourceId,
+			sourceType: r.sourceType,
+			startAssetPosition: this.startAssetPosition,
+			startTimestamp: a,
+			streamingSessionId: e
+		}).catch(console.error);
+	}
+	get expired() {
+		let e = t.getStreamInfo(this.currentStreamingSessionId);
+		return e ? e.expires <= Date.now() : !1;
+	}
+	finishCurrentMediaProduct(e, n = !1) {
+		if (!this.hasStarted()) return;
+		let r = this.#e, i = r ? t.hasStreamInfo(r) : !1;
+		!n && !this.preloadedStreamingSessionId && (this.playbackState = "IDLE"), r && i && this.#l({
+			endAssetPosition: this.currentTime,
+			endReason: e,
+			isSeamlessTransition: n,
+			streamingSessionId: r
+		});
+	}
+	getPosition() {
+		return 0;
+	}
+	async hardReload(e, t) {
+		return this.currentStreamingSessionId && this.finishCurrentMediaProduct("skip"), m(e, t);
+	}
+	hasNextItem() {
+		return this.preloadedStreamingSessionId;
+	}
+	hasStarted() {
+		return this.currentStreamingSessionId && t.hasStartedStreamInfo(this.currentStreamingSessionId);
+	}
+	get isActivePlayer() {
+		return i.activePlayer && this.name === i.activePlayer.name;
+	}
+	load(e, t) {
+		return Promise.resolve();
+	}
+	async maybeHardReload() {
+		let e = this.prefetched || this.expired;
+		return this.currentMediaProduct && e ? (await this.hardReload(this.currentMediaProduct, this.currentTime), !0) : !1;
+	}
+	mediaProductStarted(e) {
+		!e || t.hasStartedStreamInfo(e) || (this.debugLog("mediaProductStarted"), this.eventTrackingStreamingStarted(e), t.setStartedStreamInfo(e), this.updateVolumeLevel(), this.#r = !1, this.preloadedStreamingSessionId = void 0, this.unloadPreloadedMediaProduct().catch(console.error), this.attachPlaybackEngineEndedHandler());
+	}
+	next(e) {
+		return Promise.resolve();
+	}
+	get nextItem() {
+		if (this.preloadedStreamingSessionId) return t.getMediaProductTransition(this.preloadedStreamingSessionId);
+	}
+	set outputDeviceType(e) {
+		this.#i = e ? c(e) : void 0;
+	}
+	overwriteMediaProduct(e, n) {
+		let r = t.getMediaProductTransition(e);
+		if (r) {
+			t.deleteMediaProductTransition(e);
+			let i = {
+				mediaProduct: {
+					...r.mediaProduct,
+					...n
+				},
+				playbackContext: { ...r.playbackContext }
+			};
+			t.saveMediaProductTransition(e, i);
+		}
+	}
+	pause() {}
+	play() {
+		return Promise.resolve();
+	}
+	playbackEngineEndedHandler(e) {
+		return Promise.resolve();
+	}
+	set playbackState(t) {
+		let n = this.#a;
+		if (n === t || !this.currentStreamingSessionId) return;
+		let r = (e, r) => n === e && r === t;
+		switch (!0) {
+			case r("NOT_PLAYING", "STALLED"):
+			case r("IDLE", "STALLED"): return;
+			case r("PLAYING", "NOT_PLAYING"):
+			case r("PLAYING", "IDLE"):
+				this.duration && this.currentTime < this.duration && h(this.currentStreamingSessionId, {
+					actionType: "PLAYBACK_STOP",
+					assetPosition: this.currentTime,
+					timestamp: o.now()
+				}).catch(console.error);
+				break;
+			case r("IDLE", "PLAYING"):
+			case r("NOT_PLAYING", "PLAYING"):
+				this.currentTime !== this.startAssetPosition && h(this.currentStreamingSessionId, {
+					actionType: "PLAYBACK_START",
+					assetPosition: this.currentTime,
+					timestamp: o.now()
+				}).catch(console.error);
+				break;
+			default: break;
+		}
+		this.#a = t, this.debugLog(`playbackState: ${t}`);
+		let a = i.activePlayer === void 0;
+		(this.isActivePlayer || a) && e.dispatchEvent(b(this.#a));
+	}
+	get playbackState() {
+		return this.#a;
+	}
+	get prefetched() {
+		return t.getStreamInfo(this.currentStreamingSessionId)?.prefetched;
+	}
+	set preloadedStreamingSessionId(e) {
+		this.#o = e;
+	}
+	get preloadedStreamingSessionId() {
+		return this.#o;
+	}
+	reset(e) {
+		return Promise.resolve();
+	}
+	seek(e) {}
+	seekEnd(t) {
+		let n = this.currentStreamingSessionId;
+		if (n) {
+			let r = () => h(n, {
+				actionType: "PLAYBACK_START",
+				assetPosition: t,
+				timestamp: o.now()
+			});
+			if (this.playbackState === "PLAYING") r().catch(console.error);
+			else {
+				let t = () => {
+					this.playbackState === "PLAYING" && (r().catch(console.error), e.removeEventListener("playback-state-change", t));
+				};
+				e.addEventListener("playback-state-change", t);
+			}
+		}
+	}
+	seekStart(e) {
+		this.currentStreamingSessionId && h(this.currentStreamingSessionId, {
+			actionType: "PLAYBACK_STOP",
+			assetPosition: e,
+			timestamp: o.now()
+		}).catch(console.error);
+	}
+	async setStateToXIfNotYInZMs(e, t, n) {
+		await r(e), this.playbackState !== t && (this.playbackState = n);
+	}
+	skipToPreloadedMediaProduct() {
+		return Promise.resolve();
+	}
+	get startAssetPosition() {
+		return this.#s;
+	}
+	set startAssetPosition(e) {
+		this.#s = e;
+	}
+	unloadPreloadedMediaProduct() {
+		return Promise.resolve();
+	}
+	updateOutputDevice() {
+		return Promise.resolve();
+	}
+	updateVolumeLevel() {
+		let e = t.getStreamInfo(this.currentStreamingSessionId);
+		e && (this.volume = this.adjustedVolume(e));
+	}
+	updateVolumeLevelForNextProduct() {
+		let e = t.getStreamInfo(this.preloadedStreamingSessionId);
+		e && (this.volume = this.adjustedVolume(e));
+	}
+	get volume() {
+		return 1;
+	}
+	set volume(e) {}
+};
+//#endregion
+export { _ as n, v as r, O as t };

package/dist/browserPlayer-BzBNrx-C-DjxeaFTq.js

@@ -0,0 +1,170 @@
+import { a as e, i as t, o as n, u as r } from "./state-BT7sE_jc-iVaBwnBC.js";
+import { a as i, n as a } from "./audio-context-store-Bf50rcqa-DUuCXOzU.js";
+import { n as o, r as s, t as c } from "./basePlayer-D9LFxFnB-BNIKxMHD.js";
+import { t as l } from "./media-element-error-circuit-breaker-BUJbK6sd-DNlFckiw.js";
+//#region ../player/dist/browserPlayer-BzBNrx-C.js
+var u = class extends c {
+	#e;
+	#t;
+	#n = !0;
+	#r;
+	#i = l();
+	#a;
+	#o = document.createElement("video");
+	#s = !1;
+	name = "browserPlayer";
+	constructor() {
+		super(), this.playbackState = "IDLE";
+		let e = () => {
+			this.mediaElement && !this.mediaElement.paused && (this.playbackState = "PLAYING");
+		}, r = (e) => {
+			this.currentStreamingSessionId && e.target instanceof HTMLMediaElement && t.overwriteDuration(this.currentStreamingSessionId, e.target.duration);
+		}, o = () => {
+			this.playbackState = "STALLED";
+		}, s = () => {
+			(async () => {
+				let e = this.#e;
+				if (e) {
+					if (this.preloadedStreamingSessionId && e.currentTime === e.duration && (await n(1e3), e.currentTime !== e.duration)) return;
+					this.playbackState = "NOT_PLAYING";
+				}
+			})().catch(console.error);
+		}, c = (e) => {
+			if (e instanceof Event) {
+				let t = e.target;
+				t.readyState > HTMLMediaElement.HAVE_NOTHING && (this.currentTime = t.currentTime);
+			}
+		}, l = (e) => {
+			c(e), this.finishCurrentMediaProduct("completed");
+		}, u = (e) => this.#i.handleError(e), d = () => {
+			this.mediaElement && (this.currentTime = this.mediaElement.currentTime, this.seekEnd(this.currentTime));
+		};
+		this.#a = {
+			durationChangeHandler: r,
+			endedHandler: l,
+			errorHandler: u,
+			pauseHandler: s,
+			playHandler: e,
+			playingHandler: e,
+			seekedHandler: d,
+			stalledHandler: o,
+			timeUpdateHandler: c,
+			waitingHandler: o
+		}, i().then().catch(console.error), this.#t = a, this.currentPlayer = this.#t;
+	}
+	#c(e, t) {
+		this.debugLog("mediaElementEvents", t ? "adding to" : "removing from", e);
+		let n = t ? "addEventListener" : "removeEventListener";
+		e[n]("durationchange", this.#a.durationChangeHandler, { passive: !0 }), e[n]("play", this.#a.playHandler, { passive: !0 }), e[n]("playing", this.#a.playingHandler, { passive: !0 }), e[n]("timeupdate", this.#a.timeUpdateHandler, { passive: !0 }), e[n]("pause", this.#a.pauseHandler, { passive: !0 }), e[n]("ended", this.#a.endedHandler, { passive: !0 }), e[n]("error", this.#a.errorHandler, { passive: !0 }), e[n]("waiting", this.#a.waitingHandler, { passive: !0 }), e[n]("stalled", this.#a.stalledHandler, { passive: !0 }), e[n]("seeked", this.#a.seekedHandler, { passive: !0 });
+	}
+	get currentPlayer() {
+		return this.#e;
+	}
+	set currentPlayer(e) {
+		this.debugLog("set currentPlayer", e), this.#e && (this.#c(this.#e, !1), this.#e.load()), e && (this.#e = e, this.#c(e, !0));
+	}
+	getPosition() {
+		return this.debugLog("getPosition"), this.mediaElement && (this.mediaElement.ended ? this.currentTime = 0 : this.currentTime = this.mediaElement.currentTime), this.currentTime;
+	}
+	async load(n, r) {
+		this.debugLog("load", n), this.currentTime = n.assetPosition, this.startAssetPosition = n.assetPosition, await i(), await this.reset(), this.#n = !1, r === "explicit" && (this.playbackState = "NOT_PLAYING");
+		let { assetPosition: a, mediaProduct: c, playbackInfo: l, streamInfo: u } = n;
+		this.currentStreamingSessionId = u.streamingSessionId;
+		let { currentPlayer: d } = this;
+		if (!d) return;
+		let f = new Promise((e) => d.addEventListener("canplay", () => e(), { once: !0 }));
+		d.src = u.streamUrl, d.currentTime = a, d.load();
+		let p = new Promise((e) => d.addEventListener("durationchange", (t) => {
+			t.target instanceof HTMLMediaElement && e(t.target.duration);
+		}, { once: !0 }));
+		if (await f, this.currentStreamingSessionId !== u.streamingSessionId) return;
+		let m = s({
+			assetPosition: a,
+			duration: await p,
+			playbackInfo: l,
+			streamInfo: u
+		});
+		return t.saveMediaProductTransition(u.streamingSessionId, {
+			mediaProduct: c,
+			playbackContext: m
+		}), this.debugLog("dispatching mediaProductTransition"), e.dispatchEvent(o(c, m)), this.#s ? (this.#s = !1, this.play()) : Promise.resolve();
+	}
+	get mediaElement() {
+		return this.currentPlayer ?? null;
+	}
+	async next(e) {
+		this.debugLog("next", e), this.playbackState === "IDLE" && (this.playbackState = "NOT_PLAYING");
+		let { mediaProduct: n, playbackInfo: r, streamInfo: i } = e, a = this.#o;
+		if (this.preloadedStreamingSessionId = i.streamingSessionId, !a) return;
+		a.src = i.streamUrl, a.load();
+		let o = s({
+			assetPosition: 0,
+			duration: await new Promise((e) => a.addEventListener("durationchange", (t) => {
+				t.target instanceof HTMLMediaElement && e(t.target.duration);
+			}, { once: !0 })),
+			playbackInfo: r,
+			streamInfo: i
+		});
+		t.saveMediaProductTransition(i.streamingSessionId, {
+			mediaProduct: n,
+			playbackContext: o
+		}), this.#n = !1;
+	}
+	pause() {
+		this.debugLog("pause"), this.mediaElement && this.mediaElement.pause();
+	}
+	async play() {
+		if (this.debugLog("play"), await this.maybeHardReload(), this.playbackState === "IDLE") return this.debugLog("is IDLE, returning early"), this.#s = !0, Promise.resolve();
+		"setSinkId" in a && await this.updateOutputDevice(), this.currentStreamingSessionId && this.mediaProductStarted(this.currentStreamingSessionId), this.setStateToXIfNotYInZMs(1e3, "PLAYING", "STALLED"), this.currentPlayer && await this.currentPlayer.play().catch(console.error);
+	}
+	async playbackEngineEndedHandler(e) {
+		if (this.isActivePlayer) {
+			let { reason: t } = e.detail;
+			t === "completed" && (this.hasNextItem() ? (await this.skipToPreloadedMediaProduct(), await this.play()) : (console.warn("No item preloaded, not progressing."), this.playbackState = "NOT_PLAYING"));
+		}
+	}
+	get ready() {
+		return this.#r;
+	}
+	async reset({ keepPreload: e } = { keepPreload: !1 }) {
+		if (this.#i.reset(), this.#n) return Promise.resolve();
+		this.debugLog("reset"), this.playbackState !== "IDLE" && this.finishCurrentMediaProduct("skip"), this.playbackState = "IDLE", this.detachPlaybackEngineEndedHandler(), this.currentStreamingSessionId = void 0, e || (this.preloadedStreamingSessionId = void 0);
+		let { currentPlayer: t } = this;
+		return t && t.readyState !== 0 && (t.load(), await new Promise((e) => t.addEventListener("emptied", () => e(), { passive: !0 }))), this.#n = !0, Promise.resolve();
+	}
+	seek(e) {
+		this.debugLog("seek", e);
+		let { currentPlayer: t } = this, n = e;
+		if (t) return this.seekStart(this.currentTime), "fastSeek" in t ? t.fastSeek(n) : t.currentTime = n, new Promise((e) => {
+			t.addEventListener("seeked", () => e(t.currentTime), { once: !0 });
+		});
+	}
+	async skipToPreloadedMediaProduct() {
+		let n = t.getMediaProductTransition(this.preloadedStreamingSessionId);
+		if (!n) {
+			this.playbackState = "NOT_PLAYING";
+			return;
+		}
+		if (this.debugLog("skipToPreloadedMediaProduct", this.preloadedStreamingSessionId), this.#o.src && this.currentPlayer) {
+			this.currentPlayer.src = this.#o.src, this.currentStreamingSessionId = String(this.preloadedStreamingSessionId), this.preloadedStreamingSessionId = void 0;
+			let { mediaProduct: t, playbackContext: r } = n;
+			e.dispatchEvent(o(t, r)), this.playbackState === "IDLE" && (this.playbackState = "NOT_PLAYING");
+		}
+	}
+	togglePlayback() {
+		this.debugLog("togglePlayback"), this.mediaElement && (this.mediaElement.paused ? this.mediaElement.play().catch(console.error) : this.mediaElement.pause());
+	}
+	async unloadPreloadedMediaProduct() {
+		this.debugLog("unloadPreloadedMediaProduct", this.preloadedStreamingSessionId), this.cleanUpStoredPreloadInfo();
+		let e = this.#o;
+		e && (e.src = "", e.load());
+	}
+	get volume() {
+		return r("desiredVolumeLevel");
+	}
+	set volume(e) {
+		this.debugLog("Setting volume to", e), this.currentPlayer && (this.currentPlayer.volume = e);
+	}
+};
+//#endregion
+export { u as default };