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

package/dist/media-element-error-circuit-breaker-BUJbK6sd-DNlFckiw.js

@@ -0,0 +1,22 @@
+import { a as e, n as t } from "./state-BT7sE_jc-iVaBwnBC.js";
+import { t as n } from "./pushkin-C7W2HCqN-BHqS8oLX.js";
+//#region ../player/dist/media-element-error-circuit-breaker-BUJbK6sd.js
+var r = 6e4, i = (e) => {
+	console.error("HTMLMediaElement errored", e.target?.error ?? null);
+}, a = () => {
+	console.error("HTMLMediaElement error limit reached, suppressing further errors"), e.dispatchError(new t("EUnexpected", "ME01"));
+};
+function o(e = {}) {
+	let { errorWindowMs: t = r, log: o = i, maxErrors: s = 10, now: c = () => n.now(), onLimitReached: l = a } = e, u = 0, d = 0;
+	return {
+		handleError(e) {
+			let n = c();
+			n - d >= t && (u = 0), d = n, u += 1, u <= s && o(e), u === s && l();
+		},
+		reset() {
+			u = 0, d = 0;
+		}
+	};
+}
+//#endregion
+export { o as t };

package/dist/nativePlayer-DtYpfmo5-nNN5yO4E.js

@@ -0,0 +1,232 @@
+import { a as e, i as t, n, t as r, u as i } from "./state-BT7sE_jc-iVaBwnBC.js";
+import { t as a } from "./pushkin-C7W2HCqN-BHqS8oLX.js";
+import { a as o } from "./load-L6Urw8gV-CQAMBwcN.js";
+import { t as s } from "./active-device-mode-changed-OmLVES_4-zwN5exje.js";
+import { t as c } from "./active-device-changed-BDbOSq7P-DQ6vFR_K.js";
+import { n as l, r as u, t as d } from "./basePlayer-D9LFxFnB-BNIKxMHD.js";
+//#region ../player/dist/nativePlayer-DtYpfmo5.js
+var f = "active-device-disconnected";
+function p() {
+	return new CustomEvent(f);
+}
+var m = {
+	file_checksum_mismatch: "NPO02",
+	no_such_file: "NPO01",
+	unreadable_file: "NPO03"
+}, h = {
+	devicedisconnected: "NPD01",
+	deviceexclusivemodenotallowed: "NPD02",
+	deviceformatnotsupported: "NPD03",
+	devicelocked: "NPD04",
+	devicenotfound: "NPD05",
+	deviceunknownerror: "NPD00"
+}, g, _ = class extends d {
+	#e = "default";
+	#t;
+	#n;
+	#r;
+	name = "nativePlayer";
+	playbackEngineHandlerAttached = !1;
+	constructor() {
+		super(), i("outputDevicesEnabled") && (async () => {
+			g = (await import("./output-devices-CPJfYcO--BP7JMB6k.js")).outputDevices, this.#n.listDevices();
+		})(), this.#n = window.NativePlayerComponent.Player(), this.playbackState = "IDLE", this.registerEventListeners(), this.#n.setVolume(100);
+	}
+	#i(t) {
+		e.dispatchError(new n("EUnexpected", h[t]));
+	}
+	#a(t) {
+		this.debugLog("handleMediaError", t.target);
+		let r = m[t.target.errorCode];
+		this.currentStreamingSessionId && o({
+			errorCode: r,
+			errorMessage: JSON.stringify(t.target),
+			streamingSessionId: this.currentStreamingSessionId
+		}), e.dispatchError(new n("EUnexpected", r));
+	}
+	#o(e) {
+		switch (this.debugLog("handleNativePlayerStateChange", e), e) {
+			case "active":
+				this.playbackState = "PLAYING";
+				break;
+			case "idle":
+			case "seeking":
+				this.playbackState = "STALLED";
+				break;
+			case "paused":
+			case "ready":
+				this.playbackState = "NOT_PLAYING";
+				break;
+			case "stopped":
+				this.playbackState = "NOT_PLAYING";
+				break;
+			case "uninitialized":
+				this.playbackState = "IDLE";
+				break;
+			default:
+				this.debugLog("No handling for state", e);
+				break;
+		}
+	}
+	async #s() {
+		this.debugLog("handleNetworkError");
+		let t = a.timestamp("streaming_metrics:playback_statistics:actualStartTimestamp");
+		if ((t === void 0 ? 0 : Math.abs(a.now() - t)) >= 36e5) {
+			let e = structuredClone(this.currentMediaProduct), t = this.currentTime;
+			this.finishCurrentMediaProduct("error"), e && (await this.hardReload(e, t), await this.play());
+			return;
+		}
+		await Promise.race([this.mediaStateChange("idle"), new Promise((e) => {
+			window.addEventListener("online", () => e("online"));
+		})]) === "idle" && e.dispatchError(new n("PENetwork", "NPN01"));
+	}
+	abandon() {
+		g?.deviceMode === "exclusive" && this.#n.selectSystemDevice();
+	}
+	getPosition() {
+		return this.currentTime;
+	}
+	async handleAutomaticTransitionToPreloadedMediaProduct() {
+		await this.nativeEvent("mediaduration"), this.#r = void 0;
+		let n = t.getMediaProductTransition(this.preloadedStreamingSessionId);
+		if (!n) {
+			console.warn("No media product transition saved for next item. Stopping playback."), this.playbackState = "NOT_PLAYING";
+			return;
+		}
+		let { mediaProduct: r, playbackContext: i } = n, a = {
+			...i,
+			actualDuration: this.#t
+		};
+		this.preloadedStreamingSessionId && t.saveMediaProductTransition(this.preloadedStreamingSessionId, {
+			mediaProduct: r,
+			playbackContext: a
+		}), await this.mediaStateChange("active"), e.dispatchEvent(l(r, a)), this.currentStreamingSessionId = this.preloadedStreamingSessionId, this.mediaProductStarted(this.currentStreamingSessionId);
+	}
+	async load(n, r) {
+		this.debugLog("load", n), this.currentTime = n.assetPosition, this.startAssetPosition = n.assetPosition, await this.reset();
+		let { assetPosition: i, mediaProduct: a, playbackInfo: o, streamInfo: s } = n, { securityToken: c, streamFormat: d, streamUrl: f } = s;
+		this.currentStreamingSessionId = s.streamingSessionId, r === "explicit" && (this.playbackState = "NOT_PLAYING");
+		let p = this.nativeEvent("mediaduration");
+		if (d) this.#n.load(f, d, c);
+		else throw Error("Stream format is undefined.");
+		if (await p, this.currentStreamingSessionId !== s.streamingSessionId) return;
+		this.debugLog("load() duration is", this.#t), i !== 0 && i < this.#t ? (async () => {
+			await this.mediaStateChange("active"), this.currentStreamingSessionId === s.streamingSessionId && (await this.seek(i), this.currentTime = i);
+		})().catch(console.error) : this.currentTime = 0;
+		let m = u({
+			assetPosition: i,
+			duration: this.#t,
+			playbackInfo: o,
+			streamInfo: s
+		});
+		t.saveMediaProductTransition(s.streamingSessionId, {
+			mediaProduct: a,
+			playbackContext: m
+		}), this.debugLog("load() mediaProductTransition"), e.dispatchEvent(l(a, m)), this.debugLog("load() pb NOT_PLAYING"), this.debugLog("load() done");
+	}
+	mediaStateChange(e) {
+		return new Promise((t) => {
+			let n = (r) => {
+				r.target === e && (this.#n.removeEventListener("mediastate", n), t(r.target));
+			};
+			this.#n.addEventListener("mediastate", n);
+		});
+	}
+	nativeEvent(e) {
+		return new Promise((t) => {
+			let n = (r) => {
+				this.#n.removeEventListener(e, n), t(r);
+			};
+			this.#n.addEventListener(e, n);
+		});
+	}
+	async next(e) {
+		this.debugLog("next", e), this.hasNextItem() && await this.unloadPreloadedMediaProduct();
+		let { mediaProduct: n, playbackInfo: r, streamInfo: i } = e, { securityToken: a, streamFormat: o, streamUrl: s, streamingSessionId: c } = i;
+		this.preloadedStreamingSessionId = c, this.debugLog("preloading", s, "for", c), o ? (this.#n.preload(s, o, a), this.isActivePlayer || this.#n.pause()) : console.error("Stream format undefined for preload."), this.debugLog("preloading done");
+		let l = u({
+			assetPosition: 0,
+			duration: 0,
+			playbackInfo: r,
+			streamInfo: i
+		});
+		t.saveMediaProductTransition(c, {
+			mediaProduct: n,
+			playbackContext: l
+		}), this.#r = e;
+	}
+	pause() {
+		this.#n.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.#n.play();
+	}
+	async playbackEngineEndedHandler(e) {
+		if (this.isActivePlayer) {
+			let { reason: t } = e.detail;
+			t === "completed" && (this.hasNextItem() ? await this.handleAutomaticTransitionToPreloadedMediaProduct() : (r.preloadedStreamingSessionId ? this.debugLog(`Switching player from ${this.name} to ${r.preloadPlayer?.name}`) : this.debugLog("No next item queued."), this.playbackState = "NOT_PLAYING"));
+		}
+	}
+	get ready() {
+		return Promise.resolve();
+	}
+	registerEventListeners() {
+		this.debugLog("registerEventListeners"), this.#n.addEventListener("mediacurrenttime", (e) => {
+			this.currentTime = Number(e.target);
+		}), this.#n.addEventListener("mediastate", (e) => {
+			e.target === "completed" ? this.finishCurrentMediaProduct("completed") : this.#o(e.target);
+		}), this.#n.addEventListener("devices", (e) => {
+			g ? g.addNativeDevices(e.target) : console.error("Output devices not loaded.");
+		}), this.#n.addEventListener("devicedisconnected", () => {
+			e.dispatchEvent(p()), this.#i("devicedisconnected");
+		}), this.#n.addEventListener("deviceexclusivemodenotallowed", () => this.#i("deviceexclusivemodenotallowed")), this.#n.addEventListener("deviceformatnotsupported", () => this.#i("deviceformatnotsupported")), this.#n.addEventListener("devicelocked", () => this.#i("devicelocked")), this.#n.addEventListener("devicenotfound", () => this.#i("devicenotfound")), this.#n.addEventListener("deviceunknownerror", () => this.#i("deviceunknownerror")), this.#n.addEventListener("mediaduration", (e) => {
+			this.#t = Number(e.target);
+		}), this.#n.addEventListener("mediaerror", (e) => this.#a(e)), this.#n.addEventListener("mediamaxconnectionsreached", () => {
+			this.#s().catch(console.error);
+		});
+	}
+	async reset({ keepPreload: e } = { keepPreload: !1 }) {
+		this.currentStreamingSessionId !== void 0 && (this.debugLog("reset"), e || await this.unloadPreloadedMediaProduct(), this.#n.stop(), this.playbackState !== "IDLE" && this.finishCurrentMediaProduct("skip"), this.detachPlaybackEngineEndedHandler(), this.currentStreamingSessionId = void 0, e || (this.preloadedStreamingSessionId = void 0), this.playbackState = "IDLE");
+	}
+	async seek(e) {
+		this.hasStarted() || await this.mediaStateChange("active"), this.seekStart(this.currentTime), this.currentTime = e, this.#n.seek(e), this.seekEnd(this.currentTime);
+	}
+	async skipToPreloadedMediaProduct() {
+		this.debugLog("skipToPreloadedMediaProduct", this.preloadedStreamingSessionId);
+		let e = this.currentStreamingSessionId === void 0;
+		if (this.preloadedStreamingSessionId && this.#r) {
+			let n = t.getMediaProductTransition(this.preloadedStreamingSessionId);
+			n && (this.#r.mediaProduct = n.mediaProduct), await this.load(this.#r, "implicit"), await this.updateOutputDevice(), e && (this.playbackState = "PLAYING"), this.playbackState === "IDLE" && (this.playbackState = "NOT_PLAYING");
+			return;
+		}
+		console.warn("No preloaded item in native player.");
+	}
+	async unloadPreloadedMediaProduct() {
+		this.debugLog("unloadPreloadedMediaProduct", this.preloadedStreamingSessionId), this.hasNextItem() && (this.cleanUpStoredPreloadInfo(), "cancelPreload" in this.#n ? this.#n.cancelPreload() : console.warn("cancelPreload not available. Update native player."));
+	}
+	updateDeviceMode() {
+		this.updateOutputDevice()?.catch(console.error), g && e.dispatchEvent(s(g.deviceMode));
+	}
+	updateOutputDevice() {
+		if (!g || (this.debugLog("updateOutputDevice", g.activeDevice), !g.activeDevice)) return Promise.resolve();
+		let { nativeDeviceId: t } = g.activeDevice;
+		if (this.outputDeviceType = g.activeDevice.type, t === "default") this.#e !== "default" && (this.#n.selectSystemDevice(), e.dispatchEvent(c("default")), this.#e = "default");
+		else if (t) {
+			let n = g.getNativeDevice(t);
+			n && (this.#n.selectDevice(n, g.deviceMode), e.dispatchEvent(c(g.activeDevice.id)), e.dispatchEvent(s(g.deviceMode)), this.#e = t);
+		} else throw Error(`Device with sinkId ${t} not found.`);
+		return Promise.resolve();
+	}
+	get volume() {
+		return i("desiredVolumeLevel");
+	}
+	set volume(e) {
+		this.debugLog("Setting volume to", e), this.#n.setVolume(e * 100);
+	}
+};
+//#endregion
+export { _ as default };

package/dist/output-devices-CPJfYcO--BP7JMB6k.js

@@ -0,0 +1,156 @@
+import { a as e, t } from "./state-BT7sE_jc-iVaBwnBC.js";
+import { i as n, n as r, r as i, t as a } from "./generate-guid-BMGZjV-R-D16yCCHx.js";
+//#region ../player/dist/output-devices-CPJfYcO-.js
+var o = /* @__PURE__ */ i(((e, t) => {
+	t.exports = (function() {
+		function e(e, t, n, r, i) {
+			return e < t || n < t ? e > n ? n + 1 : e + 1 : r === i ? t : t + 1;
+		}
+		return function(t, n) {
+			if (t === n) return 0;
+			if (t.length > n.length) {
+				var r = t;
+				t = n, n = r;
+			}
+			for (var i = t.length, a = n.length; i > 0 && t.charCodeAt(i - 1) === n.charCodeAt(a - 1);) i--, a--;
+			for (var o = 0; o < i && t.charCodeAt(o) === n.charCodeAt(o);) o++;
+			if (i -= o, a -= o, i === 0 || a < 3) return a;
+			var s = 0, c, l, u, d, f, p, m, h, g, _, v, y, b = [];
+			for (c = 0; c < i; c++) b.push(c + 1), b.push(t.charCodeAt(o + c));
+			for (var x = b.length - 1; s < a - 3;) for (g = n.charCodeAt(o + (l = s)), _ = n.charCodeAt(o + (u = s + 1)), v = n.charCodeAt(o + (d = s + 2)), y = n.charCodeAt(o + (f = s + 3)), p = s += 4, c = 0; c < x; c += 2) m = b[c], h = b[c + 1], l = e(m, l, u, g, h), u = e(l, u, d, _, h), d = e(u, d, f, v, h), p = e(d, f, p, y, h), b[c] = p, f = d, d = u, u = l, l = m;
+			for (; s < a;) for (g = n.charCodeAt(o + (l = s)), p = ++s, c = 0; c < x; c += 2) m = b[c], b[c] = p = e(m, l, p, g, b[c + 1]), l = m;
+			return p;
+		};
+	})();
+})), s = /* @__PURE__ */ a(r(), 1), c = /* @__PURE__ */ a(o(), 1);
+function l(e) {
+	return new CustomEvent("device-change", { detail: { devices: e } });
+}
+var u = s.default.parse(navigator.userAgent), d = class {
+	controllableVolume;
+	id;
+	name;
+	nativeDeviceId;
+	type;
+	webDeviceId;
+	constructor({ controllableVolume: e, name: t, nativeDeviceId: r, type: i, webDeviceId: a }) {
+		this.name = t, this.id = r === "default" && a === "default" ? "default" : n(), this.nativeDeviceId = r, this.webDeviceId = a, this.type = i, this.controllableVolume = e !== !1;
+	}
+};
+function f(e) {
+	if (m(e)) return "windowsCommunication";
+	if ("id" in e && e.id === "BuiltInSpeakerDevice") return "builtIn";
+	if ("type" in e && e.type === "airplay") return "airplay";
+	if ("label" in e) {
+		let t = e.label.toLowerCase();
+		if (t.includes("bluetooth")) return "bluetooth";
+		if (t.includes("displayport")) return "displayPort";
+		if (t.includes("hdmi")) return "hdmi";
+		if (t.includes("usb")) return "usb";
+		if (t.includes("built-in")) return "builtIn";
+		if (t.includes("airplay")) return "airplay";
+	}
+}
+function p(e, t) {
+	let n = t.toLowerCase(), r = e;
+	return n.includes("mac") && (r = (e.split("(")[0] ?? "").trim()), r;
+}
+function m(e) {
+	let t;
+	return "label" in e && (t = e.label), "name" in e && (t = e.name), t?.startsWith("Communications") ?? !1;
+}
+function h(e, t) {
+	if (t = p(t, u.os.name || ""), [...e].length === 0 || t === "") return;
+	let n = [...e].find((e) => e.name === t);
+	if (n) return n;
+	let r = [...e].filter((e) => t.includes(e.name) || e.name.includes(t)).map((e) => ({
+		device: e,
+		distance: (0, c.default)(e.name, t)
+	})).sort((e, t) => e.distance - t.distance).reverse();
+	if (r.length > 0) {
+		let e = r.pop();
+		if (e && e.distance <= 16) return e.device;
+	}
+}
+var g = new class {
+	#e;
+	#t;
+	#n = "shared";
+	#r;
+	#i;
+	#a;
+	outputDevices;
+	constructor() {
+		this.#i = /* @__PURE__ */ new Set(), this.#a = /* @__PURE__ */ new Set(), this.#r = new EventTarget(), this.#t = new d({
+			name: "System Default",
+			nativeDeviceId: "default",
+			type: "systemDefault",
+			webDeviceId: "default"
+		}), this.#e = this.#t, this.outputDevices = new Set([this.#t]), this.hydrateWebDevices().then().catch(console.error), navigator.mediaDevices.addEventListener("devicechange", () => {
+			this.hydrateWebDevices().then().catch(console.error);
+		}), this.#r.addEventListener("native-devices", ((e) => {
+			this.#i = new Set(e.detail), this.queueUpdate().then().catch(console.error);
+		})), this.#r.addEventListener("web-devices", ((e) => {
+			this.#a = new Set(e.detail), this.queueUpdate().then().catch(console.error);
+		}));
+	}
+	set activeDevice(e) {
+		this.#e = e, this.#n = "shared", t.activePlayer?.updateOutputDevice()?.catch(console.error);
+	}
+	get activeDevice() {
+		return this.#e;
+	}
+	addNativeDevices(e) {
+		this.#r.dispatchEvent(new CustomEvent("native-devices", { detail: e }));
+	}
+	addWebDevices(e) {
+		e = e.filter((e) => e.deviceId !== "default"), this.#r.dispatchEvent(new CustomEvent("web-devices", { detail: e }));
+	}
+	set deviceMode(e) {
+		let { activeDevice: n } = this, { activePlayer: r } = t;
+		n && r?.name === "nativePlayer" && this.deviceMode !== e && (this.#n = e, r.updateDeviceMode());
+	}
+	get deviceMode() {
+		return this.#n;
+	}
+	emitDeviceChange() {
+		e.dispatchEvent(l([...this.outputDevices]));
+	}
+	getNativeDevice(e) {
+		return [...this.#i].find((t) => t.id === e);
+	}
+	async hydrateWebDevices() {
+		let e = (await navigator.mediaDevices.enumerateDevices()).filter((e) => e.kind === "audiooutput");
+		this.addWebDevices(e);
+	}
+	mergeDevices() {
+		[...this.outputDevices].filter((e) => e.id !== "default").forEach((e) => {
+			e.nativeDeviceId = void 0, e.webDeviceId = void 0;
+		}), this.#i.forEach((e) => {
+			let t = h(this.outputDevices, e.name);
+			t ? (t.nativeDeviceId = e.id, t.controllableVolume = e.controllableVolume, t.type = f(e) || t.type) : this.outputDevices.add(new d({
+				controllableVolume: e.controllableVolume,
+				name: p(e.name, u.os.name || ""),
+				nativeDeviceId: e.id,
+				type: f(e)
+			}));
+		}), this.#a.forEach((e) => {
+			let t = h(this.outputDevices, e.label);
+			t ? (t.webDeviceId = e.deviceId, t.type = f(e) || t.type) : this.outputDevices.add(new d({
+				name: p(e.label, u.os.name || ""),
+				type: f(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() {
+		let e = new Promise((e) => this.#r.addEventListener("native-devices", ((t) => e(t.detail)), { once: !0 })), t = new Promise((e) => this.#r.addEventListener("web-devices", ((t) => e(t.detail)), { once: !0 }));
+		await Promise.any([
+			e,
+			t,
+			((e) => new Promise((t) => setTimeout(() => t(), e)))(1e3)
+		]), this.mergeDevices(), this.emitDeviceChange();
+	}
+}();
+//#endregion
+export { g as outputDevices };

package/dist/pushkin-C7W2HCqN-BHqS8oLX.js

@@ -0,0 +1,117 @@
+import { a as e, c as t, s as n, t as r, u as i } from "./state-BT7sE_jc-iVaBwnBC.js";
+//#region ../player/dist/pushkin-C7W2HCqN.js
+var a = new class {
+	#e;
+	#t = !1;
+	#n;
+	#r;
+	constructor(e) {
+		this.#r = new URL(e), this.synchronize();
+	}
+	now(e = Date.now()) {
+		return !this.#n || !this.#e ? (console.warn("TrueTime is not yet synchronized"), e) : this.#n + (e - this.#e);
+	}
+	async synchronize() {
+		if (!(this.#e && Math.abs(Date.now() - this.#e) < 36e5 || this.#t)) {
+			this.#t = !0;
+			try {
+				let e = await fetch(this.#r);
+				e.ok && e.headers.has("date") && (this.#n = new Date(e.headers.get("date")).getTime(), this.#e = Date.now());
+			} catch (e) {
+				console.error(e);
+			}
+			this.#t = !1;
+		}
+	}
+	timestamp(e, t) {
+		let n;
+		if (t) {
+			if (n = performance.getEntriesByName(e).find((e) => "detail" in e && e.detail === t), !n) throw ReferenceError(`There is no performance entry named "${e}" with detail "${t}"`);
+		} else n = performance.getEntriesByName(e).pop();
+		return n ? n.startTime : void 0;
+	}
+}("https://api.tidal.com/v1/ping"), o = "streaming-privileges-revoked";
+function s(e) {
+	return new CustomEvent(o, { detail: e });
+}
+var c;
+async function l(e) {
+	let t = i("legacyApiUrl"), { url: n } = await (await fetch(t + "/rt/connect", {
+		headers: new Headers({
+			Authorization: "Bearer " + e,
+			"Content-Type": "application/json"
+		}),
+		method: "POST"
+	})).json();
+	return n;
+}
+function u(e) {
+	return new Promise((t) => {
+		e.addEventListener("open", () => t(), { once: !0 });
+	});
+}
+var d = class i {
+	#e;
+	#t;
+	#n;
+	#r;
+	constructor() {
+		this.#r = void 0, this.#t = this.#i(), e.addEventListener("user-action", () => {
+			this.connected && this.userAction().then().catch(console.error);
+		});
+	}
+	static async ensure() {
+		await n() && (c ? c.connected || await c.reconnect() : c = new i());
+	}
+	static async refresh() {
+		if (!await n()) return;
+		let e = await t();
+		c && e && c.reconnect().catch(console.error);
+	}
+	async #i() {
+		let e = await t();
+		if (!e) throw Error("No access token to connect to Pushkin.");
+		let n = await l(e);
+		n && (this.#r = new WebSocket(n), await u(this.#r), this.#n = ((e) => this.#s(e.data)), this.#e = () => this.#o(), this.#r.addEventListener("message", this.#n, !1), this.#r.addEventListener("closed", this.#e, !1), window.addEventListener("online", () => this.#o(), { once: !0 }));
+	}
+	async #a(e) {
+		if (!this.#r) throw Error("No socket connected. Did you forget to call connect method in Pushkin service first?");
+		this.#r.readyState !== WebSocket.OPEN && await this.#t, this.#r.send(JSON.stringify(e));
+	}
+	#o() {
+		this.#t = this.#i();
+	}
+	#s(t) {
+		let n = JSON.parse(t);
+		switch (n.type) {
+			case "PRIVILEGED_SESSION_NOTIFICATION":
+				e.dispatchEvent(s(String(n.payload.clientDisplayName))), r.activePlayer?.pause();
+				break;
+			case "RECONNECT":
+				this.reconnect().catch(console.error);
+				break;
+			default:
+				console.warn("Unhandled event from Pushkin: ", n);
+				break;
+		}
+	}
+	get connected() {
+		return this.#r && this.#r.readyState === WebSocket.OPEN;
+	}
+	reconnect() {
+		return this.#r ? (this.#n && this.#r.removeEventListener("message", this.#n), this.#e && this.#r.removeEventListener("closed", this.#e), this.#r.close(), this.#t = this.#i(), this.#t) : Promise.resolve();
+	}
+	async userAction() {
+		this.connected || await this.reconnect();
+		try {
+			await this.#a({
+				payload: { startedAt: a.now() },
+				type: "USER_ACTION"
+			});
+		} catch (e) {
+			console.error(e);
+		}
+	}
+};
+//#endregion
+export { d as n, a as t };

package/dist/pushkin-dg1sQNx0-CAPg-zq7.js

@@ -0,0 +1,2 @@
+import { n as e } from "./pushkin-C7W2HCqN-BHqS8oLX.js";
+export { e as Pushkin };