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

package/cdn/{hls-CcSAx_3I.js → hls-DjqAxSvY.js}

@@ -1,7 +1,8 @@
 import { t as listen } from "./listen-CJT7C4kM.js";
-import { t as HTMLVideoElementHost } from "./video-host-BtD61mpF.js";
-import { t as shallowEqual } from "./shallow-equal-Daj3-_LC.js";
-import { n as MediaError, t as NativeHlsMedia } from "./native-hls-lhip4tV9.js";
+import { t as MediaStreamTypes } from "./types-B_4Es-UH.js";
+import { t as HTMLVideoElementHost } from "./video-host-BU9t26fe.js";
+import { t as shallowEqual } from "./shallow-equal-DSpD9PMp.js";
+import { n as MediaError, t as NativeHlsMedia } from "./native-hls-D4f2-E9D.js";
 
 //#region ../core/dist/dev/core/utils/bridge-events.js
 /** Wrap `source.dispatchEvent` so every event is also re-dispatched on `target`. */
@@ -5389,8 +5390,8 @@ var LevelKey = class LevelKey {
 				}
 				if (!this.keyId) this.keyId = getKeyIdFromPlayReadyKey(levelKeys);
 				break;
-			case KeySystemFormats.PLAYREADY:
-				this.pssh = mp4pssh(new Uint8Array([
+			case KeySystemFormats.PLAYREADY: {
+				const PlayReadyKeySystemUUID = new Uint8Array([
 					154,
 					4,
 					240,
@@ -5407,9 +5408,11 @@ var LevelKey = class LevelKey {
 					136,
 					95,
 					149
-				]), null, keyBytes);
+				]);
+				this.pssh = mp4pssh(PlayReadyKeySystemUUID, null, keyBytes);
 				this.keyId = parsePlayReadyWRM(keyBytes);
 				break;
+			}
 			default: {
 				let keydata = keyBytes.subarray(0, 16);
 				if (keydata.length !== 16) {
@@ -12622,7 +12625,8 @@ var MP4Remuxer = class extends Logger {
 			}
 		}
 		mp4SampleDuration = stretchedLastFrame || !mp4SampleDuration ? averageSampleDuration : mp4SampleDuration;
-		this.nextVideoTs = nextVideoTs = lastDTS + mp4SampleDuration - initTime;
+		const endDTS = lastDTS + mp4SampleDuration;
+		this.nextVideoTs = nextVideoTs = endDTS - initTime;
 		this.videoSampleDuration = mp4SampleDuration;
 		this.isVideoContiguous = true;
 		const data = {
@@ -20658,7 +20662,8 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
 			this.altSelection = _objectSpread2(_objectSpread2({}, this.altSelection), {}, { audio });
 			return;
 		}
-		this.mediaSelection = _objectSpread2(_objectSpread2({}, previousSelection), {}, { audio });
+		const currentSelection = _objectSpread2(_objectSpread2({}, previousSelection), {}, { audio });
+		this.mediaSelection = currentSelection;
 	}
 	onSubtitleTrackUpdated(event, data) {
 		const subtitles = this.hls.subtitleTracks[data.id];
@@ -20667,7 +20672,8 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
 			this.altSelection = _objectSpread2(_objectSpread2({}, this.altSelection), {}, { subtitles });
 			return;
 		}
-		this.mediaSelection = _objectSpread2(_objectSpread2({}, previousSelection), {}, { subtitles });
+		const currentSelection = _objectSpread2(_objectSpread2({}, previousSelection), {}, { subtitles });
+		this.mediaSelection = currentSelection;
 	}
 	onAudioTrackSwitching(event, data) {
 		const audioOption = getBasicSelectionOption(data);
@@ -20687,7 +20693,8 @@ Schedule: ${scheduleItems.map((seg) => segmentToString(seg))} pos: ${this.timeli
 	onBufferFlushed(event, data) {
 		const playingItem = this.playingItem;
 		if (playingItem && !this.itemsMatch(playingItem, this.bufferingItem) && !this.isInterstitial(playingItem)) {
-			this.bufferedPos = this.timelinePos;
+			const timelinePos = this.timelinePos;
+			this.bufferedPos = timelinePos;
 			this.checkBuffer();
 		}
 	}
@@ -28251,6 +28258,127 @@ function HlsJsMediaErrorsMixin(BaseClass) {
 	return HlsJsMediaErrors;
 }
 
+//#endregion
+//#region ../core/dist/dev/dom/media/hls/live.js
+function HlsJsMediaLiveMixin(BaseClass) {
+	class HlsJsMediaLive extends BaseClass {
+		#targetLiveWindow = NaN;
+		#liveEdgeStartOffset;
+		#seekToLiveAbort = null;
+		#seekToLivePending = false;
+		constructor(...args) {
+			super(...args);
+			const { engine } = this;
+			engine?.on(Hls.Events.MANIFEST_LOADING, () => {
+				this.#reset();
+				this.#armSeekToLive();
+			});
+			engine?.on(Hls.Events.MEDIA_ATTACHED, () => this.#armSeekToLive());
+			engine?.on(Hls.Events.MEDIA_DETACHED, () => this.#disarmSeekToLive());
+			engine?.on(Hls.Events.DESTROYING, () => {
+				this.#reset();
+				this.#disarmSeekToLive();
+			});
+			engine?.on(Hls.Events.LEVEL_LOADED, (_event, data) => {
+				this.#derive(data.details);
+				if (this.#seekToLivePending) this.#trySeekToLive();
+			});
+		}
+		get targetLiveWindow() {
+			return this.#targetLiveWindow;
+		}
+		get liveEdgeStart() {
+			if (this.#liveEdgeStartOffset === void 0) return NaN;
+			const { target } = this;
+			if (!target) return NaN;
+			const { seekable } = target;
+			if (!seekable.length) return NaN;
+			return seekable.end(seekable.length - 1) - this.#liveEdgeStartOffset;
+		}
+		#derive(details) {
+			if (!details.live) return this.#reset();
+			const info = getStreamInfoFromHlsjsLevelDetails(details);
+			this.#liveEdgeStartOffset = info.liveEdgeStartOffset;
+			this.#updateConfig(info);
+			this.#setTargetLiveWindow(info.targetLiveWindow);
+		}
+		#reset() {
+			this.#liveEdgeStartOffset = void 0;
+			this.#setTargetLiveWindow(NaN);
+		}
+		#updateConfig({ streamType, lowLatency }) {
+			if (streamType === MediaStreamTypes.LIVE) {
+				const hls = this.engine;
+				if (!hls) return;
+				if (lowLatency) {
+					hls.config.backBufferLength = hls.userConfig.backBufferLength ?? 4;
+					hls.config.maxFragLookUpTolerance = hls.userConfig.maxFragLookUpTolerance ?? .001;
+					hls.config.abrBandWidthUpFactor = hls.userConfig.abrBandWidthUpFactor ?? hls.config.abrBandWidthFactor;
+				} else hls.config.backBufferLength = hls.userConfig.backBufferLength ?? 8;
+			}
+		}
+		#setTargetLiveWindow(value) {
+			if (Object.is(this.#targetLiveWindow, value)) return;
+			this.#targetLiveWindow = value;
+			this.dispatchEvent(new Event("targetlivewindowchange"));
+		}
+		/**
+		* Arm a one-shot seek-to-live on the first user-initiated `play`. Skipped
+		* when `autoplay` is set, since hls.js positions at the live edge during
+		* its own startup sequence and a programmatic seek would race that.
+		*/
+		#armSeekToLive() {
+			this.#disarmSeekToLive();
+			const target = this.target;
+			if (!target || target.autoplay) return;
+			this.#seekToLiveAbort = new AbortController();
+			target.addEventListener("play", () => {
+				this.#seekToLivePending = true;
+				this.#trySeekToLive();
+			}, {
+				signal: this.#seekToLiveAbort.signal,
+				once: true
+			});
+		}
+		#disarmSeekToLive() {
+			this.#seekToLiveAbort?.abort();
+			this.#seekToLiveAbort = null;
+			this.#seekToLivePending = false;
+		}
+		#trySeekToLive() {
+			const target = this.target;
+			if (!target) return;
+			const { liveEdgeStart } = this;
+			if (!Number.isFinite(liveEdgeStart)) return;
+			if (target.currentTime < liveEdgeStart) target.currentTime = liveEdgeStart;
+			this.#seekToLivePending = false;
+		}
+	}
+	return HlsJsMediaLive;
+}
+const getStreamInfoFromHlsjsLevelDetails = (levelDetails) => {
+	const playlistType = levelDetails.type;
+	const streamType = toStreamTypeFromPlaylistType(playlistType);
+	const targetLiveWindow = toTargetLiveWindowFromPlaylistType(playlistType);
+	const lowLatency = !!levelDetails.partList?.length;
+	let liveEdgeStartOffset;
+	if (streamType === MediaStreamTypes.LIVE) liveEdgeStartOffset = lowLatency ? levelDetails.partHoldBack || levelDetails.partTarget * 2 : levelDetails.holdBack || levelDetails.targetduration * 3;
+	return {
+		streamType,
+		targetLiveWindow,
+		liveEdgeStartOffset,
+		lowLatency
+	};
+};
+const toStreamTypeFromPlaylistType = (playlistType) => {
+	return playlistType === "VOD" ? MediaStreamTypes.ON_DEMAND : MediaStreamTypes.LIVE;
+};
+const toTargetLiveWindowFromPlaylistType = (playlistType) => {
+	if (playlistType === "EVENT") return Number.POSITIVE_INFINITY;
+	if (playlistType === "VOD") return NaN;
+	return 0;
+};
+
 //#endregion
 //#region ../core/dist/dev/dom/media/hls/metadata-tracks.js
 /**
@@ -28357,6 +28485,45 @@ function HlsJsMediaPreloadMixin(BaseClass) {
 	return HlsJsMediaPreload;
 }
 
+//#endregion
+//#region ../core/dist/dev/dom/media/hls/stream-type.js
+function HlsJsMediaStreamTypeMixin(BaseClass) {
+	class HlsJsMediaStreamType extends BaseClass {
+		#streamType = MediaStreamTypes.UNKNOWN;
+		#isUserStreamType = false;
+		constructor(...args) {
+			super(...args);
+			this.engine?.on(Hls.Events.MANIFEST_LOADING, () => this.#setDetected(MediaStreamTypes.UNKNOWN));
+			this.engine?.on(Hls.Events.DESTROYING, () => this.#setDetected(MediaStreamTypes.UNKNOWN));
+			this.engine?.on(Hls.Events.LEVEL_LOADED, (_event, data) => {
+				this.#setDetected(data.details.live ? MediaStreamTypes.LIVE : MediaStreamTypes.ON_DEMAND);
+			});
+		}
+		get streamType() {
+			return this.#streamType;
+		}
+		set streamType(value) {
+			if (value === MediaStreamTypes.UNKNOWN) {
+				this.#isUserStreamType = false;
+				this.#update(MediaStreamTypes.UNKNOWN);
+				return;
+			}
+			this.#isUserStreamType = true;
+			this.#update(value);
+		}
+		#setDetected(value) {
+			if (this.#isUserStreamType) return;
+			this.#update(value);
+		}
+		#update(value) {
+			if (this.#streamType === value) return;
+			this.#streamType = value;
+			this.dispatchEvent(new Event("streamtypechange"));
+		}
+	}
+	return HlsJsMediaStreamType;
+}
+
 //#endregion
 //#region ../core/dist/dev/dom/media/hls/text-tracks.js
 /**
@@ -28499,7 +28666,7 @@ var HlsJsMediaBase = class extends HTMLVideoElementHost {
 		this.#engine = null;
 	}
 };
-var HlsJsMedia = class extends HlsJsMediaPreloadMixin(HlsJsMediaMetadataTracksMixin(HlsJsMediaTextTracksMixin(HlsJsMediaErrorsMixin(HlsJsMediaBase)))) {};
+var HlsJsMedia = class extends HlsJsMediaPreloadMixin(HlsJsMediaLiveMixin(HlsJsMediaStreamTypeMixin(HlsJsMediaMetadataTracksMixin(HlsJsMediaTextTracksMixin(HlsJsMediaErrorsMixin(HlsJsMediaBase)))))) {};
 
 //#endregion
 //#region ../core/dist/dev/dom/media/hls/index.js
@@ -28511,14 +28678,26 @@ const SourceTypes = {
 	M3U8: "application/vnd.apple.mpegurl",
 	MP4: "video/mp4"
 };
+const StreamTypes = MediaStreamTypes;
+const hlsMediaDefaultProps = {
+	src: "",
+	type: void 0,
+	preferPlayback: "mse",
+	config: {},
+	debug: false,
+	preload: "metadata",
+	streamType: MediaStreamTypes.UNKNOWN
+};
 var HlsMedia = class extends HTMLVideoElementHost {
 	#delegate = null;
-	#src = "";
-	#type;
-	#preferPlayback = "mse";
-	#config = {};
-	#debug = false;
-	#preload = "metadata";
+	#src = hlsMediaDefaultProps.src;
+	#type = hlsMediaDefaultProps.type;
+	#preferPlayback = hlsMediaDefaultProps.preferPlayback;
+	#config = { ...hlsMediaDefaultProps.config };
+	#debug = hlsMediaDefaultProps.debug;
+	#preload = hlsMediaDefaultProps.preload;
+	#streamType = hlsMediaDefaultProps.streamType;
+	#isUserStreamType = false;
 	#loadRequested;
 	#prevEngineProps;
 	get engine() {
@@ -28564,6 +28743,7 @@ var HlsMedia = class extends HTMLVideoElementHost {
 		this.#debug = debug;
 		this.#requestLoad();
 	}
+	/** Preload type (`'none'` / `'metadata'` / `'auto'`). */
 	get preload() {
 		return this.#preload;
 	}
@@ -28571,6 +28751,38 @@ var HlsMedia = class extends HTMLVideoElementHost {
 		this.#preload = value;
 		if (this.#delegate) this.#delegate.preload = value;
 	}
+	/** Current stream type (`'on-demand'` / `'live'` / `'unknown'`). */
+	get streamType() {
+		return this.#delegate?.streamType ?? this.#streamType;
+	}
+	set streamType(value) {
+		this.#isUserStreamType = value !== StreamTypes.UNKNOWN;
+		if (this.#delegate) {
+			this.#delegate.streamType = value;
+			this.#streamType = this.#delegate.streamType;
+			return;
+		}
+		if (this.#streamType === value) return;
+		this.#streamType = value;
+		this.dispatchEvent(new Event("streamtypechange"));
+	}
+	/**
+	* Presentation time marking the start of the Live Edge Window.
+	*
+	* Derived from the delegate on every read; `NaN` when no delegate is
+	* attached or the stream is not live.
+	*/
+	get liveEdgeStart() {
+		return this.#delegate?.liveEdgeStart ?? NaN;
+	}
+	/**
+	* Seekable range size for live content. `0` for standard live, `Infinity`
+	* for DVR, `NaN` for on-demand or unknown. Fires `targetlivewindowchange`
+	* when the value changes (bridged from the delegate).
+	*/
+	get targetLiveWindow() {
+		return this.#delegate?.targetLiveWindow ?? NaN;
+	}
 	attach(target) {
 		super.attach(target);
 		this.#delegate?.attach(target);
@@ -28588,13 +28800,15 @@ var HlsMedia = class extends HTMLVideoElementHost {
 		if (this.#shouldEngineUpdate(this.#engineProps())) {
 			this.#engineDestroy();
 			this.#prevEngineProps = this.#engineProps();
-			this.#delegate = Hls.isSupported() && this.type === SourceTypes.M3U8 && this.preferPlayback !== PlaybackTypes.NATIVE ? new HlsJsMedia({ config: {
+			const useMse = Hls.isSupported() && this.type === SourceTypes.M3U8 && this.preferPlayback !== PlaybackTypes.NATIVE;
+			this.#delegate = useMse ? new HlsJsMedia({ config: {
 				...this.config,
 				debug: this.debug
 			} }) : new NativeHlsMedia();
 			bridgeEvents(this.#delegate, this);
-			if (this.target) this.#delegate.attach(this.target);
+			if (this.#isUserStreamType) this.#delegate.streamType = this.#streamType;
 			this.#delegate.preload = this.preload;
+			if (this.target) this.#delegate.attach(this.target);
 		}
 		if (this.#delegate) this.#delegate.src = this.#src;
 	}
@@ -28620,6 +28834,7 @@ var HlsMedia = class extends HTMLVideoElementHost {
 		this.#delegate = null;
 		this.#prevEngineProps = null;
 		this.#loadRequested = null;
+		if (!this.#isUserStreamType) this.#streamType = StreamTypes.UNKNOWN;
 	}
 };
 function inferSourceType(src) {
@@ -28628,5 +28843,5 @@ function inferSourceType(src) {
 }
 
 //#endregion
-export { Hls as n, HlsMedia as t };
-//# sourceMappingURL=hls-CcSAx_3I.js.map
+export { hlsMediaDefaultProps as n, Hls as r, HlsMedia as t };
+//# sourceMappingURL=hls-DjqAxSvY.js.map