@kkcompany/player 2.25.0-canary.24 → 2.25.0-canary.25

package/dist/StallReload-BFlQRphx.mjs

@@ -0,0 +1,717 @@
+import { A as once$1, i as isLiveDuration } from "./mediaBindings-CoY60lQw.mjs";
+import { t as loadScript_default } from "./loadScript-Ct19kU9g.mjs";
+import { n as pipeEvents } from "./events-B3vI3Srm.mjs";
+import mitt from "mitt";
+
+//#region src/playerCore/fetchManifests.js
+/** @param {string} m3u8Manifest */
+const getManifestUrl = ({ url, data }) => {
+	const lines = data.split("\n");
+	const i = lines.findIndex((line) => line.startsWith("#EXT-X-STREAM-INF"));
+	return i >= 0 ? new URL(lines[i + 1], url) : "";
+};
+/** @param {string} url */
+const fetchManifests = async (url) => {
+	if (!url.toString().split("?")[0].endsWith(".m3u8")) return fetch(url);
+	const innerUrl = getManifestUrl({
+		url,
+		data: await fetch(url).then((result) => result.text())
+	});
+	return innerUrl && fetchManifests(innerUrl);
+};
+var fetchManifests_default = fetchManifests;
+
+//#endregion
+//#region src/ad/impression.js
+const _IsNumber = (value) => typeof value === "number" && value >= 0;
+const AD_TIME_EVENT_TYPE = [
+	"impression",
+	"start",
+	"firstQuartile",
+	"midpoint",
+	"thirdQuartile",
+	"complete"
+];
+const doNothing = () => {};
+const getSkipTimeOffset = (ad) => {
+	if (!ad.skipOffset) return;
+	const percentageOffset = (ad.skipOffset?.match(/\d+/)?.[0] || 0) / 100;
+	return (ad.skipOffset?.match(/(\d+):(\d+):(\d+)/) || []).slice(1, 4).reduce((last, time) => last * 60 + +time, 0) + ad.durationInSeconds * percentageOffset;
+};
+const inRange = ({ startTimeInSeconds, durationInSeconds }, time) => startTimeInSeconds <= time && time <= startTimeInSeconds + durationInSeconds;
+const getCurrentAd = (adBreak, streamTime) => (adBreak?.ads || []).find((ad) => inRange(ad, streamTime)) || {};
+const adEventData = (instance, ad) => {
+	const streamTime = instance._common.currentPosition;
+	const currentAd = getCurrentAd(ad, streamTime);
+	return {
+		getAd: () => ({ getSkipTimeOffset: () => getSkipTimeOffset(currentAd) }),
+		getStreamData: () => {
+			const adItems = [].concat(...instance.waitingForPlayAds.map((avail) => avail.ads));
+			return { adProgressData: {
+				adPosition: 1 + adItems.findIndex((item) => inRange(item, streamTime)),
+				totalAds: adItems.length,
+				currentTime: streamTime - currentAd.startTimeInSeconds,
+				duration: currentAd.durationInSeconds,
+				clickThroughUrl: currentAd.trackingEvents?.find((event) => event.eventType === "clickThrough")?.beaconUrls[0]
+			} };
+		}
+	};
+};
+var Impression = class {
+	constructor({ seek, onAdBreakStarted = doNothing, onAdProgress = doNothing, onAdBreakEnded = doNothing, onSkippableStateChanged = doNothing } = {}) {
+		this._common = {
+			adBreaks: [],
+			currentPosition: -1,
+			seek,
+			onAdBreakStarted,
+			onAdProgress,
+			onSkippableStateChanged,
+			onAdBreakEnded
+		};
+		this.currentAd = null;
+		this.waitingForPlayAds = [];
+		this.waitingForPlayAdIndex = null;
+		this.resumeUserSeekTime = null;
+		this.resumeAdStartTime = null;
+		this.isResumed = null;
+		this.checkAdEventProcess = null;
+	}
+	/**
+	* @description
+	* @param {object[]} value
+	*/
+	set adBreaks(value) {
+		this._common.adBreaks = value;
+		if (_IsNumber(value.length)) this.checkAdCueTone();
+	}
+	/**
+	* @description when position is updated, check if ad is started or ended
+	* @param {number} value current position in seconds
+	*/
+	set currentPosition(value) {
+		this._common.currentPosition = value;
+		if (_IsNumber(this._common.adBreaks.length)) this.checkAdCueTone();
+	}
+	getAdIndex(target) {
+		if (!target) return null;
+		return this._common.adBreaks.findIndex((ad) => ad.availId === target.availId);
+	}
+	getActiveAdIndex(time) {
+		const { adBreaks = [] } = this._common;
+		const index = adBreaks.findIndex((ad) => {
+			const { startTime, endTime } = this.getAdTimingInfo(ad);
+			return time >= startTime && time <= endTime;
+		});
+		return {
+			index,
+			position: (adBreaks[index]?.ads || []).findIndex((ad) => inRange(ad, time))
+		};
+	}
+	isWithinTimeRange(target, startTime, endTime) {
+		return target >= startTime && target <= endTime;
+	}
+	getAdTimingInfo(adInfo = {}) {
+		const adStartTime = adInfo.startTimeInSeconds || 0;
+		return {
+			startTime: adStartTime,
+			endTime: adStartTime + (adInfo.durationInSeconds || 0)
+		};
+	}
+	getSkippedAds(time) {
+		return this._common.adBreaks.filter((ad) => this._common.currentPosition <= ad.startTimeInSeconds && ad.startTimeInSeconds <= time && !ad.isFired);
+	}
+	setAdIsFiredByIndex() {}
+	checkAdCueTone() {
+		const { adBreaks, currentPosition, seek } = this._common;
+		const { index: activeAdIndex, position } = this.getActiveAdIndex(currentPosition);
+		if (this.currentAd) {
+			if (!this.checkAdEventProcess) this.checkAdEventProcess = this.checkAdEvent();
+			this.checkAdEventProcess({
+				index: activeAdIndex,
+				position
+			});
+		}
+		if (this.waitingForPlayAds.length > 0) {
+			const { startTime: currentAdStartTime, endTime: currentAdEndTime } = this.getAdTimingInfo(this.currentAd);
+			if (!this.isWithinTimeRange(currentPosition, currentAdStartTime, currentAdEndTime)) {
+				const nextAd = this.waitingForPlayAds[`${this.waitingForPlayAdIndex + 1}`];
+				if (currentPosition < this.currentAd.startTimeInSeconds + this.currentAd.durationInSeconds) return;
+				if (nextAd) {
+					const adIndex = this.getAdIndex(this.currentAd);
+					const { startTime: nextAdStartTime } = this.getAdTimingInfo(nextAd);
+					this.setAdIsFiredByIndex(adIndex);
+					this.updateWaitingForPlayIndex(this.waitingForPlayAdIndex + 1);
+					this.updateCurrentAd(nextAd);
+					seek?.(nextAdStartTime);
+				} else {
+					const adIndex = this.getAdIndex(this.currentAd);
+					this.setAdIsFiredByIndex(adIndex);
+					this.updateWaitingForPlayAds([]);
+					this.updateWaitingForPlayIndex(null);
+					this.updateCurrentAd(null);
+					_IsNumber(this.resumeUserSeekTime) && seek?.(this.resumeUserSeekTime);
+					this.resumeUserSeekTime = null;
+				}
+			}
+		} else if (activeAdIndex !== -1) if (!adBreaks[activeAdIndex].isFired) {
+			this.updateWaitingForPlayIndex(0);
+			this.updateWaitingForPlayAds(adBreaks.slice(activeAdIndex, activeAdIndex + 1));
+			this.updateCurrentAd(adBreaks[activeAdIndex]);
+		} else this.updateCurrentAd(adBreaks[`${activeAdIndex}`] || {});
+		else this.updateCurrentAd(null);
+	}
+	checkAdEvent() {
+		const state = {
+			lastPosition: void 0,
+			isSkippableEventFired: false
+		};
+		return ({ index, position }) => {
+			const streamTime = this._common.currentPosition;
+			const currentBreak = this._common.adBreaks[index];
+			const currentAd = currentBreak?.ads[position];
+			if (!currentAd) return;
+			if (position !== state.lastPosition) {
+				this._common.onAdProgress?.(adEventData(this, currentBreak));
+				Object.assign(state, {
+					lastPosition: position,
+					isSkippableEventFired: false,
+					trackingTypes: AD_TIME_EVENT_TYPE.slice()
+				});
+			}
+			if (!state.isSkippableEventFired && streamTime >= currentAd.startTimeInSeconds + getSkipTimeOffset(currentAd)) {
+				state.isSkippableEventFired = true;
+				this._common.onSkippableStateChanged({ getAd: () => ({ isSkippable: () => true }) });
+			}
+			if (!_IsNumber(streamTime) || currentAd.trackingEvents?.length <= 0) return;
+			currentAd.trackingEvents?.forEach((e) => {
+				const { eventType = "", beaconUrls = [], startTimeInSeconds = 0, isFired } = e;
+				const adEventIndex = state.trackingTypes.findIndex((type) => type === eventType);
+				if (!isFired && beaconUrls.length > 0 && streamTime >= startTimeInSeconds && adEventIndex !== -1) {
+					beaconUrls.forEach((url) => {
+						fetch(url);
+					});
+					state.trackingTypes.splice(adEventIndex, 1);
+				}
+			});
+		};
+	}
+	/**
+	* @description To snapback if seeking over some ads
+	* @param {number} to
+	*/
+	onSeek(to) {
+		const { adBreaks } = this._common;
+		const skippedAds = this.getSkippedAds(to);
+		const seekTargetAdIndex = this.getActiveAdIndex(to);
+		if (!adBreaks || adBreaks.length <= 0) return;
+		if (this.currentAd) {} else if (skippedAds.length > 0) {
+			this.updateWaitingForPlayAds(skippedAds);
+			this.updateWaitingForPlayIndex(0);
+			this.resumeUserSeekTime = seekTargetAdIndex === -1 ? to : null;
+		} else if (seekTargetAdIndex !== -1 && !_IsNumber(this.resumeAdStartTime) && !this.isResumed) {
+			const { startTime } = this.getAdTimingInfo(adBreaks[seekTargetAdIndex]);
+			this.resumeAdStartTime = startTime;
+		}
+	}
+	/** @description to seek to next ad after snapback */
+	onSeeked() {
+		const { adBreaks, seek } = this._common;
+		if (!adBreaks || adBreaks.length <= 0) return;
+		if (this.waitingForPlayAds.length > 0 && !this.currentAd) {
+			const nextAd = this.waitingForPlayAds[`${this.waitingForPlayAdIndex}`] || {};
+			const { startTime: nextAdStartTime } = this.getAdTimingInfo(nextAd);
+			seek?.(nextAdStartTime);
+			this.updateCurrentAd(nextAd);
+		} else if (this.currentAd) {} else if (_IsNumber(this.resumeAdStartTime)) {
+			_IsNumber(this.resumeAdStartTime) && seek?.(this.resumeAdStartTime);
+			this.resumeAdStartTime = null;
+			this.isResumed = true;
+		} else this.isResumed = false;
+	}
+	updateCurrentAd(ad) {
+		if (!this.currentAd && ad) this._common.onAdBreakStarted?.(adEventData(this, ad));
+		else if (this.currentAd && !ad) this._common.onAdBreakEnded?.({ getStreamData: () => this.getStreamData() });
+		this.currentAd = ad;
+		if (!ad) this.checkAdEventProcess = null;
+	}
+	updateWaitingForPlayAds(ads) {
+		this.waitingForPlayAds = ads.slice();
+	}
+	updateWaitingForPlayIndex(index) {
+		this.waitingForPlayAdIndex = index;
+	}
+	/** @description mark all ads as played */
+	setAllAdsFired() {
+		this._common.adBreaks = this._common.adBreaks.map((ad) => ({
+			...ad,
+			isFired: true
+		}));
+		this.updateWaitingForPlayAds([]);
+		this.updateWaitingForPlayIndex(null);
+		this.updateCurrentAd(null);
+	}
+	/** @description clear data */
+	reset() {
+		this._common = {
+			adBreaks: [],
+			currentPosition: -1,
+			seek: null
+		};
+		this.currentAd = null;
+		this.waitingForPlayAds = [];
+		this.waitingForPlayAdIndex = null;
+		this.resumeUserSeekTime = null;
+		this.resumeAdStartTime = null;
+		this.isResumed = null;
+		this.checkAdEventProcess = null;
+	}
+	/** @description clear ad status */
+	resetSession() {
+		this._common = {
+			...this._common,
+			currentPosition: 0
+		};
+		this.resumeUserSeekTime = null;
+		this.resumeAdStartTime = null;
+		this.isResumed = null;
+		this.updateWaitingForPlayAds([]);
+		this.updateWaitingForPlayIndex(null);
+		this.updateCurrentAd(null);
+	}
+};
+
+//#endregion
+//#region src/ad/vast.js
+const getLastAd = (avails, streamTime) => avails.reduce((current, item) => current.startTimeInSeconds <= item.startTimeInSeconds && item.startTimeInSeconds <= streamTime ? item : current, {
+	startTimeInSeconds: 0,
+	durationInSeconds: 0
+});
+const getStreamTime = (avails, contentTime) => avails.reduce((time, item) => time + (time > item.startTimeInSeconds ? item.durationInSeconds : 0), contentTime);
+const getContentTime = (avails, streamTime) => streamTime - avails.filter((item) => item.startTimeInSeconds <= streamTime).map((item) => Math.min(streamTime - item.startTimeInSeconds, item.durationInSeconds)).reduce((a, b) => a + b, 0);
+
+//#endregion
+//#region src/ad/seekingHandler.js
+const seekingHandler = (handleSeeking) => {
+	const ref = {};
+	return (video) => {
+		if (!(Math.abs(video.currentTime - ref.originTime) > .5) || video.webkitPresentationMode !== "fullscreen") {
+			ref.originTime = video.currentTime;
+			return;
+		}
+		handleSeeking({
+			originTime: ref.originTime,
+			seekTime: video.currentTime
+		});
+		ref.originTime = video.currentTime;
+	};
+};
+var seekingHandler_default = seekingHandler;
+
+//#endregion
+//#region src/util/snapback.js
+const snapback = ({ streamManager, originTime, seekTime, seek }) => {
+	const cuePoint = streamManager?.previousCuePointForStreamTime(seekTime);
+	if (Math.floor(cuePoint?.start) >= Math.floor(originTime)) {
+		once$1(streamManager, "adBreakEnded", async () => {
+			await new Promise((resolve) => {
+				setTimeout(resolve, 20);
+			});
+			seek(seekTime);
+		});
+		seek(cuePoint.start);
+	} else seek(seekTime);
+};
+var snapback_default = snapback;
+
+//#endregion
+//#region src/plugins/MediaTailor.js
+const axios = () => {};
+const addFetchPolyfill = () => {
+	window.fetch = async (url, { method } = {}) => {
+		const result = await axios(url, { method });
+		return Promise.resolve({ json: () => result.data });
+	};
+};
+const fetchStreamInfo = async (url, adsParams) => fetch(url, {
+	method: "POST",
+	body: JSON.stringify({ adsParams })
+}).then((result) => result.json());
+const on = (eventTarget, eventName, handler) => {
+	eventTarget.addEventListener(eventName, handler);
+	return () => eventTarget.removeEventListener(eventName, handler);
+};
+const once = (eventTarget, eventName, handler) => {
+	const listener = (...args) => {
+		eventTarget.removeEventListener(eventName, listener);
+		return handler(...args);
+	};
+	eventTarget.addEventListener(eventName, listener);
+};
+const seekVideo = (videoElement, streamTime) => {
+	videoElement.currentTime = streamTime;
+};
+const initialState = {
+	currentTime: 0,
+	adBreaks: [],
+	mpdStartTime: 0,
+	isUserSkipAd: false,
+	skipAdEndTime: 0
+};
+const getAdEndTime = (streamData, videoElement) => {
+	const { currentTime, duration } = streamData.adProgressData;
+	return videoElement.currentTime + duration - currentTime;
+};
+const pipeEvent = (emitter, type) => (event) => emitter.emit(type, {
+	type,
+	getAd: () => event.getAd(),
+	getStreamData: () => event.getStreamData()
+});
+const getMpdStartTime = (manifest) => {
+	const availabilityStartTime = new DOMParser().parseFromString(manifest, "text/xml").firstChild.getAttribute("availabilityStartTime");
+	return new Date(availabilityStartTime).getTime() / 1e3;
+};
+const createStreamManager = (videoElement, { player, emitter }) => {
+	let state = initialState;
+	const streamData = {};
+	const impression = new Impression({
+		seek: (streamTime) => seekVideo(videoElement, streamTime),
+		onAdBreakStarted: pipeEvent(emitter, "adBreakStarted"),
+		onAdProgress: (event) => {
+			state.adEndTime = getAdEndTime(event.getStreamData(), videoElement);
+			pipeEvent(emitter, "adProgress")(event);
+		},
+		onSkippableStateChanged: pipeEvent(emitter, "skippableStateChanged"),
+		onAdBreakEnded: pipeEvent(emitter, "adBreakEnded")
+	});
+	const previousCuePointForStreamTime = (streamTime) => {
+		const ad = getLastAd(state.adBreaks, streamTime - .1 - state.mpdStartTime);
+		if (ad.durationInSeconds > 0) {
+			const start = ad.startTimeInSeconds;
+			return {
+				start,
+				end: start + ad.durationInSeconds,
+				played: state.played[ad.availId]
+			};
+		}
+	};
+	emitter.on("adBreakEnded", () => {
+		state.adEndTime = -1;
+		const ad = getLastAd(state.adBreaks, videoElement.currentTime);
+		state.played[ad.availId] = true;
+	});
+	const refreshTrackingData = async () => {
+		if (!streamData.trackingUrl) return;
+		const trackingData = await fetch(streamData.trackingUrl).then((result) => result.json()) || { avails: [] };
+		state.adBreaks = trackingData.avails || [];
+		if (trackingData.avails.length > 0) {
+			impression.adBreaks = state.adBreaks;
+			emitter.emit("cuepointsChanged", { cuepoints: state.adBreaks.map((item) => ({ start: getContentTime(state.adBreaks, item.startTimeInSeconds) })) });
+		}
+	};
+	const handleTimeUpdate = (streamTime) => {
+		if (!Number.isFinite(streamTime)) return;
+		if (player.isLive() && streamTime > state.currentTime + 5) {
+			state.currentTime = streamTime;
+			refreshTrackingData();
+		}
+		if (state.isUserSkipAd) {
+			if (state.skipAdEndTime + .1 >= streamTime) return;
+			state.isUserSkipAd = false;
+			state.skipAdEndTime = -1;
+		}
+		impression.currentPosition = streamTime - state.mpdStartTime;
+	};
+	const streamManager = {
+		requestStream: async (options = {}) => {
+			const reportingUrl = options.client_side_reporting_url;
+			const info = await fetchStreamInfo(reportingUrl, options.adParams).catch((error) => ({ error }));
+			if (!info || info.error) return;
+			streamData.trackingUrl = new URL(info.trackingUrl, reportingUrl).toString();
+			streamData.url = new URL(info.manifestUrl, reportingUrl).toString();
+			await fetchManifests_default(streamData.url);
+			await refreshTrackingData();
+			emitter.emit("loaded", { getStreamData: () => streamData });
+			state.played = {};
+		},
+		addEventListener: (eventName, handler) => emitter.on(eventName, handler),
+		removeEventListener: (eventName, handler) => emitter.off(eventName, handler),
+		streamTimeForContentTime: (contentTime) => getStreamTime(state.adBreaks, contentTime),
+		contentTimeForStreamTime: (streamTime) => getContentTime(state.adBreaks, streamTime),
+		previousCuePointForStreamTime,
+		skipAd: () => {
+			if (state.adEndTime > 0) {
+				const seekTime = state.adEndTime;
+				handleTimeUpdate(state.adEndTime);
+				state.isUserSkipAd = true;
+				state.skipAdEndTime = seekTime;
+				player?.seek(seekTime, "internal");
+				emitter.emit("skip");
+			}
+		},
+		setMpdStartTime: (time) => {
+			state.mpdStartTime = time;
+		},
+		getVastAvails: () => state.adBreaks,
+		reset: () => {
+			state.registered.forEach((removeListener) => removeListener());
+			impression.reset();
+			state = initialState;
+			streamData.trackingUrl = "";
+		}
+	};
+	const handleSeeking = seekingHandler_default(({ originTime, seekTime }) => {
+		if (state.adEndTime > 0) {
+			seekVideo(videoElement, originTime);
+			return;
+		}
+		const diff = seekTime - originTime;
+		if (Math.abs(diff + 15) <= .25) {
+			seekVideo(videoElement, getStreamTime(state.adBreaks, getContentTime(state.adBreaks, originTime) + diff));
+			return;
+		}
+		snapback_default({
+			streamManager,
+			originTime,
+			seekTime,
+			seek: (streamTime) => {
+				if (Math.abs(videoElement.currentTime - streamTime) > .5) seekVideo(videoElement, streamTime);
+			}
+		});
+	});
+	state.registered = [on(videoElement, "timeupdate", () => {
+		handleSeeking(videoElement);
+		if (!videoElement.paused) handleTimeUpdate(videoElement.currentTime);
+	}), on(videoElement, "ended", () => handleTimeUpdate(Infinity))];
+	return streamManager;
+};
+const init = (options, { skipWatched }) => {
+	const { player, video, streamManager } = options;
+	const ref = {
+		player,
+		video,
+		streamManager
+	};
+	streamManager.addEventListener("adProgress", (event) => {
+		ref.adEndTime = getAdEndTime(event.getStreamData(), ref.video);
+	});
+	streamManager.addEventListener("adBreakEnded", () => {
+		ref.adEndTime = -1;
+	});
+	player?.on?.("sourceloaded", () => {
+		ref.isLive = player.isLive();
+		if (player.manifest.dash && player.isLive()) streamManager.setMpdStartTime(getMpdStartTime(player.getManifest()));
+	});
+	if (skipWatched) video.addEventListener("timeupdate", () => {
+		const streamTime = video.currentTime;
+		const cuePoint = streamManager.previousCuePointForStreamTime(streamTime + .5);
+		if (cuePoint?.end > streamTime && cuePoint.played) player?.seek(cuePoint.end, "internal");
+	});
+	return ref;
+};
+const MediaTailorPlugin = ({ adParams, skipWatched } = {}) => {
+	const emitter = mitt();
+	let ref = {};
+	let options = { adParams };
+	return {
+		isActive: () => !!ref.streamManager,
+		load: async (manifestItem, { player, video, source = {} } = {}) => {
+			if (typeof fetch !== "function") addFetchPolyfill();
+			ref.streamManager?.reset();
+			const mediaTailorOptions = manifestItem.ssai?.media_tailor;
+			if (!mediaTailorOptions) return;
+			mediaTailorOptions.adParams = options.adParams;
+			const streamManager = createStreamManager(video, {
+				player,
+				emitter
+			});
+			ref = init({
+				player,
+				video,
+				streamManager
+			}, { skipWatched });
+			streamManager.requestStream(mediaTailorOptions);
+			const { url } = await new Promise((resolve) => {
+				once(streamManager, "loaded", (event) => resolve(event.getStreamData()));
+			});
+			if (!url) {
+				console.warn("Ad stream is not available, use fallback stream instead");
+				return manifestItem;
+			}
+			return {
+				...manifestItem,
+				ssaiProvider: "AWS",
+				url,
+				vastAvails: streamManager.getVastAvails(),
+				startTime: streamManager.streamTimeForContentTime(source.options?.startTime)
+			};
+		},
+		handleSeek: (contentTime, seek) => {
+			snapback_default({
+				streamManager: ref.streamManager,
+				originTime: ref.video.currentTime,
+				seekTime: ref.streamManager.streamTimeForContentTime(contentTime),
+				seek
+			});
+		},
+		skipAd: () => ref.streamManager.skipAd(),
+		getPlaybackStatus: () => ref.streamManager && {
+			...!ref.isLive && {
+				currentTime: ref.streamManager.contentTimeForStreamTime(ref.video.currentTime),
+				duration: ref.streamManager.contentTimeForStreamTime(ref.video.duration)
+			},
+			...ref.adEndTime > 0 && { adRemainingTime: ref.adEndTime - ref.video.currentTime }
+		},
+		on: (name, listener) => emitter.on(name, listener),
+		reset: () => {
+			ref.streamManager?.reset();
+			ref.streamManager = void 0;
+		},
+		setOptions: (updatedOptions) => {
+			options = updatedOptions;
+		}
+	};
+};
+var MediaTailor_default = MediaTailorPlugin;
+
+//#endregion
+//#region src/plugins/ImaDai.js
+const GOOGLE_DAI_SDK_URL = "https://imasdk.googleapis.com/js/sdkloader/ima3_dai.js";
+const ensureDaiApi = async () => {
+	if (!window.google?.ima?.dai?.api?.StreamManager) await loadScript_default(GOOGLE_DAI_SDK_URL);
+	return window.google.ima.dai.api;
+};
+const ImaDaiPlugin = ({ requestOptionOverrides = {} } = {}) => {
+	const emitter = mitt();
+	const ref = {};
+	const reset = () => {
+		ref.progress = void 0;
+		ref.streamManager?.reset();
+		ref.streamManager = void 0;
+		ref.video = void 0;
+	};
+	const getStartTime = (startTime) => {
+		const startTimeInStreamTime = ref.streamManager.streamTimeForContentTime(startTime);
+		let earliestCuepoint = { start: startTimeInStreamTime };
+		while (earliestCuepoint !== null && earliestCuepoint.start !== 0) earliestCuepoint = ref.streamManager.previousCuePointForStreamTime(earliestCuepoint.start);
+		return earliestCuepoint?.start ?? startTimeInStreamTime;
+	};
+	return {
+		isActive: () => !!ref.streamManager,
+		load: async (manifestItem, { player, video, streamFormat, startTime }) => {
+			reset();
+			if (!manifestItem.ssai?.google_dai) return;
+			ref.video = video;
+			const { live: liveOptions, vod: vodOptions } = manifestItem.ssai.google_dai;
+			const daiApi = await ensureDaiApi();
+			if (!ref.adContainer) console.warn(`The 'adContainer' is '${ref.adContainer}'. Please provide it using 'ImaDai.setAdContainer', or the DAI SDK won't request skippable ADs. See: https://developers.google.com/interactive-media-ads/docs/sdks/html5/dai/reference/js/StreamManager#StreamManager`);
+			ref.streamManager = new daiApi.StreamManager(video, ref.adContainer);
+			pipeEvents(ref.streamManager, emitter, [daiApi.StreamEvent.Type.SKIPPABLE_STATE_CHANGED, daiApi.StreamEvent.Type.SKIPPED]);
+			/**
+			* To align with the MideaTailor, convert the cuepoint.start from the stream time to content time.
+			*/
+			ref.streamManager.addEventListener(daiApi.StreamEvent.Type.CUEPOINTS_CHANGED, (event) => {
+				const cuepointsInContentTime = event.getStreamData().cuepoints.map((cuepoint) => ({
+					start: ref.streamManager.contentTimeForStreamTime(cuepoint.start),
+					duration: cuepoint.end - cuepoint.start
+				}));
+				emitter.emit("cuepointsChanged", { cuepoints: cuepointsInContentTime });
+			});
+			/**
+			* We can't get the adProgressData from the event adBreakStarted, so we map the first call of adProgress to adBreakStarted.
+			*/
+			let isFirstAdProgressCalled = true;
+			ref.streamManager.addEventListener("adProgress", (event) => {
+				if (isFirstAdProgressCalled) {
+					emitter.emit("adBreakStarted", event);
+					isFirstAdProgressCalled = false;
+				} else emitter.emit("adProgress", event);
+			});
+			ref.streamManager.addEventListener("adBreakEnded", (event) => {
+				emitter.emit("adBreakEnded", event);
+				isFirstAdProgressCalled = true;
+			});
+			const requestOptions = {
+				apiKey: liveOptions?.api_key || vodOptions?.api_key,
+				contentSourceId: vodOptions?.content_source_id,
+				videoId: vodOptions?.video_id,
+				assetKey: liveOptions?.asset_key,
+				format: streamFormat,
+				...requestOptionOverrides
+			};
+			const streamRequest = Object.assign(liveOptions ? new daiApi.LiveStreamRequest() : new daiApi.VODStreamRequest(), requestOptions);
+			const url = await new Promise((resolve) => {
+				ref.streamManager.addEventListener(daiApi.StreamEvent.Type.LOADED, (e) => resolve(e.getStreamData().url));
+				ref.streamManager.requestStream(streamRequest);
+			});
+			player.on("metadata", ({ metadata }) => {
+				const TXXX = metadata.TXXX || metadata.properties.messageData;
+				ref.streamManager.onTimedMetadata({ TXXX });
+			});
+			ref.streamManager.addEventListener(daiApi.StreamEvent.Type.AD_PROGRESS, (e) => {
+				ref.progress = e.getStreamData().adProgressData;
+			});
+			return {
+				ssaiProvider: "DAI",
+				url,
+				startTime: getStartTime(startTime)
+			};
+		},
+		getPlaybackStatus: () => ref.streamManager && ref.video && {
+			currentTime: ref.streamManager.contentTimeForStreamTime(ref.video.currentTime),
+			duration: ref.streamManager.contentTimeForStreamTime(ref.video.duration),
+			...ref.progress && { adRemainingTime: ref.progress.duration - ref.progress.currentTime }
+		},
+		on: (name, listener) => emitter.on(name, listener),
+		reset,
+		handleSeek: (contentTime, seek) => {
+			snapback_default({
+				streamManager: ref.streamManager,
+				originTime: ref.video.currentTime,
+				seekTime: ref.streamManager.streamTimeForContentTime(contentTime),
+				seek
+			});
+		},
+		setAdContainer: (adContainer) => {
+			ref.adContainer = adContainer;
+		}
+	};
+};
+var ImaDai_default = ImaDaiPlugin;
+
+//#endregion
+//#region src/plugins/StallReload.js
+const wallTimeSeconds = () => Date.now() / 1e3;
+const StallReloadPlugin = ({ stallThresholdSeconds = 10 } = {}) => {
+	const state = {
+		lastVideoTime: 0,
+		lastTimer: 0,
+		lastUpdateSeconds: wallTimeSeconds()
+	};
+	const load = (_, { player, video, reload }) => {
+		clearInterval(state.lastTimer);
+		const checkStall = async () => {
+			if (!isLiveDuration(video.duration)) return;
+			if (video.paused || video.playbackRate === 0 || state.lastVideoTime !== video.currentTime || !(video.currentTime > 0)) {
+				state.lastUpdateSeconds = wallTimeSeconds();
+				state.lastVideoTime = video.currentTime;
+				return;
+			}
+			if (wallTimeSeconds() - state.lastUpdateSeconds > stallThresholdSeconds) {
+				console.warn("Stall detected, reload to resume");
+				await reload();
+				if (player.play) player.play();
+				else video.play();
+			}
+		};
+		state.lastVideoTime = video.currentTime;
+		state.lastTimer = setInterval(checkStall, stallThresholdSeconds / 8 * 1e3);
+		video.addEventListener("play", () => {
+			state.lastUpdateSeconds = wallTimeSeconds();
+		});
+	};
+	return { load };
+};
+var StallReload_default = StallReloadPlugin;
+
+//#endregion
+export { ImaDai_default as n, MediaTailor_default as r, StallReload_default as t };