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

package/dist/shakaPlayer-CqIY64ST-BhwOXSvi.js

@@ -0,0 +1,1448 @@
+import { a as e, d as t, i as n, n as r, o as i, t as a, u as o } from "./state-BT7sE_jc-iVaBwnBC.js";
+import { t as s } from "./pushkin-C7W2HCqN-BHqS8oLX.js";
+import { a as c, i as l, n as u } from "./audio-context-store-Bf50rcqa-DUuCXOzU.js";
+import { t as d } from "./generate-guid-BMGZjV-R-D16yCCHx.js";
+import { a as f, d as p, n as m, p as h, r as g } from "./load-L6Urw8gV-CQAMBwcN.js";
+import { t as _ } from "./active-device-changed-BDbOSq7P-DQ6vFR_K.js";
+import { n as v, r as y, t as b } from "./basePlayer-D9LFxFnB-BNIKxMHD.js";
+import { t as x } from "./media-element-error-circuit-breaker-BUJbK6sd-DNlFckiw.js";
+//#region ../player/dist/shakaPlayer-CqIY64ST.js
+var S = /* @__PURE__ */ d(m(), 1);
+function C(e) {
+	return new CustomEvent("playback-quality-changed", { detail: { playbackContext: e } });
+}
+function w(e) {
+	let t = e.audioCodec;
+	if (t === "flac") {
+		let t = e.originalAudioId == null ? void 0 : T(e.originalAudioId);
+		return e.audioSamplingRate && e.audioSamplingRate > 44100 || t != null && t > 16 ? "HI_RES_LOSSLESS" : "LOSSLESS";
+	}
+	return t === "mp4a.40.2" ? "HIGH" : "LOW";
+}
+function T(e) {
+	if (!e?.includes(",")) return;
+	let t = e.match(/\d+/g)?.at(-1);
+	return t == null ? void 0 : Number(t);
+}
+function E(t, r) {
+	if (t && r?.audioCodec) {
+		let i = n.getMediaProductTransition(t);
+		if (!i) {
+			console.warn("No media product transition saved.");
+			return;
+		}
+		let { mediaProduct: a, playbackContext: o } = i, s = {
+			...o,
+			actualAudioQuality: w(r),
+			bandwidth: r.bandwidth ?? null,
+			bitDepth: r.originalAudioId ? T(r.originalAudioId) ?? null : null,
+			codec: r.audioCodec ? h(r.audioCodec) ?? null : null,
+			sampleRate: r.audioSamplingRate ?? null
+		};
+		n.saveMediaProductTransition(t, {
+			mediaProduct: a,
+			playbackContext: s
+		}), e.dispatchEvent(C(s));
+	}
+}
+function D(e, t) {
+	let n = s.now(), r = e.mimeType, i = e.codecs, a = e.bandwidth, o = e.width;
+	return {
+		assetPosition: t,
+		bandwidth: a,
+		codecs: i,
+		mimeType: r,
+		timestamp: n,
+		videoHeight: e.height,
+		videoWidth: o
+	};
+}
+async function O(e, t, n) {
+	let r = D(t, n);
+	return r.mimeType && r.codecs && await f({
+		adaptations: [r],
+		streamingSessionId: e
+	}), r;
+}
+function k(e, t, n) {
+	let r = () => {
+		if (!n()) return;
+		let r = e.getVariantTracks().find((e) => e.active), i = e.getMediaElement(), a = t();
+		a && i && O(a, r, i.currentTime).catch(console.error);
+	}, i = (e) => {
+		if (!n()) return;
+		r();
+		let i = e.newTrack, a = t();
+		a && E(a, i);
+	};
+	return e.addEventListener("adaptation", i), e.addEventListener("variantchanged", r), function() {
+		e.removeEventListener("adaptation", i), e.removeEventListener("variantchanged", r);
+	};
+}
+async function A() {
+	try {
+		let e = await (await fetch("https://fp.fa.tidal.com/certificate")).arrayBuffer();
+		return new Uint8Array(e);
+	} catch (e) {
+		throw console.error("Failed to retrieve the server certificate.", e);
+	}
+}
+var j = {
+	isPlaying: !1,
+	isSeeking: !1
+}, M = (e) => new Promise((t) => e.addEventListener("waiting", () => t(), { once: !0 })), N = (e) => new Promise((t) => e.addEventListener("playing", () => t(), { once: !0 }));
+function P() {
+	j.isSeeking = !0;
+}
+function F() {
+	j.isSeeking = !1;
+}
+function I() {
+	j.isPlaying = !1;
+}
+async function L(e, t) {
+	j.isPlaying = !0, await M(e);
+	let n = e.currentTime;
+	if (!j.isPlaying || n === 0) return;
+	let r = s.now(), i = j.isSeeking ? "SEEK" : "UNEXPECTED";
+	await N(e), f({
+		stalls: [{
+			assetPosition: n,
+			endTimestamp: s.now(),
+			reason: i,
+			startTimestamp: r
+		}],
+		streamingSessionId: t
+	});
+}
+function R(t) {
+	let n;
+	e.addEventListener("media-product-transition", (e) => {
+		e instanceof CustomEvent && (n = e.detail.playbackContext.playbackSessionId);
+	});
+	let r = () => I(), i = () => {
+		n && L(t, n).catch(console.error);
+	}, a = () => P(), o = () => F();
+	return t.addEventListener("seeking", a), t.addEventListener("seeked", o), t.addEventListener("playing", i), t.addEventListener("paused", r), function() {
+		t.removeEventListener("seeking", a), t.removeEventListener("seeked", o), t.removeEventListener("playing", i), t.removeEventListener("paused", r);
+	};
+}
+var z;
+function B(e) {
+	switch (e.split("/").pop()?.split("?")[0]) {
+		case "fairplay": return "FAIR_PLAY";
+		case "widevine": return "WIDEVINE";
+		default: return "NONE";
+	}
+}
+var V = new Uint8Array([
+	10,
+	193,
+	2,
+	8,
+	3,
+	18,
+	16,
+	23,
+	5,
+	185,
+	23,
+	204,
+	18,
+	4,
+	134,
+	139,
+	6,
+	51,
+	58,
+	47,
+	119,
+	42,
+	140,
+	24,
+	130,
+	180,
+	130,
+	146,
+	5,
+	34,
+	142,
+	2,
+	48,
+	130,
+	1,
+	10,
+	2,
+	130,
+	1,
+	1,
+	0,
+	153,
+	237,
+	91,
+	59,
+	50,
+	125,
+	171,
+	94,
+	36,
+	239,
+	195,
+	182,
+	42,
+	149,
+	181,
+	152,
+	82,
+	10,
+	213,
+	188,
+	203,
+	55,
+	80,
+	62,
+	6,
+	69,
+	184,
+	20,
+	216,
+	118,
+	184,
+	223,
+	64,
+	81,
+	4,
+	65,
+	173,
+	140,
+	227,
+	173,
+	177,
+	27,
+	184,
+	140,
+	78,
+	114,
+	90,
+	94,
+	74,
+	158,
+	7,
+	149,
+	41,
+	29,
+	88,
+	88,
+	64,
+	35,
+	167,
+	225,
+	175,
+	14,
+	56,
+	169,
+	18,
+	121,
+	57,
+	48,
+	8,
+	97,
+	11,
+	111,
+	21,
+	140,
+	135,
+	140,
+	126,
+	33,
+	191,
+	251,
+	254,
+	234,
+	119,
+	225,
+	1,
+	158,
+	30,
+	87,
+	129,
+	232,
+	164,
+	95,
+	70,
+	38,
+	61,
+	20,
+	230,
+	14,
+	128,
+	88,
+	168,
+	96,
+	122,
+	220,
+	224,
+	79,
+	172,
+	132,
+	87,
+	177,
+	55,
+	168,
+	214,
+	124,
+	205,
+	235,
+	51,
+	112,
+	93,
+	152,
+	58,
+	33,
+	251,
+	78,
+	236,
+	189,
+	74,
+	16,
+	202,
+	71,
+	73,
+	12,
+	164,
+	126,
+	170,
+	93,
+	67,
+	130,
+	24,
+	221,
+	186,
+	241,
+	202,
+	222,
+	51,
+	146,
+	241,
+	61,
+	111,
+	251,
+	100,
+	66,
+	253,
+	49,
+	225,
+	191,
+	64,
+	176,
+	198,
+	4,
+	209,
+	196,
+	186,
+	76,
+	149,
+	32,
+	164,
+	191,
+	151,
+	238,
+	189,
+	96,
+	146,
+	154,
+	252,
+	238,
+	245,
+	91,
+	186,
+	245,
+	100,
+	226,
+	208,
+	231,
+	108,
+	215,
+	197,
+	92,
+	115,
+	160,
+	130,
+	185,
+	150,
+	18,
+	11,
+	131,
+	89,
+	237,
+	206,
+	36,
+	112,
+	112,
+	130,
+	104,
+	13,
+	111,
+	103,
+	198,
+	216,
+	44,
+	74,
+	197,
+	243,
+	19,
+	68,
+	144,
+	167,
+	78,
+	236,
+	55,
+	175,
+	75,
+	47,
+	1,
+	12,
+	89,
+	232,
+	40,
+	67,
+	226,
+	88,
+	47,
+	11,
+	107,
+	159,
+	93,
+	176,
+	252,
+	94,
+	110,
+	223,
+	100,
+	251,
+	211,
+	8,
+	180,
+	113,
+	27,
+	207,
+	18,
+	80,
+	1,
+	156,
+	159,
+	90,
+	9,
+	2,
+	3,
+	1,
+	0,
+	1,
+	58,
+	20,
+	108,
+	105,
+	99,
+	101,
+	110,
+	115,
+	101,
+	46,
+	119,
+	105,
+	100,
+	101,
+	118,
+	105,
+	110,
+	101,
+	46,
+	99,
+	111,
+	109,
+	18,
+	128,
+	3,
+	174,
+	52,
+	115,
+	20,
+	181,
+	168,
+	53,
+	41,
+	127,
+	39,
+	19,
+	136,
+	251,
+	123,
+	184,
+	203,
+	82,
+	119,
+	210,
+	73,
+	130,
+	60,
+	221,
+	209,
+	218,
+	48,
+	185,
+	51,
+	57,
+	81,
+	30,
+	179,
+	204,
+	189,
+	234,
+	4,
+	185,
+	68,
+	185,
+	39,
+	193,
+	33,
+	52,
+	110,
+	253,
+	189,
+	234,
+	201,
+	212,
+	19,
+	145,
+	126,
+	110,
+	193,
+	118,
+	161,
+	4,
+	56,
+	70,
+	10,
+	80,
+	59,
+	193,
+	149,
+	43,
+	155,
+	164,
+	228,
+	206,
+	15,
+	196,
+	191,
+	194,
+	10,
+	152,
+	8,
+	170,
+	175,
+	75,
+	252,
+	209,
+	156,
+	29,
+	207,
+	205,
+	245,
+	116,
+	204,
+	172,
+	40,
+	209,
+	180,
+	16,
+	65,
+	108,
+	249,
+	222,
+	136,
+	4,
+	48,
+	28,
+	189,
+	179,
+	52,
+	202,
+	252,
+	208,
+	212,
+	9,
+	120,
+	66,
+	58,
+	100,
+	46,
+	84,
+	97,
+	61,
+	240,
+	175,
+	207,
+	150,
+	202,
+	74,
+	146,
+	73,
+	216,
+	85,
+	228,
+	43,
+	58,
+	112,
+	62,
+	241,
+	118,
+	127,
+	106,
+	155,
+	211,
+	109,
+	107,
+	248,
+	43,
+	231,
+	107,
+	191,
+	12,
+	186,
+	79,
+	222,
+	89,
+	210,
+	171,
+	204,
+	118,
+	254,
+	182,
+	66,
+	71,
+	184,
+	92,
+	67,
+	31,
+	188,
+	165,
+	34,
+	102,
+	182,
+	25,
+	252,
+	54,
+	151,
+	149,
+	67,
+	252,
+	169,
+	203,
+	189,
+	187,
+	250,
+	250,
+	14,
+	26,
+	85,
+	231,
+	85,
+	163,
+	199,
+	188,
+	230,
+	85,
+	249,
+	100,
+	111,
+	88,
+	42,
+	185,
+	207,
+	112,
+	170,
+	8,
+	185,
+	121,
+	248,
+	103,
+	246,
+	58,
+	11,
+	43,
+	127,
+	219,
+	54,
+	44,
+	91,
+	196,
+	236,
+	213,
+	85,
+	216,
+	91,
+	202,
+	169,
+	197,
+	147,
+	195,
+	131,
+	200,
+	87,
+	212,
+	157,
+	170,
+	183,
+	126,
+	64,
+	183,
+	133,
+	29,
+	223,
+	210,
+	73,
+	152,
+	128,
+	142,
+	53,
+	178,
+	88,
+	231,
+	93,
+	120,
+	234,
+	192,
+	202,
+	22,
+	247,
+	4,
+	115,
+	4,
+	194,
+	13,
+	147,
+	237,
+	228,
+	232,
+	255,
+	28,
+	111,
+	23,
+	230,
+	36,
+	62,
+	63,
+	61,
+	168,
+	252,
+	23,
+	9,
+	135,
+	14,
+	196,
+	95,
+	186,
+	130,
+	58,
+	38,
+	63,
+	12,
+	239,
+	161,
+	247,
+	9,
+	59,
+	25,
+	9,
+	146,
+	131,
+	38,
+	51,
+	55,
+	5,
+	4,
+	58,
+	41,
+	189,
+	166,
+	249,
+	180,
+	52,
+	44,
+	200,
+	223,
+	84,
+	60,
+	177,
+	161,
+	24,
+	47,
+	124,
+	95,
+	255,
+	51,
+	241,
+	4,
+	144,
+	250,
+	202,
+	91,
+	37,
+	54,
+	11,
+	118,
+	1,
+	94,
+	156,
+	90,
+	6,
+	171,
+	142,
+	224,
+	47,
+	0,
+	210,
+	232,
+	213,
+	152,
+	97,
+	4,
+	170,
+	204,
+	77,
+	212,
+	117,
+	253,
+	150,
+	238,
+	156,
+	228,
+	227,
+	38,
+	242,
+	27,
+	131,
+	199,
+	5,
+	133,
+	119,
+	179,
+	135,
+	50,
+	205,
+	218,
+	188,
+	106,
+	107,
+	237,
+	19,
+	251,
+	13,
+	73,
+	211,
+	138,
+	69,
+	235,
+	135,
+	165,
+	244
+]), H = class d extends b {
+	static #e = 250;
+	static #t = .25;
+	#n = 1;
+	#r = null;
+	#i = !1;
+	#a = null;
+	#o = null;
+	#s = void 0;
+	#c = !0;
+	#l;
+	#u = x();
+	#d;
+	#f;
+	#p;
+	#m = !1;
+	#h = null;
+	#g;
+	#_;
+	#v;
+	#y = !1;
+	name = "shakaPlayer";
+	constructor() {
+		super(), this.playbackState = "IDLE", this.#l = this.#M(), o("outputDevicesEnabled") && (async () => {
+			z = (await import("./output-devices-CPJfYcO--BP7JMB6k.js")).outputDevices;
+		})();
+		let e = (e) => {
+			if (!e) return !1;
+			let t = e.target;
+			return t instanceof HTMLMediaElement ? t !== this.#T() : t instanceof S.default.Player ? t !== this.#E() : !0;
+		}, t = (t) => {
+			e(t) || (this.mediaElement && !this.mediaElement.paused && (this.playbackState = "PLAYING"), t?.target === this.#T() && this.#m && this.#h && !this.#i && this.#o == null && this.#P());
+		}, r = (t) => {
+			if (e(t)) return;
+			let n = t.type === "buffering" && this.mediaElement?.networkState === HTMLMediaElement.NETWORK_LOADING;
+			(this.mediaElement?.paused || n) && (this.playbackState = "STALLED");
+		}, a = (t) => {
+			e(t) || (async () => {
+				this.mediaElement && this.preloadedStreamingSessionId && this.mediaElement.currentTime === this.mediaElement.duration && (await i(1e3), this.mediaElement && this.mediaElement.currentTime !== this.mediaElement.duration) || (this.playbackState = "NOT_PLAYING");
+			})().catch(console.error);
+		}, s = (e) => {
+			let t = e.target, n = t === this.#T();
+			if (n && t.readyState > HTMLMediaElement.HAVE_NOTHING && (this.currentTime = t.currentTime), n && this.#h && this.#m) {
+				let e = t.duration - t.currentTime, { startBeforeEndS: n } = this.#k();
+				!this.#i && !t.paused && e <= n && e > 0 && this.#R().catch(console.error);
+			}
+		}, c = (e) => {
+			this.currentStreamingSessionId && e.target instanceof HTMLMediaElement && e.target === this.#T() && n.overwriteDuration(this.currentStreamingSessionId, e.target.duration);
+		}, l = (e) => {
+			let t = e.target;
+			s(e);
+			let n = t === u, r = n ? this.#f : this.#p;
+			if (r) {
+				let e = this.currentStreamingSessionId === r;
+				if (e && this.#i) {
+					this.debugLog(`Active track ended mid-crossfade (session: ${r}) -- letting #completeTransition finalize`);
+					return;
+				}
+				if (t.readyState > HTMLMediaElement.HAVE_NOTHING && (this.currentTime = t.currentTime), this.debugLog(`Ended event from player ${n ? 1 : 2} (session: ${r})`), e) this.finishCurrentMediaProduct("completed");
+				else {
+					let e = this.playbackState, t = this.currentStreamingSessionId;
+					this.currentStreamingSessionId = r, this.finishCurrentMediaProduct("completed", !0), this.currentStreamingSessionId = t, this.playbackState = e;
+					let n = this.#T();
+					n && n.readyState > HTMLMediaElement.HAVE_NOTHING && (this.currentTime = n.currentTime);
+				}
+				n ? this.#f = void 0 : this.#p = void 0;
+			}
+		}, d = (e) => this.#u.handleError(e), f = (t) => {
+			e(t) || (this.currentTime = this.mediaElement ? this.mediaElement.currentTime : 0, this.seekEnd(this.currentTime));
+		};
+		this.#d = {
+			durationChangeHandler: c,
+			endedHandler: l,
+			errorHandler: d,
+			pauseHandler: a,
+			playHandler: t,
+			playingHandler: t,
+			seekedHandler: f,
+			stalledHandler: r,
+			timeUpdateHandler: s,
+			waitingHandler: r
+		}, this.#g = {
+			bufferingHandler: (e) => {
+				e.buffering ? r(e) : this.hasStarted() && t(e);
+			},
+			errorHandler: (e) => this.#A(e),
+			loadedHandler: a,
+			stallDetectedHandler: r
+		};
+	}
+	#b() {
+		this.#a != null && (clearTimeout(this.#a), this.#a = null), this.#r != null && (clearTimeout(this.#r), this.#r = null), this.#o != null && (clearTimeout(this.#o), this.#o = null);
+	}
+	#x(t, r, i) {
+		if (i !== void 0 && i !== this.#s) return;
+		this.#s = void 0, this.#b(), this.debugLog("Crossfade complete - swapping active player");
+		let a = this.#T(), o = this.#n === 1 ? this.#f : this.#p;
+		if (o) {
+			let e = this.playbackState, t = this.currentStreamingSessionId;
+			this.currentTime = a.currentTime, this.currentStreamingSessionId = o, this.finishCurrentMediaProduct("completed", !0), this.currentStreamingSessionId = t, this.playbackState = e, this.#n === 1 ? this.#f = void 0 : this.#p = void 0;
+		}
+		a.volume = 0;
+		try {
+			a.pause();
+		} catch {}
+		this.#n = this.#n === 1 ? 2 : 1, this.currentTime = t.currentTime, this.currentStreamingSessionId = r.streamInfo.streamingSessionId, this.preloadedStreamingSessionId = void 0, this.startAssetPosition = 0;
+		let c = Number.isFinite(t.duration) ? t.duration : r.streamInfo.duration ?? 0, l = t.currentTime, u = y({
+			assetPosition: l,
+			duration: c,
+			playbackInfo: r.playbackInfo,
+			streamInfo: r.streamInfo
+		});
+		n.saveMediaProductTransition(r.streamInfo.streamingSessionId, {
+			mediaProduct: r.mediaProduct,
+			playbackContext: u
+		}), this.debugLog("Media product transition saved for track"), e.dispatchEvent(v(r.mediaProduct, u)), performance.mark("streaming_metrics:playback_statistics:idealStartTimestamp", {
+			detail: r.streamInfo.streamingSessionId,
+			startTime: s.now()
+		}), this.mediaProductStarted(r.streamInfo.streamingSessionId), this.debugLog("Transition complete! Active player is now:", this.#n), this.#i = !1;
+	}
+	async #S(e) {
+		if ("Cypress" in window) return;
+		let t = await S.default.Player.probeSupport();
+		if (t.drm["com.widevine.alpha"]) {
+			this.debugLog("Configuring widevine DRM."), e.configure({ drm: {
+				advanced: { "com.widevine.alpha": {
+					audioRobustness: ["SW_SECURE_CRYPTO"],
+					serverCertificate: V,
+					videoRobustness: ["SW_SECURE_CRYPTO"]
+				} },
+				servers: { "com.widevine.alpha": "https://api.tidal.com/v2/widevine" }
+			} });
+			return;
+		} else if (t.drm["com.apple.fps.1_0"]) {
+			this.debugLog("Configuring fairplay DRM."), S.default.polyfill.PatchedMediaKeysApple.install();
+			let t = await A();
+			e.configure({ drm: {
+				advanced: { "com.apple.fps.1_0": {
+					serverCertificate: t,
+					serverCertificateUri: "https://fp.fa.tidal.com/certificate"
+				} },
+				initDataTransform: S.default.drm.FairPlay.verimatrixInitDataTransform,
+				servers: { "com.apple.fps.1_0": "https://fp.fa.tidal.com/license" }
+			} });
+			return;
+		}
+	}
+	async #C(e) {
+		await S.default.drm.FairPlay.isFairPlaySupported() && e && (e.getConfiguration().streaming.preferNativeHls !== !0 && e.configure("streaming.preferNativeHls", !0), e.getConfiguration().streaming.useNativeHlsForFairPlay !== !0 && e.configure("streaming.useNativeHlsForFairPlay", !0), await e.unload(!0));
+	}
+	async #w(e, n) {
+		this.debugLog("createShakaPlayer", e);
+		let r = new S.default.Player();
+		await r.attach(e), R(e), k(r, () => n === 1 ? this.#f : this.#p, () => this.#n === n);
+		let i = await S.default.drm.FairPlay.isFairPlaySupported(), a = {
+			backoffFactor: 2,
+			baseDelay: 1e3,
+			fuzzFactor: .5,
+			maxAttempts: 5,
+			timeout: 5e3
+		};
+		r.configure({
+			abr: { enabled: !0 },
+			drm: { retryParameters: a },
+			manifest: {
+				defaultPresentationDelay: 0,
+				disableText: !0,
+				disableThumbnails: !0,
+				retryParameters: a
+			},
+			streaming: {
+				bufferBehind: 40,
+				bufferingGoal: 40,
+				preferNativeHls: i,
+				retryParameters: a,
+				useNativeHlsForFairPlay: i
+			}
+		});
+		try {
+			await this.#S(r);
+		} catch {
+			this.finishCurrentMediaProduct("error");
+			return;
+		}
+		return r.getNetworkingEngine()?.registerRequestFilter(async (e, r, i) => {
+			if (e === S.default.net.NetworkingEngine.RequestType.LICENSE) {
+				let e = i?.isPreload ?? n !== this.#n ? this.preloadedStreamingSessionId ?? this.currentStreamingSessionId : this.currentStreamingSessionId;
+				performance.mark("streaming_metrics:drm_license_fetch:startTimestamp", {
+					detail: e,
+					startTime: s.now()
+				}), r.headers["Content-Type"] = "application/octet-stream";
+				let { token: a } = await t.credentialsProvider.getCredentials();
+				a && (r.headers.authorization = `Bearer ${a}`);
+			}
+		}), r.getNetworkingEngine()?.registerResponseFilter((e, t, r) => {
+			let i = r?.isPreload ?? n !== this.#n ? this.preloadedStreamingSessionId ?? this.currentStreamingSessionId : this.currentStreamingSessionId;
+			e === S.default.net.NetworkingEngine.RequestType.LICENSE && i && (performance.mark("streaming_metrics:drm_license_fetch:endTimestamp", {
+				detail: i,
+				startTime: s.now()
+			}), performance.measure("streaming_metrics:drm_license_fetch", {
+				detail: i,
+				end: "streaming_metrics:drm_license_fetch:endTimestamp",
+				start: "streaming_metrics:drm_license_fetch:startTimestamp"
+			}), f({
+				cdm: B(t.uri),
+				cdmVersion: null,
+				streamingSessionId: i
+			}), p([g({
+				endReason: "COMPLETE",
+				endTimestamp: s.timestamp("streaming_metrics:drm_license_fetch:endTimestamp"),
+				errorCode: null,
+				errorMessage: null,
+				startTimestamp: s.timestamp("streaming_metrics:drm_license_fetch:startTimestamp"),
+				streamingSessionId: i
+			})]).catch(console.error), performance.clearMarks("streaming_metrics:drm_license_fetch:endTimestamp"), performance.clearMarks("streaming_metrics:drm_license_fetch:startTimestamp"));
+		}), this.#F(r, !0), this.#N(e, !0), r;
+	}
+	#T() {
+		return this.#n === 1 ? u : l;
+	}
+	#E() {
+		return this.#n === 1 ? this.#_ : this.#v;
+	}
+	#D() {
+		return this.#n === 1 ? l : u;
+	}
+	#O() {
+		return this.#n === 1 ? this.#v : this.#_;
+	}
+	#k() {
+		let e = o("crossfadeInMs");
+		return e > 0 ? {
+			crossfadeDurationMs: e,
+			startBeforeEndS: e / 1e3
+		} : {
+			crossfadeDurationMs: d.#e,
+			startBeforeEndS: d.#t
+		};
+	}
+	#A(t) {
+		if (this.#c) return;
+		let n = t.target instanceof S.default.Player && t.target !== this.#E(), i = t.detail, a = `S${i.code}`;
+		switch (i.code) {
+			case S.default.util.Error.Code.LICENSE_REQUEST_FAILED: {
+				let e = n ? this.preloadedStreamingSessionId ?? this.currentStreamingSessionId : this.currentStreamingSessionId;
+				e && p([g({
+					endReason: "ERROR",
+					endTimestamp: s.timestamp("streaming_metrics:drm_license_fetch:endTimestamp"),
+					errorCode: a,
+					errorMessage: JSON.stringify(i),
+					startTimestamp: s.timestamp("streaming_metrics:drm_license_fetch:startTimestamp"),
+					streamingSessionId: e
+				})]).catch(console.error);
+				break;
+			}
+			case S.default.util.Error.Code.LOAD_INTERRUPTED: return;
+			case S.default.util.Error.Code.SRC_EQUALS_PRELOAD_NOT_SUPPORTED: return;
+			case S.default.util.Error.Code.TIMEOUT:
+				console.warn("Shaka: TIMEOUT"), console.warn("Shaka: URI", i.data[0]), console.warn("Shaka: RequestType", i.data[1]);
+				break;
+			default: break;
+		}
+		let o = i.category === S.default.util.Error.Category.NETWORK;
+		if (i.severity === S.default.util.Error.Severity.CRITICAL) {
+			if (n) {
+				this.debugLog("Critical error from inactive player, clearing preload:", a), this.#m = !1, this.unloadPreloadedMediaProduct().catch(console.error), e.dispatchError(new r(o ? "PENetwork" : "EUnexpected", a));
+				return;
+			}
+			this.playbackState = "STALLED", this.mediaElement && this.mediaElement.pause(), this.currentStreamingSessionId && f({
+				errorCode: a,
+				errorMessage: JSON.stringify(i),
+				streamingSessionId: this.currentStreamingSessionId
+			}), e.dispatchError(new r(o ? "PENetwork" : "EUnexpected", a)), o || this.finishCurrentMediaProduct("error");
+		}
+		o && (this.#y = !0);
+	}
+	async #j({ assetPosition: t, assetUriOrPreloader: r, mediaProduct: i, playbackInfo: a, streamInfo: o }) {
+		this.debugLog("loadAndDispatchMediaProductTransition"), this.currentTime = t;
+		let s = this.#E(), c = this.#T();
+		if (!s || !c) return;
+		let l, u = new Promise((e) => {
+			l = e;
+		}), d = () => l();
+		s.addEventListener("loaded", d, { once: !0 }), this.debugLog("Loading with", typeof r == "string" ? "URL" : "PreloadManager", "at position", t), this.currentStreamingSessionId = a.streamingSessionId, this.preloadedStreamingSessionId = void 0, this.#n === 1 ? this.#f = a.streamingSessionId : this.#p = a.streamingSessionId;
+		let f, p = n.hasMediaProductTransition(a.streamingSessionId);
+		p ? f = n.getMediaProductTransition(a.streamingSessionId).playbackContext : (f = y({
+			assetPosition: t,
+			duration: o.duration ?? 0,
+			playbackInfo: a,
+			streamInfo: o
+		}), n.saveMediaProductTransition(o.streamingSessionId, {
+			mediaProduct: i,
+			playbackContext: f
+		}));
+		let m = new AbortController(), h;
+		p || (h = new Promise((e) => c.addEventListener("durationchange", (t) => {
+			t.target instanceof HTMLMediaElement && e(t.target.duration);
+		}, {
+			once: !0,
+			signal: m.signal
+		})));
+		try {
+			await s.load(r, t), this.debugLog("Load completed successfully");
+		} catch (e) {
+			let t = e;
+			console.error("Load failed:", t), this.#A(new CustomEvent("shaka-error", { detail: t })), s.removeEventListener("loaded", d), m.abort(), n.deleteSession(o.streamingSessionId);
+			return;
+		}
+		h && (f = y({
+			assetPosition: t,
+			duration: await h,
+			playbackInfo: a,
+			streamInfo: o
+		}), n.saveMediaProductTransition(o.streamingSessionId, {
+			mediaProduct: i,
+			playbackContext: f
+		})), await u, this.currentStreamingSessionId === o.streamingSessionId && e.dispatchEvent(v(i, f));
+	}
+	async #M() {
+		this.debugLog("loadLibraries"), S.default.polyfill.installAll(), await c(), this.#_ = await this.#w(u, 1), this.#v = await this.#w(l, 2), l.volume = 0, this.debugLog("Both Shaka players initialized for gapless playback");
+	}
+	#N(e, t) {
+		this.debugLog("mediaElementEvents", t ? "adding to" : "removing from", e);
+		let n = t ? "addEventListener" : "removeEventListener";
+		e[n]("durationchange", this.#d.durationChangeHandler, { passive: !0 }), e[n]("play", this.#d.playHandler, { passive: !0 }), e[n]("playing", this.#d.playingHandler, { passive: !0 }), e[n]("timeupdate", this.#d.timeUpdateHandler, { passive: !0 }), e[n]("pause", this.#d.pauseHandler, { passive: !0 }), e[n]("ended", this.#d.endedHandler, { passive: !0 }), e[n]("error", this.#d.errorHandler, { passive: !0 }), e[n]("waiting", this.#d.waitingHandler, { passive: !0 }), e[n]("stalled", this.#d.stalledHandler, { passive: !0 }), e[n]("seeked", this.#d.seekedHandler, { passive: !0 });
+	}
+	#P() {
+		this.#o != null && (clearTimeout(this.#o), this.#o = null);
+		let e = this.#T(), t = e.duration;
+		if (!Number.isFinite(t) || t <= 0) {
+			this.debugLog("scheduleCrossfadeTrigger: invalid duration, skipping");
+			return;
+		}
+		let n = e.playbackRate || 1, r = t - e.currentTime, { startBeforeEndS: i } = this.#k(), a = (r - i) * 1e3 / n;
+		if (a <= 0) {
+			if (e.paused) {
+				this.debugLog("scheduleCrossfadeTrigger: inside trigger window but paused -- deferring to timeUpdateHandler");
+				return;
+			}
+			this.debugLog("scheduleCrossfadeTrigger: inside trigger window -- firing now"), this.#R().catch(console.error);
+			return;
+		}
+		this.#o = setTimeout(() => {
+			this.#o = null;
+			let { startBeforeEndS: t } = this.#k();
+			if ((e.duration - e.currentTime - t) * 1e3 / (e.playbackRate || 1) > 0) {
+				if (!this.#m || !this.#h || this.#i) {
+					this.debugLog("scheduleCrossfadeTrigger: preload no longer valid -- not rescheduling");
+					return;
+				}
+				if (e.paused) {
+					this.debugLog("scheduleCrossfadeTrigger: paused while waiting -- deferring re-arm to play event");
+					return;
+				}
+				this.debugLog("scheduleCrossfadeTrigger: no longer inside trigger window -- rescheduling"), this.#P();
+				return;
+			}
+			this.#m && this.#h && !this.#i && !e.paused && e === this.#T() ? this.#R().catch(console.error) : this.debugLog("scheduleCrossfadeTrigger: guards failed, NOT starting");
+		}, a);
+	}
+	#F(e, t) {
+		this.debugLog("shakaEvents");
+		let n = t ? "addEventListener" : "removeEventListener";
+		e[n]("error", this.#g.errorHandler, !1), e[n]("buffering", this.#g.bufferingHandler, !1), e[n]("stalldetected", this.#g.stallDetectedHandler, !1), e[n]("loaded", this.#g.loadedHandler, !1);
+	}
+	async #I(e) {
+		this.debugLog(`Starting crossfade transition (${e}ms)`);
+		let t = this.#T(), r = this.#D(), i = this.#h;
+		this.#m = !1, this.#h = null;
+		let a = {};
+		this.#s = a;
+		let o = n.getStreamInfo(this.currentStreamingSessionId);
+		try {
+			r.currentTime = 0, r.volume = .001, await r.play(), r.volume = 0;
+		} catch (e) {
+			this.debugLog("Error while starting crossfade", e);
+			try {
+				r.pause();
+			} catch {}
+			this.#b(), this.#i = !1, this.#s = void 0, this.unloadPreloadedMediaProduct().catch(console.error);
+			return;
+		}
+		let s = performance.now(), c = () => {
+			if (this.#s !== a) return;
+			let n = performance.now() - s, l = Math.min(n / e, 1), u = Math.cos(l * Math.PI / 2), d = Math.sin(l * Math.PI / 2), f = o ? this.adjustedVolume(o) : t.volume, p = this.adjustedVolume(i.streamInfo);
+			t.volume = Math.max(0, Math.min(1, f * u)), r.volume = Math.max(0, Math.min(1, p * d)), l < 1 ? this.#a = setTimeout(c, 16) : this.#x(r, i, a);
+		};
+		this.#r = setTimeout(() => {
+			this.#s === a && (this.debugLog("Crossfade hit hard deadline -- forcing completion"), t.volume = 0, r.volume = this.adjustedVolume(i.streamInfo), this.#x(r, i, a));
+		}, e + 200), c();
+	}
+	async #L() {
+		this.debugLog("Starting instant transition (no fade)");
+		let e = this.#D(), t = this.#h;
+		this.#m = !1, this.#h = null;
+		let n = {};
+		this.#s = n;
+		let r = this.adjustedVolume(t.streamInfo);
+		try {
+			e.currentTime = 0, e.volume = r, await e.play();
+		} catch (e) {
+			this.debugLog("Error while starting instant transition", e), this.#i = !1, this.#s = void 0, this.unloadPreloadedMediaProduct().catch(console.error);
+			return;
+		}
+		this.#s === n && this.#x(e, t, n);
+	}
+	async #R({ instant: e = !1 } = {}) {
+		if (this.#i || !this.#h || !this.#m) return;
+		if (this.#i = !0, e) {
+			await this.#L();
+			return;
+		}
+		let { crossfadeDurationMs: t } = this.#k(), n = this.#T(), r = n.playbackRate || 1, i = Math.max(0, (n.duration - n.currentTime) * 1e3 / r), a = Math.max(1, Math.min(t, i));
+		await this.#I(a);
+	}
+	async #z(e) {
+		return e.readyState > HTMLMediaElement.HAVE_NOTHING ? !0 : new Promise((t) => {
+			let n = !1, r = () => {
+				e.removeEventListener("loadedmetadata", a), e.removeEventListener("loadeddata", a), e.removeEventListener("canplay", a), clearTimeout(o);
+			}, i = (e) => {
+				n || (n = !0, r(), t(e));
+			}, a = () => i(!0), o = setTimeout(() => i(!1), 1e3);
+			e.addEventListener("loadedmetadata", a, { once: !0 }), e.addEventListener("loadeddata", a, { once: !0 }), e.addEventListener("canplay", a, { once: !0 });
+		});
+	}
+	getPosition() {
+		return this.currentTime;
+	}
+	async load(e, t) {
+		this.debugLog("load", e), await this.ready, this.currentTime = e.assetPosition, this.startAssetPosition = e.assetPosition, await this.reset(), this.#c = !1, await this.#C(this.#E()), await c();
+		let { assetPosition: n, mediaProduct: r, playbackInfo: i, streamInfo: a } = e;
+		this.currentStreamingSessionId = a.streamingSessionId, t === "explicit" && (this.playbackState = "NOT_PLAYING");
+		let o = this.#T();
+		if (!this.#E() || !o) return;
+		this.#i && (this.#i = !1, this.#s = void 0), this.#b(), this.#m = !1, this.#h = null;
+		let s = this.#D();
+		return s.pause(), s.volume = 0, this.#j({
+			assetPosition: n,
+			assetUriOrPreloader: a.streamUrl,
+			mediaProduct: r,
+			playbackInfo: i,
+			streamInfo: a
+		});
+	}
+	get mediaElement() {
+		return this.#T();
+	}
+	async next(e) {
+		this.debugLog("next", e);
+		let t = this.#O(), r = this.#D();
+		if (!t || !r) {
+			console.warn("Inactive Shaka instance or media element not initialized.");
+			return;
+		}
+		this.#m = !1, this.#h = e, this.preloadedStreamingSessionId = e.streamInfo.streamingSessionId;
+		let i = this.#n === 1 ? this.#p : this.#f;
+		if (i) {
+			this.debugLog(`Finalizing pending session ${i} on inactive player before preload`);
+			let e = this.playbackState, t = this.currentStreamingSessionId, n = this.currentTime;
+			r.readyState > HTMLMediaElement.HAVE_NOTHING && (this.currentTime = r.currentTime), this.currentStreamingSessionId = i, this.finishCurrentMediaProduct("completed", !0), this.currentStreamingSessionId = t, this.playbackState = e, this.currentTime = n;
+		}
+		this.#n === 1 ? this.#p = e.streamInfo.streamingSessionId : this.#f = e.streamInfo.streamingSessionId;
+		let a = y({
+			assetPosition: 0,
+			duration: e.streamInfo.duration || 0,
+			playbackInfo: e.playbackInfo,
+			streamInfo: e.streamInfo
+		});
+		n.saveMediaProductTransition(e.streamInfo.streamingSessionId, {
+			mediaProduct: e.mediaProduct,
+			playbackContext: a
+		}), this.debugLog("Loading next track in inactive player");
+		try {
+			if (await t.load(e.streamInfo.streamUrl), this.debugLog("Next track loaded in inactive player"), r.volume = 0, r.currentTime !== 0 && (r.currentTime = 0), !await this.#z(r)) throw Error(`Preloaded media element did not become ready after Shaka load (readyState=${r.readyState})`);
+			this.debugLog("Next track loaded and ready in inactive player"), this.playbackState === "IDLE" && (this.playbackState = "NOT_PLAYING"), (!r.duration || isNaN(r.duration)) && await new Promise((e) => {
+				let t = () => {
+					clearTimeout(n), e();
+				}, n = setTimeout(() => {
+					r.removeEventListener("durationchange", t), this.debugLog("next(): durationchange did not fire within 3000ms -- falling back to payload duration"), e();
+				}, 3e3);
+				r.addEventListener("durationchange", t, { once: !0 });
+			});
+			let i = y({
+				assetPosition: 0,
+				duration: r.duration || e.streamInfo.duration || 0,
+				playbackInfo: e.playbackInfo,
+				streamInfo: e.streamInfo
+			});
+			if (n.saveMediaProductTransition(e.streamInfo.streamingSessionId, {
+				mediaProduct: e.mediaProduct,
+				playbackContext: i
+			}), this.debugLog("Media product transition saved for next track"), this.preloadedStreamingSessionId !== e.streamInfo.streamingSessionId) {
+				this.debugLog(`next(): preload superseded during load (${e.streamInfo.streamingSessionId} -> ${this.preloadedStreamingSessionId ?? "none"}) -- not arming preload`);
+				return;
+			}
+			this.#m = !0, this.#c = !1, this.#P();
+		} catch (e) {
+			console.error("Failed to load next track:", e);
+			try {
+				await t.unload(!0);
+			} catch {}
+			this.#m = !1, this.#h = null, this.cleanUpStoredPreloadInfo(), this.#n === 1 ? this.#p = void 0 : this.#f = void 0;
+		}
+	}
+	pause() {
+		this.debugLog("pause"), this.mediaElement && this.mediaElement.pause();
+	}
+	async play() {
+		if (this.debugLog("play"), await this.maybeHardReload(), this.#y) {
+			let e = this.#E()?.retryStreaming();
+			if (this.#y = !e, !e) {
+				this.playbackState = "NOT_PLAYING", this.finishCurrentMediaProduct("error");
+				return;
+			}
+		}
+		if (this.playbackState === "IDLE") return this.debugLog("is IDLE, returning early"), Promise.resolve();
+		let e = this.#T();
+		e && "setSinkId" in e && await this.updateOutputDevice(), this.mediaProductStarted(this.currentStreamingSessionId), this.setStateToXIfNotYInZMs(1e3, "PLAYING", "STALLED"), await this.mediaElement?.play();
+		let t = this.#E()?.getVariantTracks()?.find((e) => e.active);
+		E(this.currentStreamingSessionId, t);
+	}
+	async playbackEngineEndedHandler(e) {
+		if (this.isActivePlayer) {
+			let { reason: t } = e.detail;
+			t === "completed" && (this.debugLog("Track ended - checking for next item"), this.#h && this.#m && !this.#i ? (this.debugLog("Transition missed - swapping immediately"), await this.#R({ instant: !0 })) : this.#m && this.hasNextItem() ? (await this.skipToPreloadedMediaProduct(), await this.play()) : (a.preloadedStreamingSessionId ? this.debugLog(`Switching player from ${this.name} to ${a.preloadPlayer?.name}`) : this.debugLog("No next item queued."), this.playbackState = "NOT_PLAYING"));
+		}
+	}
+	get ready() {
+		return this.#l;
+	}
+	async reset({ keepPreload: e } = { keepPreload: !1 }) {
+		if (this.debugLog("reset"), this.#u.reset(), this.#c) return;
+		let t = !e && !!this.preloadedStreamingSessionId;
+		e || await this.unloadPreloadedMediaProduct({ initializeMediaSource: !0 }), this.playbackState !== "IDLE" && this.finishCurrentMediaProduct("skip"), this.playbackState = "IDLE", this.detachPlaybackEngineEndedHandler(), this.currentStreamingSessionId = void 0, e || (this.preloadedStreamingSessionId = void 0, this.#m = !1, this.#h = null), this.#i && (this.#b(), this.#i = !1, this.#s = void 0), this.#c = !0;
+		let n = [], r = this.#E(), i = this.#O();
+		r && n.push(r.unload(!0)), !e && !t && i && n.push(i.unload(!0)), e ? this.#n === 1 ? this.#f = void 0 : this.#p = void 0 : (u.volume = 1, l.volume = 0, this.#n = 1, this.#f = void 0, this.#p = void 0), await Promise.all(n);
+	}
+	seek(e) {
+		this.debugLog("seek", e);
+		let { mediaElement: t } = this;
+		if (!t) {
+			this.debugLog("No media element available for seeking");
+			return;
+		}
+		this.seekStart(this.currentTime), this.currentTime = e;
+		let n = e;
+		return "fastSeek" in t ? t.fastSeek(n) : t.currentTime = n, new Promise((e) => {
+			t.addEventListener("seeked", () => e(t.currentTime), { once: !0 });
+		});
+	}
+	async skipToPreloadedMediaProduct() {
+		if (this.debugLog("skipToPreloadedMediaProduct", this.preloadedStreamingSessionId), !this.preloadedStreamingSessionId) return Promise.reject("Nothing preloaded.");
+		let e = this.#h;
+		if (!e) return Promise.reject("Preloaded payload not found.");
+		let t = n.getMediaProductTransition(this.preloadedStreamingSessionId);
+		t && (e.mediaProduct = t.mediaProduct);
+		let r = this.#D(), i = this.#T();
+		i.pause(), i.volume = 0, this.playbackState = "NOT_PLAYING", this.#b(), this.#m = !1, this.#h = null, this.#x(r, e);
+	}
+	togglePlayback() {
+		this.debugLog("togglePlayback");
+		let { mediaElement: e } = this;
+		e && (e.paused ? e.play().catch(console.error) : e.pause());
+	}
+	async unloadPreloadedMediaProduct({ initializeMediaSource: e = !1 } = {}) {
+		if (this.debugLog("unloadPreloadedMediaProduct", this.preloadedStreamingSessionId), !this.preloadedStreamingSessionId) return;
+		this.cleanUpStoredPreloadInfo(), this.#b(), this.#h = null, this.#m = !1;
+		let t = this.#O(), n = this.#D();
+		if (t) {
+			try {
+				await t.unload(e);
+			} catch (e) {
+				this.debugLog("inactivePlayer.unload() rejected (ignored)", e);
+			}
+			n.volume = 0;
+		}
+	}
+	async updateOutputDevice() {
+		if (!z) return;
+		if (z && !z.activeDevice || !o("outputDevicesEnabled")) return Promise.resolve();
+		let t = z.activeDevice.webDeviceId;
+		if (t && typeof u.setSinkId == "function") {
+			this.outputDeviceType = z.activeDevice.type;
+			try {
+				await Promise.all([u.setSinkId(t), l.setSinkId(t)]), e.dispatchEvent(_(z.activeDevice.id));
+			} catch (e) {
+				console.error(e);
+			}
+		}
+	}
+	get volume() {
+		return o("desiredVolumeLevel");
+	}
+	set volume(e) {
+		this.debugLog("Setting volume to", e), this.mediaElement && (this.mediaElement.volume = e);
+	}
+};
+//#endregion
+export { H as default };