@videojs/html 10.0.0-beta.21 → 10.0.0-beta.22

package/cdn/{mux-B5K6kOzg.js → mux-BhHIeG3e.js}

@@ -1,9 +1,720 @@
-import { n as Hls, t as HlsMedia } from "./hls-BotloEPN.js";
+import { n as Hls, t as HlsMedia } from "./hls-CcSAx_3I.js";
 
+//#region ../core/dist/dev/dom/media/castable/utils.js
+var InvalidStateError = class extends Error {};
+var NotSupportedError = class extends Error {};
+var NotFoundError = class extends Error {};
+const HLS_RESPONSE_HEADERS = [
+	"application/x-mpegURL",
+	"application/vnd.apple.mpegurl",
+	"audio/mpegurl"
+];
+var IterableWeakSet = class {
+	#refs = /* @__PURE__ */ new Set();
+	#seen = /* @__PURE__ */ new WeakMap();
+	add(value) {
+		if (this.#seen.has(value)) return this;
+		const ref = new WeakRef(value);
+		this.#seen.set(value, ref);
+		this.#refs.add(ref);
+		return this;
+	}
+	delete(value) {
+		const ref = this.#seen.get(value);
+		if (!ref) return false;
+		this.#seen.delete(value);
+		return this.#refs.delete(ref);
+	}
+	forEach(fn) {
+		for (const ref of this.#refs) {
+			const value = ref.deref();
+			if (value) fn(value);
+			else this.#refs.delete(ref);
+		}
+	}
+};
+function onCastApiAvailable(callback) {
+	const whenDefined = () => customElements.whenDefined("google-cast-button").then(callback);
+	if (!globalThis.chrome?.cast?.isAvailable) globalThis.__onGCastApiAvailable = whenDefined;
+	else if (typeof cast === "undefined" || !cast.framework) whenDefined();
+	else callback();
+}
+function requiresCastFramework() {
+	return Boolean(globalThis.chrome);
+}
+function loadCastFramework() {
+	const sdkUrl = "https://www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1";
+	if (globalThis.chrome?.cast || document.querySelector(`script[src="${sdkUrl}"]`)) return;
+	const script = document.createElement("script");
+	script.src = sdkUrl;
+	document.head.append(script);
+}
+function castContext() {
+	return typeof cast === "undefined" ? void 0 : cast.framework?.CastContext.getInstance();
+}
+function currentSession() {
+	return castContext()?.getCurrentSession();
+}
+function currentMedia() {
+	return currentSession()?.getSessionObj().media[0] ?? void 0;
+}
+function editTracksInfo(request) {
+	return new Promise((resolve, reject) => {
+		currentMedia().editTracksInfo(request, resolve, reject);
+	});
+}
+function getMediaStatus(request) {
+	return new Promise((resolve, reject) => {
+		currentMedia().getStatus(request, resolve, reject);
+	});
+}
+const MEDIA_NAMESPACE = "urn:x-cast:com.google.cast.media";
+let requestId = 0;
+function setPlaybackRate(rate) {
+	const media = currentMedia();
+	return currentSession().sendMessage(MEDIA_NAMESPACE, {
+		type: "SET_PLAYBACK_RATE",
+		playbackRate: rate,
+		mediaSessionId: media?.mediaSessionId,
+		requestId: ++requestId
+	});
+}
+function setCastOptions(options) {
+	castContext().setOptions({
+		...getDefaultCastOptions(),
+		...options
+	});
+}
+function getDefaultCastOptions() {
+	return {
+		receiverApplicationId: "CC1AD845",
+		autoJoinPolicy: globalThis.chrome?.cast?.AutoJoinPolicy?.ORIGIN_SCOPED ?? "origin_scoped",
+		androidReceiverCompatible: false,
+		language: "en-US",
+		resumeSavedSession: true
+	};
+}
+function getFormat(segment) {
+	if (!segment) return void 0;
+	const match = segment.match(/\.([a-zA-Z0-9]+)(?:\?.*)?$/);
+	return match ? match[1] : null;
+}
+function parsePlaylistUrls(playlistContent) {
+	const lines = playlistContent.split("\n");
+	const urls = [];
+	for (let i = 0; i < lines.length; i++) if (lines[i].trim().startsWith("#EXT-X-STREAM-INF")) {
+		const nextLine = lines[i + 1] ? lines[i + 1].trim() : "";
+		if (nextLine && !nextLine.startsWith("#")) urls.push(nextLine);
+	}
+	return urls;
+}
+function parseSegment(playlistContent) {
+	return playlistContent.split("\n").find((line) => !line.trim().startsWith("#") && line.trim() !== "");
+}
+async function isHls(url) {
+	if (!url) return false;
+	if (/\.m3u8?(\?.*)?$/i.test(url)) return true;
+	if (url.startsWith("blob:")) return false;
+	try {
+		const contentType = (await fetch(url, { method: "HEAD" })).headers.get("Content-Type");
+		if (!contentType) return false;
+		const normalizedContentType = contentType.toLowerCase().split(";")[0].trim();
+		return HLS_RESPONSE_HEADERS.some((header) => normalizedContentType === header.toLowerCase());
+	} catch (err) {
+		console.error("Error while trying to get the Content-Type of the manifest", err);
+		return false;
+	}
+}
+async function getPlaylistSegmentFormat(url) {
+	try {
+		const mainManifestContent = await (await fetch(url)).text();
+		let availableChunksContent = mainManifestContent;
+		const playlists = parsePlaylistUrls(mainManifestContent);
+		if (playlists.length > 0) {
+			const chosenPlaylistUrl = new URL(playlists[0], url).toString();
+			availableChunksContent = await (await fetch(chosenPlaylistUrl)).text();
+		}
+		return getFormat(parseSegment(availableChunksContent));
+	} catch (err) {
+		console.error("Error while trying to parse the manifest playlist", err);
+		return;
+	}
+}
+
+//#endregion
+//#region ../core/dist/dev/dom/media/castable/google-cast-provider.js
+const providerInstances = new IterableWeakSet();
+const castElementRef = /* @__PURE__ */ new WeakSet();
+let cf;
+onCastApiAvailable(() => {
+	if (!globalThis.chrome?.cast?.isAvailable) {
+		console.debug("chrome.cast.isAvailable", globalThis.chrome?.cast?.isAvailable);
+		return;
+	}
+	if (!cf) {
+		cf = cast.framework;
+		castContext().addEventListener(cf.CastContextEventType.CAST_STATE_CHANGED, () => {
+			providerInstances.forEach((p) => p.onCastStateChanged());
+		});
+		castContext().addEventListener(cf.CastContextEventType.SESSION_STATE_CHANGED, () => {
+			providerInstances.forEach((p) => p.onSessionStateChanged());
+		});
+		providerInstances.forEach((p) => p.init());
+	}
+});
+var GoogleCastProvider = class {
+	media;
+	seeking = false;
+	#hooks = {};
+	#isInit = false;
+	#local;
+	#remote;
+	#remoteListeners;
+	#listenersAttached = false;
+	#playbackRate = 1;
+	#localPaused = false;
+	#onTextTrackChange = () => this.#updateRemoteTextTrack();
+	#onMediaUpdate = () => this.#checkPlaybackRate();
+	constructor(media, local) {
+		this.media = media;
+		this.#local = local;
+		providerInstances.add(this);
+		this.init();
+	}
+	bindHooks(hooks) {
+		Object.assign(this.#hooks, hooks);
+	}
+	get isCasting() {
+		return castElementRef.has(this.media);
+	}
+	set isCasting(value) {
+		if (value) castElementRef.add(this.media);
+		else castElementRef.delete(this.media);
+	}
+	hasDevicesAvailable() {
+		const state = castContext()?.getCastState();
+		return !!state && state !== cast.framework.CastState.NO_DEVICES_AVAILABLE;
+	}
+	async requestCastSession() {
+		if (!this.#isCastApiAvailable()) throw new NotSupportedError("The RemotePlayback API is disabled on this platform.");
+		const willDisconnect = this.isCasting;
+		this.isCasting = true;
+		this.#applyCastOptions();
+		this.#attachRemoteListeners();
+		try {
+			await castContext().requestSession();
+		} catch (err) {
+			if (!willDisconnect) this.isCasting = false;
+			if (err === "cancel") return;
+			throw new Error(err);
+		}
+		this.#localPaused = this.#local.paused();
+		this.#local.pause();
+		this.muted = this.#local.muted();
+		try {
+			await this.load();
+		} catch (err) {
+			console.error(err);
+		}
+	}
+	async load() {
+		const mediaInfo = new chrome.cast.media.MediaInfo(this.media.castSrc, this.media.castContentType ?? "");
+		mediaInfo.customData = this.media.castCustomData ?? null;
+		const subtitles = [...this.media.querySelectorAll("track")].filter((el) => el.src && (el.kind === "subtitles" || el.kind === "captions"));
+		const { Track, TrackType, TextTrackType } = chrome.cast.media;
+		const activeTrackIds = [];
+		if (subtitles.length) mediaInfo.tracks = subtitles.map((el, i) => {
+			const trackId = i + 1;
+			if (!activeTrackIds.length && el.track.mode === "showing") activeTrackIds.push(trackId);
+			const track = new Track(trackId, TrackType.TEXT);
+			track.trackContentId = el.src;
+			track.trackContentType = "text/vtt";
+			track.subtype = el.kind === "captions" ? TextTrackType.CAPTIONS : TextTrackType.SUBTITLES;
+			track.name = el.label;
+			track.language = el.srclang;
+			return track;
+		});
+		mediaInfo.streamType = this.media.castStreamType === "live" ? chrome.cast.media.StreamType.LIVE : chrome.cast.media.StreamType.BUFFERED;
+		mediaInfo.metadata = new chrome.cast.media.GenericMediaMetadata();
+		mediaInfo.metadata.title = this.media.title;
+		mediaInfo.metadata.images = [new chrome.cast.Image(this.media.poster)];
+		if (await isHls(this.media.castSrc)) {
+			mediaInfo.contentType ||= "application/x-mpegURL";
+			const fmt = await getPlaylistSegmentFormat(this.media.castSrc) ?? "";
+			const { HlsSegmentFormat: HS, HlsVideoSegmentFormat: HVS } = chrome.cast.media;
+			if (fmt.includes("m4s") || fmt.includes("mp4")) {
+				mediaInfo.hlsSegmentFormat = HS.FMP4;
+				mediaInfo.hlsVideoSegmentFormat = HVS.FMP4;
+			} else if (fmt.includes("ts")) {
+				mediaInfo.hlsSegmentFormat = HS.TS;
+				mediaInfo.hlsVideoSegmentFormat = HVS.TS;
+			}
+		}
+		const request = new chrome.cast.media.LoadRequest(mediaInfo);
+		request.currentTime = this.#local.currentTime();
+		request.autoplay = !this.#localPaused;
+		request.activeTrackIds = activeTrackIds;
+		await currentSession()?.loadMedia(request);
+		this.media.dispatchEvent(new Event("volumechange"));
+	}
+	async play() {
+		if (!this.#remote.isMediaLoaded) {
+			this.#localPaused = false;
+			await this.load();
+			return;
+		}
+		if (this.paused) {
+			this.#remote.controller?.playOrPause();
+			return new Promise((resolve) => {
+				this.media.addEventListener("play", () => resolve(), { once: true });
+			});
+		}
+	}
+	pause() {
+		if (!this.paused) this.#remote.controller?.playOrPause();
+	}
+	get paused() {
+		return this.#remote.isPaused || this.ended;
+	}
+	get ended() {
+		return this.#remote.playerState === chrome.cast.media.PlayerState.IDLE && currentMedia()?.idleReason === chrome.cast.media.IdleReason.FINISHED;
+	}
+	get muted() {
+		return this.#remote.isMuted;
+	}
+	set muted(value) {
+		if (value !== this.#remote.isMuted) this.#remote.controller?.muteOrUnmute();
+	}
+	get volume() {
+		return this.#remote.volumeLevel ?? 1;
+	}
+	set volume(value) {
+		this.#remote.volumeLevel = +value;
+		this.#remote.controller?.setVolumeLevel();
+	}
+	get playbackRate() {
+		return currentMedia()?.playbackRate ?? 1;
+	}
+	set playbackRate(value) {
+		setPlaybackRate(value);
+	}
+	get duration() {
+		if (this.#remote?.isMediaLoaded) return this.#remote.duration ?? NaN;
+		return this.#local.duration();
+	}
+	get currentTime() {
+		if (this.#remote?.isMediaLoaded) return this.#remote.currentTime ?? 0;
+		return this.#local.currentTime();
+	}
+	set currentTime(value) {
+		this.#remote.currentTime = value;
+		this.#notifySeeking();
+		this.#remote.controller?.seek();
+	}
+	get readyState() {
+		switch (this.#remote.playerState) {
+			case chrome.cast.media.PlayerState.IDLE: return 0;
+			case chrome.cast.media.PlayerState.BUFFERING: return 2;
+			default: return 3;
+		}
+	}
+	init() {
+		if (!cf || this.#isInit) return;
+		this.#isInit = true;
+		this.#applyCastOptions();
+		this.media.textTracks.addEventListener("change", this.#onTextTrackChange);
+		this.onCastStateChanged();
+		this.#remote = new cf.RemotePlayer();
+		new cf.RemotePlayerController(this.#remote);
+		this.#remoteListeners = {
+			[cf.RemotePlayerEventType.IS_CONNECTED_CHANGED]: (event) => {
+				if (event?.value === true) this.#hooks.setState?.("connected");
+				else {
+					this.#disconnect();
+					this.#hooks.setState?.("disconnected");
+				}
+			},
+			[cf.RemotePlayerEventType.DURATION_CHANGED]: () => {
+				this.media.dispatchEvent(new Event("durationchange"));
+			},
+			[cf.RemotePlayerEventType.VOLUME_LEVEL_CHANGED]: () => {
+				this.media.dispatchEvent(new Event("volumechange"));
+			},
+			[cf.RemotePlayerEventType.IS_MUTED_CHANGED]: () => {
+				this.media.dispatchEvent(new Event("volumechange"));
+			},
+			[cf.RemotePlayerEventType.CURRENT_TIME_CHANGED]: () => {
+				if (!this.isCasting || !this.#remote.isMediaLoaded) return;
+				this.#notifySeeked();
+				this.media.dispatchEvent(new Event("timeupdate"));
+			},
+			[cf.RemotePlayerEventType.VIDEO_INFO_CHANGED]: () => {
+				this.media.dispatchEvent(new Event("resize"));
+			},
+			[cf.RemotePlayerEventType.IS_PAUSED_CHANGED]: () => {
+				this.media.dispatchEvent(new Event(this.isCasting && this.#remote.isPaused ? "pause" : "play"));
+			},
+			[cf.RemotePlayerEventType.PLAYER_STATE_CHANGED]: () => {
+				const PS = chrome.cast.media.PlayerState;
+				const state = this.isCasting ? this.#remote.playerState : void 0;
+				if (state !== PS.BUFFERING) this.#notifySeeked();
+				if (state === PS.PAUSED) return;
+				if (state === PS.IDLE) {
+					const finished = currentMedia()?.idleReason === chrome.cast.media.IdleReason.FINISHED;
+					this.media.dispatchEvent(new Event(finished ? "ended" : "emptied"));
+					return;
+				}
+				if (state === PS.PLAYING) this.media.dispatchEvent(new Event("playing"));
+				else if (state === PS.BUFFERING) this.media.dispatchEvent(new Event("waiting"));
+			},
+			[cf.RemotePlayerEventType.IS_MEDIA_LOADED_CHANGED]: async () => {
+				if (!this.isCasting || !this.#remote.isMediaLoaded) return;
+				await Promise.resolve();
+				this.#onRemoteMediaLoaded();
+			}
+		};
+	}
+	onCastStateChanged() {
+		if (!this.#isInit) return;
+		const CS = cast.framework.CastState;
+		const state = castContext().getCastState();
+		if (this.isCasting && state === CS.CONNECTING) this.#hooks.setState?.("connecting");
+		this.#hooks.setAvailable?.(!!state && state !== CS.NO_DEVICES_AVAILABLE);
+	}
+	async onSessionStateChanged() {
+		if (!this.#isInit) return;
+		const { SESSION_RESUMED } = cf.SessionState;
+		if (castContext().getSessionState() === SESSION_RESUMED) {
+			if (this.media.castSrc === currentMedia()?.media?.contentId) {
+				castElementRef.add(this.media);
+				this.#attachRemoteListeners();
+				try {
+					await getMediaStatus(new chrome.cast.media.GetStatusRequest());
+				} catch (error) {
+					console.error(error);
+				}
+				this.#remoteListeners[cf.RemotePlayerEventType.IS_PAUSED_CHANGED]();
+				this.#remoteListeners[cf.RemotePlayerEventType.PLAYER_STATE_CHANGED]();
+				this.media.dispatchEvent(new Event("ratechange"));
+			}
+		}
+	}
+	destroy() {
+		providerInstances.delete(this);
+		currentMedia()?.removeUpdateListener(this.#onMediaUpdate);
+		this.media.textTracks?.removeEventListener("change", this.#onTextTrackChange);
+		this.#detachRemoteListeners();
+		this.isCasting = false;
+		this.#isInit = false;
+	}
+	#isCastApiAvailable() {
+		return Boolean(globalThis.chrome?.cast?.isAvailable);
+	}
+	#applyCastOptions() {
+		setCastOptions(this.media.castOptions);
+	}
+	#attachRemoteListeners() {
+		if (this.#listenersAttached) return;
+		const controller = this.#remote?.controller;
+		if (!controller) return;
+		for (const [type, handler] of Object.entries(this.#remoteListeners)) controller.addEventListener(type, handler);
+		this.#listenersAttached = true;
+	}
+	#detachRemoteListeners() {
+		if (!this.#listenersAttached) return;
+		const controller = this.#remote?.controller;
+		if (controller) for (const [type, handler] of Object.entries(this.#remoteListeners)) controller.removeEventListener(type, handler);
+		this.#listenersAttached = false;
+	}
+	#disconnect() {
+		if (!this.isCasting) return;
+		currentMedia()?.removeUpdateListener(this.#onMediaUpdate);
+		this.#detachRemoteListeners();
+		this.seeking = false;
+		this.#playbackRate = 1;
+		this.isCasting = false;
+		this.media.muted = this.#remote.isMuted;
+		const saved = this.#remote.savedPlayerState;
+		if (saved) {
+			this.media.currentTime = saved.currentTime;
+			if (saved.isPaused === false) this.media.play();
+		}
+	}
+	#notifySeeking() {
+		this.seeking = true;
+		this.media.dispatchEvent(new Event("seeking"));
+	}
+	#notifySeeked() {
+		if (!this.seeking) return;
+		this.seeking = false;
+		this.media.dispatchEvent(new Event("seeked"));
+	}
+	#onRemoteMediaLoaded() {
+		this.#playbackRate = currentMedia()?.playbackRate ?? 1;
+		currentMedia()?.addUpdateListener(this.#onMediaUpdate);
+		this.#updateRemoteTextTrack();
+	}
+	#checkPlaybackRate() {
+		const rate = currentMedia()?.playbackRate ?? 1;
+		if (rate !== this.#playbackRate) {
+			this.#playbackRate = rate;
+			this.media.dispatchEvent(new Event("ratechange"));
+		}
+	}
+	async #updateRemoteTextTrack() {
+		if (!this.isCasting) return;
+		const localSubs = [...this.media.textTracks].filter(({ kind }) => kind === "subtitles" || kind === "captions");
+		const matched = (this.#remote.mediaInfo?.tracks ?? []).filter(({ type }) => type === chrome.cast.media.TrackType.TEXT).flatMap(({ language, name, trackId }) => {
+			const local = localSubs.find((l) => l.language === language && l.label === name);
+			return local?.mode ? [{
+				mode: local.mode,
+				trackId
+			}] : [];
+		});
+		const hidden = new Set(matched.filter((m) => m.mode !== "showing").map((m) => m.trackId));
+		const showing = matched.find((m) => m.mode === "showing")?.trackId;
+		const active = currentSession()?.getSessionObj().media[0]?.activeTrackIds ?? [];
+		const next = new Set(active.filter((id) => !hidden.has(id)));
+		if (showing) next.add(showing);
+		if (next.size === active.length && active.every((id) => next.has(id))) return;
+		try {
+			await editTracksInfo(new chrome.cast.media.EditTracksInfoRequest([...next]));
+		} catch (error) {
+			console.error(error);
+		}
+	}
+};
+
+//#endregion
+//#region ../core/dist/dev/dom/media/castable/remote-playback.js
+let callbackIdCount = 0;
+var RemotePlayback = class extends EventTarget {
+	#provider;
+	#state = "disconnected";
+	#available = false;
+	#callbacks = /* @__PURE__ */ new Map();
+	constructor(provider) {
+		super();
+		this.#provider = provider;
+		provider.bindHooks({
+			setState: (next) => this.#setState(next),
+			setAvailable: (available) => this.#setAvailable(available)
+		});
+	}
+	get state() {
+		return this.#state;
+	}
+	async watchAvailability(callback) {
+		this.#assertEnabled();
+		const id = ++callbackIdCount;
+		this.#callbacks.set(id, callback);
+		queueMicrotask(() => callback(this.#provider.hasDevicesAvailable()));
+		return id;
+	}
+	async cancelWatchAvailability(callbackId) {
+		this.#assertEnabled();
+		if (callbackId === void 0) {
+			this.#callbacks.clear();
+			return;
+		}
+		if (!this.#callbacks.delete(callbackId)) throw new NotFoundError(`Callback not found for id ${callbackId}.`);
+	}
+	async prompt() {
+		this.#assertEnabled();
+		await this.#provider.requestCastSession();
+	}
+	#assertEnabled() {
+		if (this.#provider.media.disableRemotePlayback) throw new InvalidStateError("disableRemotePlayback attribute is present.");
+	}
+	#setState(next) {
+		if (this.#state === next) return;
+		this.#state = next;
+		if (next === "connecting") this.dispatchEvent(new Event("connecting"));
+		else if (next === "connected") this.dispatchEvent(new Event("connect"));
+		else this.dispatchEvent(new Event("disconnect"));
+	}
+	#setAvailable(available) {
+		if (this.#available === available) return;
+		this.#available = available;
+		for (const callback of this.#callbacks.values()) callback(available);
+	}
+};
+
+//#endregion
+//#region ../core/dist/dev/dom/media/castable/index.js
+const CastableMediaMixin = (superclass) => {
+	class CastableMedia extends superclass {
+		#castOptions = getDefaultCastOptions();
+		#castCustomData;
+		#castSrc;
+		#castContentType;
+		#castStreamType;
+		#castReceiver;
+		#remote;
+		#provider;
+		#destroyed = false;
+		get remote() {
+			if (this.#remote) return this.#remote;
+			if (this.#destroyed) return super.remote;
+			if (requiresCastFramework()) {
+				if (!this.disableRemotePlayback) loadCastFramework();
+				this.#provider = new GoogleCastProvider(this, {
+					duration: () => super.duration,
+					currentTime: () => super.currentTime,
+					paused: () => super.paused,
+					muted: () => super.muted,
+					pause: () => super.pause()
+				});
+				return this.#remote = new RemotePlayback(this.#provider);
+			}
+			return super.remote;
+		}
+		attach(target) {
+			super.attach(target);
+			if (requiresCastFramework() && !this.disableRemotePlayback) loadCastFramework();
+		}
+		detach() {
+			super.detach();
+		}
+		destroy() {
+			this.#provider?.destroy();
+			this.#provider = null;
+			this.#remote = null;
+			this.#destroyed = true;
+			super.destroy();
+		}
+		async load() {
+			if (!this.#provider?.isCasting) return super.load();
+			return this.#provider.load();
+		}
+		play() {
+			if (this.#provider?.isCasting) return this.#provider.play();
+			return super.play();
+		}
+		pause() {
+			if (this.#provider?.isCasting) {
+				this.#provider.pause();
+				return;
+			}
+			super.pause();
+		}
+		get castOptions() {
+			return this.#castOptions;
+		}
+		get castReceiver() {
+			return this.#castReceiver;
+		}
+		set castReceiver(val) {
+			if (this.#castReceiver === val) return;
+			this.#castReceiver = val;
+			if (val) this.#castOptions.receiverApplicationId = val;
+		}
+		get castSrc() {
+			return this.#castSrc ?? this.querySelector("source")?.src ?? this.src ?? this.currentSrc;
+		}
+		set castSrc(val) {
+			if (this.#castSrc === val) return;
+			this.#castSrc = val;
+			if (this.#provider?.isCasting) this.load();
+		}
+		get castContentType() {
+			return this.#castContentType;
+		}
+		set castContentType(val) {
+			this.#castContentType = val;
+		}
+		get castStreamType() {
+			return this.#castStreamType ?? this.streamType;
+		}
+		set castStreamType(val) {
+			if (this.#castStreamType === val) return;
+			this.#castStreamType = val;
+			if (this.#provider?.isCasting) this.load();
+		}
+		get castCustomData() {
+			return this.#castCustomData;
+		}
+		set castCustomData(val) {
+			const valType = typeof val;
+			if (!["object", "undefined"].includes(valType)) {
+				console.error(`castCustomData must be nullish or an object but value was of type ${valType}`);
+				return;
+			}
+			this.#castCustomData = val;
+		}
+		get seeking() {
+			if (this.#provider?.isCasting) return this.#provider.seeking;
+			return super.seeking;
+		}
+		get readyState() {
+			if (this.#provider?.isCasting) return this.#provider.readyState;
+			return super.readyState;
+		}
+		get paused() {
+			if (this.#provider?.isCasting) return this.#provider.paused;
+			return super.paused;
+		}
+		get ended() {
+			if (this.#provider?.isCasting) return this.#provider.ended;
+			return super.ended;
+		}
+		get muted() {
+			if (this.#provider?.isCasting) return this.#provider.muted;
+			return super.muted;
+		}
+		set muted(val) {
+			if (this.#provider?.isCasting) {
+				this.#provider.muted = val;
+				return;
+			}
+			super.muted = val;
+		}
+		get volume() {
+			if (this.#provider?.isCasting) return this.#provider.volume;
+			return super.volume;
+		}
+		set volume(val) {
+			if (this.#provider?.isCasting) {
+				this.#provider.volume = val;
+				return;
+			}
+			super.volume = val;
+		}
+		get playbackRate() {
+			if (this.#provider?.isCasting) return this.#provider.playbackRate;
+			return super.playbackRate;
+		}
+		set playbackRate(val) {
+			if (this.#provider?.isCasting) {
+				this.#provider.playbackRate = val;
+				return;
+			}
+			super.playbackRate = val;
+		}
+		get duration() {
+			if (this.#provider?.isCasting) return this.#provider.duration;
+			return super.duration;
+		}
+		get currentTime() {
+			if (this.#provider?.isCasting) return this.#provider.currentTime;
+			return super.currentTime;
+		}
+		set currentTime(val) {
+			if (this.#provider?.isCasting) {
+				this.#provider.currentTime = val;
+				return;
+			}
+			super.currentTime = val;
+		}
+	}
+	return CastableMedia;
+};
+
+//#endregion
 //#region ../core/dist/dev/dom/media/mux/env.js
 const getEnvPlayerVersion = () => {
 	try {
-		return "10.0.0-beta.21";
+		return "10.0.0-beta.22";
 	} catch {}
 	return "UNKNOWN";
 };
@@ -3060,13 +3771,13 @@ function isMuxVideoSrc({ src }) {
 
 //#endregion
 //#region ../core/dist/dev/dom/media/mux/index.js
-var MuxVideoMedia = class extends MuxDataMediaMixin(HlsMedia) {
+var MuxVideoMedia = class extends MuxDataMediaMixin(CastableMediaMixin(HlsMedia)) {
 	static PLAYER_SOFTWARE_NAME = "mux-video";
 };
-var MuxAudioMedia = class extends MuxDataMediaMixin(HlsMedia) {
+var MuxAudioMedia = class extends MuxDataMediaMixin(CastableMediaMixin(HlsMedia)) {
 	static PLAYER_SOFTWARE_NAME = "mux-audio";
 };
 
 //#endregion
 export { MuxVideoMedia as n, MuxAudioMedia as t };
-//# sourceMappingURL=mux-B5K6kOzg.js.map
+//# sourceMappingURL=mux-BhHIeG3e.js.map