@videojs/soundcloud-audio 0.0.0-stage → 10.4.0

package/dist/default/adapter.js

@@ -0,0 +1,731 @@
+import { WIDGET_ORIGIN, createSoundCloudCommand, isSoundCloudProgress, loadedShareOf, parseSoundCloudMessage } from "./widget-api.js";
+import { buildSoundCloudWidgetUrl, parseSoundCloudSource as parseSoundCloudSource$1, wantsSoundCloudAutoplay } from "./source.js";
+import { MediaError, NO_TIME_RANGES_YET } from "@videojs/media";
+import { MediaPlayedRangesMixin, createTimeRange } from "@videojs/media/dom";
+import { tryCall } from "@videojs/utils/function";
+import { clamp } from "@videojs/utils/number";
+import { deepEqual } from "@videojs/utils/object";
+import { isNumber, isObject, isString, isUndefined } from "@videojs/utils/predicate";
+//#region src/adapter.ts
+/**
+* Plays SoundCloud tracks and sets through the SoundCloud Widget. A set plays as one source: moving to another track
+* reports a new `duration` and restarts `currentTime`, and `ended` fires once the last track ends. The widget stays
+* visible and takes input, since it is what credits the uploader and SoundCloud; what it does is reported like anything
+* the host asked for.
+*
+* @fires sourcechange - Fired when `source` changes, either directly or by resolving a new `src`. Read `source` for the
+*   new value.
+* @fires contentdatachange - Fired when the widget reports the title and artwork of a track, and when they are cleared.
+*   Read `contentData` for them.
+*/
+var SoundCloudAdapter = class SoundCloudAdapter extends MediaPlayedRangesMixin(EventTarget) {
+	static {
+		this.defaultProps = {
+			src: "",
+			autoplay: false,
+			defaultMuted: false,
+			muted: false,
+			loop: false,
+			controls: false,
+			playsInline: true,
+			preload: "metadata",
+			poster: "",
+			source: null
+		};
+	}
+	static {
+		this.PLAYER_SOFTWARE_NAME = "soundcloud-audio";
+	}
+	#target = null;
+	#listeners = null;
+	#attachId = 0;
+	#loadId = 0;
+	#adoptedSrc = null;
+	#src = SoundCloudAdapter.defaultProps.src;
+	#autoplay = SoundCloudAdapter.defaultProps.autoplay;
+	#defaultMuted = SoundCloudAdapter.defaultProps.defaultMuted;
+	#loop = SoundCloudAdapter.defaultProps.loop;
+	#controls = SoundCloudAdapter.defaultProps.controls;
+	#playsInline = SoundCloudAdapter.defaultProps.playsInline;
+	#preload = SoundCloudAdapter.defaultProps.preload;
+	#poster = SoundCloudAdapter.defaultProps.poster;
+	#source = SoundCloudAdapter.defaultProps.source;
+	#parsed = null;
+	#frameLoaded = true;
+	#widgetId = null;
+	#navigatedAt = 0;
+	#staleWidgetId = null;
+	#ready = false;
+	#requests = /* @__PURE__ */ new Map();
+	#playRequested = false;
+	#autoplayPending = false;
+	#startTime = null;
+	#soundIds = [];
+	#soundId = null;
+	#finished = false;
+	#awaitingProgress = false;
+	#playFrom = 0;
+	#reportedTime = 0;
+	#endTimer;
+	#durationTimer;
+	#seekTimer;
+	#paused = true;
+	#ended = false;
+	#seeking = false;
+	#currentTime = 0;
+	#duration = NaN;
+	#bufferedStart = 0;
+	#bufferedEnd = 0;
+	#volume = 1;
+	#muted = false;
+	#readyState = READY_STATE_HAVE_NOTHING;
+	#error = null;
+	#contentData = {};
+	/** The widget's window, which commands are posted to. Null until rendered. */
+	get engine() {
+		return this.#target?.contentWindow ?? null;
+	}
+	get target() {
+		return this.#target;
+	}
+	/** Bind the iframe hosting the widget. The widget follows once a `src` resolves, which may be after attach. */
+	attach(target) {
+		if (!target || this.#target === target) return;
+		if (this.#target) this.detach();
+		this.#target = target;
+		this.#listen(target);
+		this.#createPlayer(target);
+	}
+	detach() {
+		if (!this.#target) return;
+		this.#attachId++;
+		this.#loadId++;
+		this.#listeners?.abort();
+		this.#listeners = null;
+		this.#target = null;
+		this.#adoptedSrc = null;
+		this.#playRequested = false;
+		this.#resetState();
+	}
+	destroy() {
+		this.detach();
+		super.destroy();
+	}
+	get src() {
+		return this.#src;
+	}
+	/** SoundCloud URL. Setting it re-derives `source`, carrying its engine options over. */
+	set src(value) {
+		const { engine } = this.#source ?? {};
+		const next = {
+			...engine && { engine },
+			...value && { src: value }
+		};
+		this.source = Object.keys(next).length > 0 ? next : null;
+	}
+	get currentSrc() {
+		return this.#target?.getAttribute("src") ?? "";
+	}
+	get readyState() {
+		return this.#readyState;
+	}
+	/** Point the widget at the current source; rewriting the iframe URL is the only load the widget takes parameters on. */
+	async load() {
+		if (!this.#target) return;
+		const loadId = ++this.#loadId;
+		await Promise.resolve();
+		const target = this.#target;
+		if (loadId !== this.#loadId || !target) return;
+		const adopted = this.#adoptedSrc;
+		this.#adoptedSrc = null;
+		if (adopted && adopted === this.#buildWidgetUrl() && this.#hasReferrerPolicy(target)) {
+			this.#parsed = parseSoundCloudSource$1(this.#src);
+			this.#startTime = this.#parsed?.startTime ?? null;
+			this.#autoplayPending = true;
+			return;
+		}
+		this.#resetState();
+		this.dispatchEvent(new Event("emptied"));
+		this.#loadWidget(target);
+	}
+	get paused() {
+		return this.#paused;
+	}
+	get ended() {
+		return this.#ended;
+	}
+	get seeking() {
+		return this.#seeking;
+	}
+	async play() {
+		if (!this.#src || this.#error) return;
+		if (!this.#ready) {
+			this.#playRequested = true;
+			return;
+		}
+		if (this.#ended && this.#soundIds.length > 1 && this.#soundId !== this.#soundIds[0]) this.#post("skip", 0);
+		else this.#post("play");
+	}
+	pause() {
+		this.#playRequested = false;
+		this.#autoplayPending = false;
+		if (this.#ready) this.#post("pause");
+	}
+	get currentTime() {
+		return this.#currentTime;
+	}
+	set currentTime(value) {
+		const time = this.#clampTime(value);
+		if (!this.#ready && (!this.#src || this.#error)) {
+			this.#currentTime = time;
+			return;
+		}
+		if (time === this.#currentTime && !this.#ended) return;
+		this.#finished = false;
+		this.#ended = false;
+		this.#seeking = true;
+		this.#currentTime = time;
+		this.#reportedTime = time;
+		this.dispatchEvent(new Event("seeking"));
+		this.dispatchEvent(new Event("timeupdate"));
+		if (this.#ready) this.#seek(time);
+	}
+	get duration() {
+		return this.#duration;
+	}
+	get volume() {
+		return this.#volume;
+	}
+	set volume(value) {
+		const volume = clamp(value, 0, 1);
+		if (volume === this.#volume) return;
+		this.#volume = volume;
+		this.dispatchEvent(new Event("volumechange"));
+		if (!this.#muted) this.#applyVolume();
+	}
+	get muted() {
+		return this.#muted;
+	}
+	set muted(value) {
+		if (this.#muted === value) return;
+		this.#muted = value;
+		this.dispatchEvent(new Event("volumechange"));
+		this.#applyVolume();
+	}
+	/** Starts playback once the widget is ready, after the volume and start position apply. Browsers may refuse it. */
+	get autoplay() {
+		return this.#autoplay;
+	}
+	set autoplay(value) {
+		this.#autoplay = value;
+	}
+	get defaultMuted() {
+		return this.#defaultMuted;
+	}
+	set defaultMuted(value) {
+		this.#defaultMuted = value;
+		if (!this.#ready) this.#muted = value;
+	}
+	/** Replays the track, or a set from its first track, when the last one ends. */
+	get loop() {
+		return this.#loop;
+	}
+	set loop(value) {
+		this.#loop = value;
+	}
+	get controls() {
+		return this.#controls;
+	}
+	set controls(value) {
+		this.#controls = value;
+	}
+	get playsInline() {
+		return this.#playsInline;
+	}
+	set playsInline(value) {
+		this.#playsInline = value;
+	}
+	get preload() {
+		return this.#preload;
+	}
+	set preload(value) {
+		this.#preload = value;
+	}
+	get poster() {
+		return this.#poster;
+	}
+	set poster(value) {
+		this.#poster = value;
+	}
+	/** SoundCloud URL in `src`, widget parameters under `engine.soundcloud`. Replacing it re-derives `src`. */
+	get source() {
+		return this.#source;
+	}
+	set source(value) {
+		const source = value ?? null;
+		if (source === this.#source) return;
+		const src = source?.src ?? "";
+		const srcChanged = this.#src !== src;
+		const engineChanged = !deepEqual(this.#source?.engine?.soundcloud ?? null, source?.engine?.soundcloud ?? null);
+		this.#source = source;
+		this.#src = src;
+		if (srcChanged || engineChanged) this.load();
+		this.dispatchEvent(new Event("sourcechange"));
+	}
+	/** The stretch the widget reports loaded, from where playback last started or landed. */
+	get buffered() {
+		return this.#bufferedEnd > this.#bufferedStart ? createTimeRange(this.#bufferedStart, this.#bufferedEnd) : NO_TIME_RANGES_YET;
+	}
+	get seekable() {
+		return this.#duration > 0 && Number.isFinite(this.#duration) ? createTimeRange(0, this.#duration) : NO_TIME_RANGES_YET;
+	}
+	get error() {
+		return this.#error;
+	}
+	/**
+	* The `title` and `poster` of the track playing, which change with each track of a set. Empty until the widget
+	* reports them, and again across a source change. `contentdatachange` announces both.
+	*/
+	get contentData() {
+		return this.#contentData;
+	}
+	/** Unsupported: SoundCloud has no captions or other text tracks. */
+	get textTracks() {}
+	#createPlayer(target) {
+		const rendered = target.getAttribute("src");
+		if (!rendered) {
+			if (this.#src) this.#loadWidget(target);
+			return;
+		}
+		this.#frameLoaded = hasWidgetDocument(target);
+		this.#navigatedAt = 0;
+		this.#staleWidgetId = null;
+		this.dispatchEvent(new Event("loadstart"));
+		this.#probeReady();
+		this.#adoptedSrc = rendered;
+		if (this.#src) this.load();
+	}
+	#loadWidget(target) {
+		const parsed = parseSoundCloudSource$1(this.#src);
+		this.#parsed = parsed;
+		this.#startTime = parsed?.startTime ?? null;
+		if (!this.#src) {
+			target.removeAttribute("src");
+			return;
+		}
+		this.#autoplayPending = true;
+		this.dispatchEvent(new Event("loadstart"));
+		if (!parsed) {
+			target.removeAttribute("src");
+			this.#fail(new MediaError(`Unrecognized SoundCloud source: ${this.#src}`, MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED));
+			return;
+		}
+		this.#navigate(target, buildSoundCloudWidgetUrl(parsed.url, parsed, this.#snapshotProps()));
+	}
+	#navigate(target, url) {
+		const referrerPolicy = this.#source?.engine?.soundcloud?.referrerPolicy;
+		if (referrerPolicy !== void 0) target.referrerPolicy = referrerPolicy;
+		this.#frameLoaded = false;
+		this.#navigatedAt = Date.now();
+		target.src = url;
+	}
+	#hasReferrerPolicy(target) {
+		const referrerPolicy = this.#source?.engine?.soundcloud?.referrerPolicy;
+		return referrerPolicy === void 0 || target.referrerPolicy === referrerPolicy;
+	}
+	#buildWidgetUrl() {
+		const parsed = parseSoundCloudSource$1(this.#src);
+		if (!parsed) return "";
+		return buildSoundCloudWidgetUrl(parsed.url, parsed, this.#snapshotProps());
+	}
+	#listen(target) {
+		const win = globalThis.window;
+		if (isUndefined(win)) return;
+		const attachId = this.#attachId;
+		this.#listeners = new AbortController();
+		const { signal } = this.#listeners;
+		win.addEventListener("message", (event) => this.#onMessage(event, target, attachId), { signal });
+		target.addEventListener("load", () => {
+			this.#frameLoaded = hasWidgetDocument(target);
+			if (!this.#ready) this.#probeReady();
+		}, { signal });
+	}
+	#onMessage(event, target, attachId) {
+		if (attachId !== this.#attachId || event.origin !== "https://w.soundcloud.com") return;
+		const frame = target.contentWindow;
+		if (!frame || event.source !== frame) return;
+		const message = parseSoundCloudMessage(event.data);
+		if (!message) return;
+		const { method, value, widgetId = null } = message;
+		if (!this.#ready) {
+			if ((method === "ready" || method === READY_PROBE && this.#frameLoaded) && this.#isCurrentDocument(widgetId)) this.#onReady(widgetId);
+			return;
+		}
+		if (method === "ready" && widgetId !== this.#widgetId && this.#isCurrentDocument(widgetId)) {
+			this.#onFrameReloaded(widgetId);
+			return;
+		}
+		if (widgetId !== this.#widgetId) return;
+		const answer = this.#requests.get(method)?.shift();
+		if (answer) {
+			answer(value);
+			return;
+		}
+		switch (method) {
+			case "play":
+				if (isSoundCloudProgress(value)) this.#onWidgetPlay(value);
+				break;
+			case "pause":
+				if (isSoundCloudProgress(value)) this.#onWidgetPause(value);
+				break;
+			case "finish":
+				if (isSoundCloudProgress(value)) this.#onWidgetFinish(value);
+				break;
+			case "seek":
+				if (isSoundCloudProgress(value)) this.#onWidgetSeek(value);
+				break;
+			case "playProgress":
+				if (isSoundCloudProgress(value)) this.#onWidgetProgress(value);
+				break;
+			case "loadProgress":
+				if (isSoundCloudProgress(value)) this.#syncBuffered(value);
+				break;
+			case "error": this.#onWidgetError();
+		}
+	}
+	#onReady(widgetId) {
+		this.#ready = true;
+		this.#widgetId = widgetId;
+		for (const type of SUBSCRIBED_EVENTS) this.#post("addEventListener", type);
+		this.#get("getSounds").then((sounds) => {
+			this.#soundIds = Array.isArray(sounds) ? sounds.map(soundIdOf).filter(isNumber) : [];
+		});
+		this.#get("getCurrentSound").then((sound) => {
+			this.#soundId = soundIdOf(sound) ?? null;
+			this.#setContentData(sound);
+		});
+		this.#get("getDuration").then((duration) => this.#onLoaded(duration));
+	}
+	#onFrameReloaded(widgetId) {
+		this.#resetState();
+		this.#startTime = this.#parsed?.startTime ?? null;
+		this.dispatchEvent(new Event("emptied"));
+		this.dispatchEvent(new Event("loadstart"));
+		this.#onReady(widgetId);
+	}
+	#onLoaded(duration, attempt = 1) {
+		if (this.#error) return;
+		if (!isNumber(duration) || !(duration > 0)) {
+			if (attempt >= DURATION_ATTEMPTS) {
+				this.#fail(new MediaError("The SoundCloud widget did not finish loading in time.", MediaError.MEDIA_ERR_NETWORK));
+				return;
+			}
+			const widgetId = this.#widgetId;
+			this.#durationTimer = setTimeout(() => {
+				if (this.#ready && this.#widgetId === widgetId) this.#get("getDuration").then((next) => this.#onLoaded(next, attempt + 1));
+			}, DURATION_RETRY_INTERVAL);
+			return;
+		}
+		this.#applyDuration(duration / 1e3);
+		this.#readyState = READY_STATE_HAVE_ENOUGH_DATA;
+		for (const type of [
+			"loadedmetadata",
+			"loadeddata",
+			"canplay",
+			"canplaythrough",
+			"loadcomplete"
+		]) this.dispatchEvent(new Event(type));
+		this.#syncToWidget();
+		this.#get("isPaused").then((paused) => {
+			if (paused === false && this.#paused) this.#onWidgetPlay({ currentPosition: this.#currentTime * 1e3 });
+		});
+	}
+	#syncToWidget() {
+		this.#applyVolume();
+		if (this.#seeking) {
+			this.#currentTime = this.#clampTime(this.#currentTime);
+			this.#seek(this.#currentTime);
+		} else if (isNumber(this.#startTime) && this.#startTime > 0) this.currentTime = this.#startTime;
+		const autoplay = this.#autoplayPending && (this.#autoplay || wantsSoundCloudAutoplay(this.#parsed, this.#source));
+		if (this.#playRequested || autoplay) this.#post("play");
+		this.#playRequested = false;
+		this.#autoplayPending = false;
+	}
+	#onWidgetPlay(progress) {
+		this.#syncSound(progress);
+		this.#finished = false;
+		clearTimeout(this.#endTimer);
+		if (!this.#paused) return;
+		const position = (progress.currentPosition ?? 0) / 1e3;
+		const loaded = (loadedShareOf(progress) ?? 0) * this.#duration;
+		this.#paused = false;
+		this.#ended = false;
+		this.dispatchEvent(new Event("play"));
+		if (loaded > position + STARVED_MARGIN) {
+			this.dispatchEvent(new Event("playing"));
+			return;
+		}
+		this.#awaitingProgress = true;
+		this.#playFrom = position;
+		this.#readyState = READY_STATE_HAVE_CURRENT_DATA;
+		this.dispatchEvent(new Event("waiting"));
+	}
+	#onWidgetPause(progress) {
+		this.#syncSound(progress);
+		if (this.#isAtEnd(progress)) {
+			clearTimeout(this.#endTimer);
+			this.#endTimer = setTimeout(() => this.#onPause(), END_GRACE);
+			return;
+		}
+		this.#onPause();
+	}
+	#onWidgetFinish(progress) {
+		clearTimeout(this.#endTimer);
+		this.#syncSound(progress);
+		const index = this.#soundId === null ? -1 : this.#soundIds.indexOf(this.#soundId);
+		if (!(this.#soundIds.length === 0 || index === this.#soundIds.length - 1)) {
+			this.#endTimer = setTimeout(() => this.#end(), END_GRACE);
+			return;
+		}
+		if (!this.#loop) {
+			this.#end();
+			return;
+		}
+		this.#applyCurrentTime(0, true);
+		if (this.#soundIds.length > 1) this.#post("skip", 0);
+		else this.#post("play");
+		this.#endTimer = setTimeout(() => this.#end(), END_GRACE);
+	}
+	#onWidgetSeek(progress) {
+		this.#syncSound(progress);
+		if (this.#finished) return;
+		const time = this.#clampTime((progress.currentPosition ?? 0) / 1e3);
+		this.#setBuffered(time, this.#loadedEnd(progress) ?? this.#bufferedEnd);
+		if (this.#seeking) {
+			this.#settleSeek(time);
+			return;
+		}
+		if (Math.abs(time - this.#currentTime) < SEEK_TOLERANCE) return;
+		this.#ended = false;
+		this.#seeking = true;
+		this.dispatchEvent(new Event("seeking"));
+		this.#settleSeek(time);
+	}
+	#onWidgetProgress(progress) {
+		this.#syncSound(progress);
+		if (this.#finished) return;
+		this.#syncBuffered(progress);
+		if (this.#seeking) return;
+		const time = (progress.currentPosition ?? 0) / 1e3;
+		this.#applyCurrentTime(time);
+		if (this.#awaitingProgress && !this.#paused && time > this.#playFrom) {
+			this.#awaitingProgress = false;
+			this.#readyState = READY_STATE_HAVE_ENOUGH_DATA;
+			this.dispatchEvent(new Event("playing"));
+		}
+	}
+	#onWidgetError() {
+		if (this.#readyState < READY_STATE_HAVE_METADATA) {
+			this.#fail(new MediaError(`SoundCloud could not play ${this.#src}. It may be private, removed, or not available in this region.`, MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED));
+			this.#onPause();
+			return;
+		}
+		const error = new MediaError("The SoundCloud widget reported an error.", MediaError.MEDIA_ERR_CUSTOM, false);
+		this.dispatchEvent(new ErrorEvent("error", {
+			error,
+			message: error.message
+		}));
+		this.#get("isPaused").then((paused) => {
+			if (paused === true) this.#onPause();
+		});
+	}
+	#syncSound({ soundId }) {
+		if (!isNumber(soundId) || soundId === this.#soundId) return;
+		const changed = this.#soundId !== null;
+		this.#soundId = soundId;
+		if (!changed) return;
+		clearTimeout(this.#endTimer);
+		this.#finished = false;
+		this.#ended = false;
+		this.#setBuffered(0, 0);
+		this.#applyCurrentTime(0, true);
+		this.#get("getDuration").then((duration) => {
+			if (isNumber(duration) && duration > 0) this.#applyDuration(duration / 1e3);
+		});
+		this.#get("getCurrentSound").then((sound) => {
+			if (soundIdOf(sound) === this.#soundId) this.#setContentData(sound);
+		});
+	}
+	#end() {
+		clearTimeout(this.#endTimer);
+		this.#finished = true;
+		this.#applyCurrentTime(this.#duration, true);
+		this.#onPause();
+		this.#ended = true;
+		this.dispatchEvent(new Event("ended"));
+	}
+	#onPause() {
+		clearTimeout(this.#endTimer);
+		this.#awaitingProgress = false;
+		if (this.#paused) return;
+		this.#paused = true;
+		this.dispatchEvent(new Event("pause"));
+	}
+	#seek(time) {
+		this.#post("seekTo", Math.round(time * 1e3));
+		clearTimeout(this.#seekTimer);
+		this.#seekTimer = setTimeout(() => {
+			this.#get("getPosition").then((position) => {
+				if (this.#seeking && isNumber(position)) this.#settleSeek(this.#clampTime(position / 1e3));
+			});
+		}, SEEK_SETTLE_TIMEOUT);
+	}
+	#settleSeek(time) {
+		clearTimeout(this.#seekTimer);
+		this.#applyCurrentTime(time, true);
+		this.#seeking = false;
+		this.dispatchEvent(new Event("seeked"));
+	}
+	#applyVolume() {
+		if (!this.#ready) return;
+		this.#post("setVolume", this.#muted ? 0 : Math.round(this.#volume * 100));
+	}
+	#applyDuration(duration) {
+		if (duration === this.#duration) return;
+		this.#duration = duration;
+		this.dispatchEvent(new Event("durationchange"));
+	}
+	#applyCurrentTime(time, force = false) {
+		const clamped = this.#clampTime(time);
+		if (clamped === this.#currentTime) return;
+		this.#currentTime = clamped;
+		if (!force && Math.abs(clamped - this.#reportedTime) < TIMEUPDATE_INTERVAL) return;
+		this.#reportedTime = clamped;
+		this.dispatchEvent(new Event("timeupdate"));
+	}
+	#syncBuffered(progress) {
+		const end = this.#loadedEnd(progress);
+		if (!isUndefined(end)) this.#setBuffered(this.#bufferedStart, end);
+	}
+	#loadedEnd(progress) {
+		const share = loadedShareOf(progress);
+		return isUndefined(share) || !Number.isFinite(this.#duration) ? void 0 : clamp(share, 0, 1) * this.#duration;
+	}
+	#setBuffered(start, end) {
+		if (start === this.#bufferedStart && end === this.#bufferedEnd) return;
+		this.#bufferedStart = start;
+		this.#bufferedEnd = end;
+		this.dispatchEvent(new Event("progress"));
+	}
+	#clampTime(time) {
+		const max = Number.isFinite(this.#duration) ? this.#duration : Number.POSITIVE_INFINITY;
+		return clamp(Number.isFinite(time) ? time : 0, 0, max);
+	}
+	#isAtEnd({ currentPosition }) {
+		return Number.isFinite(this.#duration) && this.#duration - (currentPosition ?? 0) / 1e3 <= END_TOLERANCE;
+	}
+	#setContentData(sound) {
+		const contentData = contentDataOf(sound);
+		if (deepEqual(contentData, this.#contentData)) return;
+		this.#contentData = contentData;
+		this.dispatchEvent(new Event("contentdatachange"));
+	}
+	#fail(error) {
+		this.#error = error;
+		this.dispatchEvent(new Event("error"));
+	}
+	#get(method) {
+		if (!this.#ready) return Promise.resolve(void 0);
+		return new Promise((resolve) => {
+			const queue = this.#requests.get(method) ?? [];
+			queue.push(resolve);
+			this.#requests.set(method, queue);
+			this.#post(method);
+		});
+	}
+	#isCurrentDocument(widgetId) {
+		if (widgetId === null) return true;
+		const createdAt = Number(WIDGET_CREATED_AT.exec(widgetId)?.[1]);
+		return Number.isFinite(createdAt) ? createdAt >= this.#navigatedAt : widgetId !== this.#staleWidgetId;
+	}
+	#probeReady() {
+		if (this.#frameLoaded) this.#post(READY_PROBE);
+	}
+	#post(method, value) {
+		const frame = this.#target?.contentWindow;
+		if (!frame) return;
+		tryCall(() => frame.postMessage(createSoundCloudCommand(method, value), WIDGET_ORIGIN));
+	}
+	#snapshotProps() {
+		return { source: this.#source };
+	}
+	#resetState() {
+		clearTimeout(this.#endTimer);
+		clearTimeout(this.#seekTimer);
+		clearTimeout(this.#durationTimer);
+		this.#staleWidgetId = this.#widgetId ?? this.#staleWidgetId;
+		this.#widgetId = null;
+		this.#ready = false;
+		this.#requests.clear();
+		this.#autoplayPending = false;
+		this.#startTime = null;
+		this.#soundIds = [];
+		this.#soundId = null;
+		this.#finished = false;
+		this.#awaitingProgress = false;
+		this.#playFrom = 0;
+		this.#reportedTime = 0;
+		this.#paused = true;
+		this.#ended = false;
+		this.#seeking = false;
+		this.#currentTime = 0;
+		this.#duration = NaN;
+		this.#bufferedStart = 0;
+		this.#bufferedEnd = 0;
+		this.#readyState = READY_STATE_HAVE_NOTHING;
+		this.#error = null;
+		this.#setContentData(null);
+	}
+};
+function hasWidgetDocument(target) {
+	return !!target.getAttribute("src") && target.contentDocument === null;
+}
+function soundIdOf(sound) {
+	const id = isObject(sound) ? sound.id : void 0;
+	return isNumber(id) ? id : isString(id) && /^\d+$/.test(id) ? Number(id) : void 0;
+}
+function contentDataOf(sound) {
+	if (!isObject(sound)) return {};
+	const { title, artwork_url: artwork, user } = sound;
+	const image = isString(artwork) && artwork ? artwork : user?.avatar_url;
+	return {
+		...isString(title) && title && { title },
+		...isString(image) && image && { poster: image.replace(ARTWORK_SIZE, "-t500x500.") }
+	};
+}
+const ARTWORK_SIZE = /-large\.(?=[a-z]+$)/;
+const SUBSCRIBED_EVENTS = [
+	"play",
+	"pause",
+	"finish",
+	"seek",
+	"playProgress",
+	"loadProgress",
+	"error"
+];
+const WIDGET_CREATED_AT = /^widget_(\d+)$/;
+const READY_PROBE = "getCurrentSoundIndex";
+const END_TOLERANCE = .5;
+const END_GRACE = 1500;
+const SEEK_TOLERANCE = .05;
+const STARVED_MARGIN = .5;
+const SEEK_SETTLE_TIMEOUT = 2e3;
+const DURATION_ATTEMPTS = 20;
+const DURATION_RETRY_INTERVAL = 250;
+const TIMEUPDATE_INTERVAL = .25;
+const READY_STATE_HAVE_NOTHING = 0;
+const READY_STATE_HAVE_METADATA = 1;
+const READY_STATE_HAVE_CURRENT_DATA = 2;
+const READY_STATE_HAVE_ENOUGH_DATA = 4;
+//#endregion
+export { SoundCloudAdapter };