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

package/dist/api-2BOrEA5d.mjs

@@ -0,0 +1,1057 @@
+import { t as DEBUG_OPTIONS } from "./debugUtil-IF7p5TSI.mjs";
+import { A as once, D as SeekOrigin, i as isLiveDuration, k as on, m as getSource, o as seek$1 } from "./mediaBindings-CoY60lQw.mjs";
+import { t as loadScript_default } from "./loadScript-Ct19kU9g.mjs";
+import mitt from "mitt";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region src/premium/timeline.js
+const getChapterIndex = (chapters, time) => chapters.reduce((currentIndex, chapter, index) => time >= chapter.startTime && chapter.startTime > chapters[currentIndex].startTime ? index : currentIndex, 0);
+const dispatchChapterEvents = ({ media, chapters = [], getTime }) => {
+	const state = {};
+	const updateChapter = (event) => {
+		if (media.webkitDisplayingFullscreen) return;
+		const next = getChapterIndex(chapters, getTime());
+		if (next !== state.currentChapterIndex) media.dispatchEvent(Object.assign(new CustomEvent("chapterChange"), {
+			action: /seek/.test(event?.type) ? "seek" : "",
+			chapterIndex: next,
+			chapter: chapters[next]
+		}));
+		state.currentChapterIndex = next;
+	};
+	const listeners = [
+		on(media, "seeking", updateChapter),
+		on(media, "timeupdate", updateChapter),
+		on(media, "seeked", updateChapter),
+		on(media, "webkitendfullscreen", updateChapter)
+	];
+	const checkInterval = setInterval(() => {
+		const timeToNext = (chapters[state.currentChapterIndex + 1]?.startTime - getTime() + .05) / media.playbackRate;
+		if (timeToNext >= 0 && timeToNext <= 1) state.timerId = setTimeout(updateChapter, timeToNext * 1e3);
+	}, 1e3);
+	return () => {
+		clearInterval(checkInterval);
+		clearInterval(state.timerId);
+		listeners.forEach((removeListener) => removeListener());
+	};
+};
+const getNextChapter = (chapters, currentTime) => chapters.find((chapter) => chapter.startTime > currentTime);
+const dispatchSkipEvent = (media, chapters, triggerMethod) => {
+	if (!media || chapters?.length < 1) return;
+	const skipFrom = media?.currentTime;
+	const skipTo = getNextChapter(chapters, media.currentTime)?.startTime;
+	media.dispatchEvent(Object.assign(new CustomEvent("skip"), {
+		skipFrom,
+		skipTo,
+		triggerMethod
+	}));
+};
+const goToNextChapter = (media, chapters) => {
+	const nextChapter = getNextChapter(chapters, media.currentTime);
+	if (nextChapter) seek$1(media, { player: {} }, nextChapter.startTime + .8);
+};
+const autoSkip = ({ media, chapters, autoSkipOpening = 3, autoplayNext = 10, onStateUpdate }) => {
+	const state = { maxPlayedTime: 0 };
+	let skipTimer;
+	const handleChapterChange = ({ action, chapter = {} }) => {
+		state.currentChapter = chapter.type;
+		if (chapter.type === "opening") {
+			const enableAutoSkip = action !== "seek" && media.currentTime > state.maxPlayedTime && autoSkipOpening;
+			state.maxPlayedTime = Infinity;
+			onStateUpdate({
+				display: "skip-opening",
+				autoSkip: enableAutoSkip
+			});
+			if (enableAutoSkip) skipTimer = setTimeout(() => {
+				dispatchSkipEvent(media, chapters, "auto_skip");
+				goToNextChapter(media, chapters);
+			}, autoSkipOpening * 1e3);
+		} else if (chapter.type === "ending") {
+			const autoSkipTime = action !== "seek" && !state.reachedEnding && autoplayNext;
+			onStateUpdate({
+				display: state.reachedEnding ? "none" : "skip-ending",
+				autoSkip: autoSkipTime,
+				chapter: "ending"
+			});
+			state.reachedEnding = true;
+		} else {
+			clearInterval(skipTimer);
+			onStateUpdate({ display: "none" });
+		}
+		state.maxPlayedTime = Math.max(media.currentTime, state.maxPlayedTime);
+	};
+	const listeners = [on(media, "chapterChange", handleChapterChange), on(media, "ended", () => {
+		state.chapter = "ended";
+		onStateUpdate({
+			display: "skip-ending",
+			autoSkip: autoplayNext,
+			chapter: "ended"
+		});
+		state.reachedEnding = true;
+	})];
+	return {
+		skip: () => {
+			onStateUpdate({ display: "none" });
+			goToNextChapter(media, chapters);
+		},
+		dismiss: () => {
+			clearInterval(skipTimer);
+			onStateUpdate({
+				chapter: state.chapter,
+				display: state.currentChapter === "opening" ? "skip-opening" : "none",
+				autoSkip: false
+			});
+		},
+		clear: () => {
+			onStateUpdate({ display: "none" });
+			state.reachedOpening = false;
+			clearInterval(skipTimer);
+			listeners.forEach((removeListener) => removeListener());
+		}
+	};
+};
+const getTimelineSegments = (chapters, { startTime, current, buffered, duration }) => (chapters.length === 0 ? [{ startTime }] : chapters).map((chapter, index) => {
+	const length = (chapters[index + 1]?.startTime || duration) - chapter.startTime;
+	return {
+		length: length / duration,
+		current: Math.min(Math.max(0, (current - chapter.startTime) / length), 1),
+		buffered: Math.min(Math.max(0, (buffered - chapter.startTime) / length), 1)
+	};
+});
+
+//#endregion
+//#region src/cast/framework.js
+const SENDER_URL = "https://www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1";
+const getContext = () => window.cast && cast.framework?.CastContext.getInstance();
+const getCastReceiverState = () => {
+	const context = getContext();
+	const castState = context.getCastState();
+	const currentSession = context.getCurrentSession();
+	const mediaTitle = currentSession.getMediaSession()?.media.metadata.title;
+	return {
+		castState,
+		deviceName: castState === "CONNECTED" && currentSession.getCastDevice().friendlyName,
+		mediaTitle,
+		...currentSession && {
+			volume: currentSession.getVolume(),
+			muted: currentSession.isMute()
+		}
+	};
+};
+const getMediaSession = () => {
+	return getContext()?.getCurrentSession()?.getMediaSession() || {};
+};
+const ensureSenderFramework = () => {
+	if (window.cast && cast.framework && window.chrome && chrome.cast) return Promise.resolve(getContext());
+	if (!window.loadSenderFramework) window.loadSenderFramework = new Promise((resolve, reject) => {
+		window.__onGCastApiAvailable = (isAvailable) => {
+			if (isAvailable) resolve(getContext());
+			else reject();
+		};
+		loadScript_default(SENDER_URL);
+	});
+	return window.loadSenderFramework;
+};
+const LIVE_EDGE_GAP = 10;
+const getLiveTime = () => {
+	if (typeof window === "undefined" || !window.cast) return {};
+	const mediaSession = getMediaSession();
+	if (!mediaSession.getEstimatedTime) return {};
+	const liveSeekableRange = mediaSession.media.metadata.sectionStartTimeInMedia && (mediaSession.getEstimatedLiveSeekableRange() || {});
+	if (!liveSeekableRange) return {
+		startTime: 0,
+		currentTime: mediaSession.getEstimatedTime(),
+		duration: mediaSession.media.duration
+	};
+	const actualTime = mediaSession.getEstimatedTime() - liveSeekableRange.end;
+	const currentTime = Math.abs(actualTime) < LIVE_EDGE_GAP ? 0 : actualTime;
+	const duration = liveSeekableRange.end - liveSeekableRange.start;
+	return {
+		startTime: -duration,
+		currentTime,
+		duration
+	};
+};
+const setAppId = ({ context, appId }) => {
+	context.setOptions({
+		receiverApplicationId: appId,
+		resumeSavedSession: true,
+		autoJoinPolicy: chrome.cast.AutoJoinPolicy.ORIGIN_SCOPED
+	});
+	return context;
+};
+const initSender = async ({ appId, ...options }) => {
+	(await ensureSenderFramework()).setOptions({
+		receiverApplicationId: appId,
+		resumeSavedSession: true,
+		autoJoinPolicy: chrome.cast.AutoJoinPolicy.ORIGIN_SCOPED,
+		...options
+	});
+};
+const connect = () => {
+	const context = getContext();
+	const currentSession = context.getCurrentSession();
+	if (currentSession) return Promise.resolve(currentSession);
+	return context.requestSession().then(() => context.getCurrentSession()).catch((e) => {
+		console.log(e);
+	});
+};
+const seek = (options) => {
+	const seconds = options.seconds || options;
+	const origin = options.origin || SeekOrigin.START;
+	const media = getMediaSession();
+	const startOverOffset = media.getEstimatedLiveSeekableRange()?.end || 0;
+	const currentTime = seconds + (origin === SeekOrigin.CURRENT ? media.getEstimatedTime() : 0) + startOverOffset;
+	media.seek(Object.assign(new chrome.cast.media.SeekRequest(), { currentTime }));
+};
+const setVolume = (volume) => getContext().getCurrentSession().setVolume(volume);
+const getCastState = () => {
+	const context = getContext();
+	const castState = context.getCastState();
+	const mediaSession = context.getCurrentSession()?.getMediaSession() || {};
+	return {
+		playbackState: castState === "CONNECTED" ? mediaSession.playerState : castState,
+		deviceName: context.getCurrentSession()?.getCastDevice().friendlyName,
+		title: mediaSession.media?.metadata?.title,
+		playingIndex: mediaSession.currentItemId,
+		queueSize: mediaSession.items?.length,
+		...getLiveTime()
+	};
+};
+const subscribeSessionState = (onChange) => {
+	const request = ensureSenderFramework().then(() => {
+		const { CAST_STATE_CHANGED } = cast.framework.CastContextEventType;
+		const { PLAYER_STATE_CHANGED, TITLE_CHANGED, MEDIA_INFO_CHANGED, CURRENT_TIME_CHANGED, DURATION_CHANGED, IS_PLAYING_BREAK_CHANGED, BREAK_CLIP_ID_CHANGED, CURRENT_BREAK_TIME_CHANGED } = cast.framework.RemotePlayerEventType;
+		const notifyChange = () => onChange(getCastState());
+		const context = getContext();
+		const player = new cast.framework.RemotePlayer();
+		const controller = new cast.framework.RemotePlayerController(player);
+		context.addEventListener(CAST_STATE_CHANGED, notifyChange);
+		const listeners = [
+			PLAYER_STATE_CHANGED,
+			TITLE_CHANGED,
+			MEDIA_INFO_CHANGED,
+			CURRENT_TIME_CHANGED,
+			DURATION_CHANGED,
+			IS_PLAYING_BREAK_CHANGED,
+			BREAK_CLIP_ID_CHANGED,
+			CURRENT_BREAK_TIME_CHANGED
+		].map((eventName) => {
+			controller.addEventListener(eventName, notifyChange);
+			return () => controller.removeEventListener(eventName, notifyChange);
+		});
+		notifyChange();
+		return listeners;
+	});
+	return () => request.then((listeners) => listeners.forEach((removeListener) => removeListener()));
+};
+const initializeSenderState = ({ context, setState, setCastState, getVolume: getVolume$1 }) => {
+	const handleCastStateChange = ({ castState }) => {
+		const currentSession = context.getCurrentSession();
+		setCastState({
+			castState,
+			deviceName: castState === "CONNECTED" && currentSession.getCastDevice().friendlyName
+		});
+	};
+	context.addEventListener(cast.framework.CastContextEventType.CAST_STATE_CHANGED, handleCastStateChange);
+	handleCastStateChange({ castState: context.getCastState() });
+	const player = new cast.framework.RemotePlayer();
+	const controller = new cast.framework.RemotePlayerController(player);
+	const remotePlayerEventType = cast.framework.RemotePlayerEventType;
+	controller.addEventListener(remotePlayerEventType.PLAYER_STATE_CHANGED, ({ value }) => {
+		setCastState({
+			playerState: value,
+			castingMedia: value !== "IDLE" ? getMediaSession().media : null
+		});
+	});
+	controller.addEventListener(remotePlayerEventType.TITLE_CHANGED, ({ value }) => setCastState({ mediaTitle: value }));
+	controller.addEventListener(remotePlayerEventType.MEDIA_INFO_CHANGED, ({ value }) => {
+		const { media } = getMediaSession() || { media: {} };
+		setCastState({
+			castingMedia: value,
+			...value ? value.customData && { customData: value.customData } : { customData: {} },
+			metadata: media.metadata,
+			seekEnabled: getMediaSession()?.supportedMediaCommands.includes("seek")
+		});
+	});
+	controller.addEventListener(remotePlayerEventType.DURATION_CHANGED, ({ value }) => setCastState({ duration: value }));
+	controller.addEventListener(remotePlayerEventType.CURRENT_TIME_CHANGED, ({ value }) => setState((current) => ({
+		...current,
+		progressTime: value
+	})));
+	controller.addEventListener(remotePlayerEventType.MEDIA_INFO_CHANGED, ({ value }) => setCastState({ streamType: value && value.streamType }));
+	controller.addEventListener(remotePlayerEventType.MEDIA_INFO_CHANGED, ({ value }) => {
+		const { activeTrackIds = [] } = getMediaSession() || { media: {} };
+		setCastState({
+			castingMedia: value,
+			activeTrackIds
+		});
+	});
+	controller.addEventListener(remotePlayerEventType.IS_PLAYING_BREAK_CHANGED, ({ value }) => setCastState({ isPlayingBreak: value }));
+	controller.addEventListener(remotePlayerEventType.BREAK_CLIP_ID_CHANGED, ({ value }) => setCastState({
+		breakClipId: value,
+		clickThroughUrl: (getMediaSession().media?.breakClips || []).find((item) => item.id === value)?.clickThroughUrl
+	}));
+	controller.addEventListener(remotePlayerEventType.CURRENT_BREAK_TIME_CHANGED, ({ value }) => {
+		setCastState({
+			currentBreakTime: value,
+			whenSkippable: player.whenSkippable
+		});
+	});
+	const subscribeVolumeChange$1 = (handleChange) => {
+		const listeners = [on(controller, remotePlayerEventType.VOLUME_LEVEL_CHANGED, () => handleChange(getVolume$1(context.getCurrentSession()))), on(controller, remotePlayerEventType.IS_MUTED_CHANGED, () => handleChange(getVolume$1(context.getCurrentSession())))];
+		return () => listeners.forEach((removeListener) => removeListener());
+	};
+	const getItem = (media, index) => {
+		const items = media.items || [];
+		return items[(items.length + index) % items.length] || {};
+	};
+	return {
+		connect: () => connect(),
+		stopCasting: () => context.endCurrentSession(true),
+		play: () => getMediaSession().play(new chrome.cast.media.PlayRequest()),
+		pause: () => getMediaSession().pause(new chrome.cast.media.PauseRequest()),
+		seek,
+		skipAd: () => controller.skipAd(),
+		hasPrevious: () => {
+			const media = getMediaSession() || {};
+			return media.currentItemId !== getItem(media, 0).itemId;
+		},
+		hasNext: () => {
+			const media = getMediaSession() || {};
+			return media.currentItemId !== getItem(media, -1).itemId;
+		},
+		changePreviousEpisode: () => new Promise((resolve, reject) => {
+			getMediaSession().queuePrev(resolve, reject);
+		}),
+		changeNextEpisode: () => new Promise((resolve, reject) => {
+			getMediaSession().queueNext(resolve, reject);
+		}),
+		subscribeVolumeChange: subscribeVolumeChange$1,
+		setVolume,
+		toggleMute: () => controller.muteOrUnmute()
+	};
+};
+const togglePlay = () => {
+	const player = new cast.framework.RemotePlayer();
+	return new cast.framework.RemotePlayerController(player).playOrPause();
+};
+const queuePrevious = () => getMediaSession()?.queuePrev();
+const queueNext = () => getMediaSession()?.queueNext();
+const getVolume = () => {
+	const session = getContext()?.getCurrentSession();
+	return session && {
+		volume: session.getVolume(),
+		muted: session.isMute()
+	};
+};
+const subscribeVolumeChange = (handleChange) => {
+	const player = new cast.framework.RemotePlayer();
+	const controller = new cast.framework.RemotePlayerController(player);
+	const { VOLUME_LEVEL_CHANGED, IS_MUTED_CHANGED } = cast.framework.RemotePlayerEventType;
+	const listeners = [on(controller, VOLUME_LEVEL_CHANGED, () => handleChange(getVolume())), on(controller, IS_MUTED_CHANGED, () => handleChange(getVolume()))];
+	return () => listeners.forEach((removeListener) => removeListener());
+};
+const toggleMute = () => {
+	const player = new cast.framework.RemotePlayer();
+	return new cast.framework.RemotePlayerController(player).muteOrUnmute();
+};
+const skipAd = () => {
+	const player = new cast.framework.RemotePlayer();
+	return new cast.framework.RemotePlayerController(player).skipAd();
+};
+const parseMediaTracks = ({ castingMediaTracks, activeTrackIds }) => {
+	const tracks = castingMediaTracks.map((track) => ({
+		type: track.type.toLowerCase(),
+		label: track.name || track.language,
+		value: track.trackId,
+		enabled: false,
+		trackId: track.trackId
+	}));
+	const audioTracks = tracks.filter((track) => track.type === "audio");
+	const subtitleTracks = tracks.filter((track) => track.type === "text");
+	const activeAudio = activeTrackIds.find((id) => audioTracks.some((track) => track.value === id)) || audioTracks[0]?.value;
+	const activeSubtitles = activeTrackIds.find((id) => subtitleTracks.some((track) => track.value === id));
+	return {
+		sections: [{
+			name: "audio",
+			title: "KKS.AUDIO",
+			items: audioTracks
+		}, {
+			name: "subtitles",
+			title: "KKS.SUBTITLES",
+			items: [{
+				label: "OFF",
+				value: "off"
+			}].concat(subtitleTracks)
+		}],
+		values: {
+			audio: activeAudio,
+			subtitles: activeSubtitles || "off"
+		}
+	};
+};
+const switchTracks = ({ audio, subtitles }) => window.cast && getMediaSession()?.editTracksInfo?.(new chrome.cast.media.EditTracksInfoRequest([audio, subtitles].filter((id) => id !== "off")));
+const subscribeCastState = (handleStateChange) => {
+	const waitFramework = ensureSenderFramework().then(() => {
+		const name = cast.framework.CastContextEventType.CAST_STATE_CHANGED;
+		const context = getContext();
+		const onChange = ({ castState }) => handleStateChange(castState);
+		handleStateChange(context.getCastState());
+		context.addEventListener(name, onChange);
+		return () => context.removeEventListener(name, onChange);
+	});
+	return () => waitFramework.then((removeListeners) => removeListeners());
+};
+const getMediaInfo = ({ manifestOptions, source, values }) => {
+	const { src, drm } = getSource(source, manifestOptions);
+	const { title, locale, audio, subtitles, modulesConfig } = values;
+	const customData = {
+		drm: {
+			...drm?.widevine,
+			licenseUrl: drm?.widevine?.licenseUri
+		},
+		locale,
+		audioTrack: {
+			language: audio,
+			name: audio
+		},
+		subtitleTrack: {
+			language: subtitles,
+			name: subtitles
+		},
+		modulesConfig
+	};
+	return Object.assign(new chrome.cast.media.MediaInfo(src), {
+		contentId: src,
+		metadata: { title },
+		customData
+	});
+};
+const startCastPlaylist = async (mediaInfos, onLoad, startIndex = 0) => {
+	const castSession = await connect();
+	const mediaItems = mediaInfos.map((media) => new chrome.cast.media.QueueItem(media));
+	const request = new chrome.cast.media.QueueLoadRequest(mediaItems);
+	request.startIndex = startIndex;
+	await onLoad?.(request);
+	return new Promise((resolve, reject) => {
+		castSession.getSessionObj().queueLoad(request, () => resolve(getCastReceiverState()), (failEvent) => {
+			console.log(failEvent);
+			return reject(failEvent);
+		});
+	});
+};
+const startCastVideo = async (source, onLoad, { title, locale, audio, subtitles, modulesConfig }) => {
+	const castSession = await connect();
+	const { src, drm } = source || {};
+	const customData = {
+		drm: {
+			...drm?.widevine,
+			licenseUrl: drm?.widevine?.licenseUri
+		},
+		locale,
+		audioTrack: {
+			language: audio,
+			name: audio
+		},
+		subtitleTrack: {
+			language: subtitles,
+			name: subtitles
+		},
+		modulesConfig
+	};
+	const media = Object.assign(new chrome.cast.media.MediaInfo(src), {
+		contentId: src,
+		metadata: { title },
+		customData
+	});
+	const request = new chrome.cast.media.LoadRequest(media);
+	await onLoad?.(request);
+	return castSession.loadMedia(request).then(() => getCastReceiverState()).catch((e) => {
+		console.log(e);
+		return Promise.reject(e);
+	});
+};
+const disconnect = async () => {
+	await ensureSenderFramework();
+	try {
+		getContext().endCurrentSession(true);
+	} catch (e) {
+		console.log(e);
+	}
+};
+const loadMedia = ({ source, contentType, contentId: paramContentId, sourceType, apiConfig, customData }) => {
+	const session = getContext().getCurrentSession();
+	if (!session) return "receiver_unavailable";
+	const sourceInfo = source && getSource(source);
+	const contentId = paramContentId || sourceInfo?.src;
+	const drm = sourceInfo?.drm && {
+		...sourceInfo.drm?.widevine,
+		licenseUrl: sourceInfo.drm?.widevine?.licenseUri
+	};
+	const request = new chrome.cast.media.LoadRequest(Object.assign(new chrome.cast.media.MediaInfo(contentId), {
+		contentId,
+		contentID: contentId,
+		customData: {
+			itemType: contentType,
+			...apiConfig,
+			customHeaders: apiConfig?.headers,
+			customQuery: apiConfig?.params,
+			mediaSource: sourceType,
+			...drm && { drm },
+			...customData
+		},
+		metadata: new chrome.cast.media.GenericMediaMetadata()
+	}));
+	const currentMedia = session?.getMediaSession()?.media || {};
+	if (contentId === currentMedia.contentId && contentType === currentMedia.customData?.itemType) return Promise.resolve();
+	return session.loadMedia(request).catch((e) => console.log(e));
+};
+const linkCast = ({ onChange, ...options }) => subscribeCastState((state) => {
+	if (state === "CONNECTED") loadMedia(options);
+	onChange?.(state);
+});
+
+//#endregion
+//#region src/util/uuidv4.js
+const uuidv4 = () => {
+	const crypto = window.crypto || window.msCrypto;
+	return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16));
+};
+var uuidv4_default = uuidv4;
+
+//#endregion
+//#region src/playerCore/playlogv2.js
+const modes = {
+	videos: "video",
+	lives: "live"
+};
+const logEventNames = {
+	playbackBegan: "video_playback_began",
+	playbackStarted: "video_playback_started",
+	playbackStopped: "video_playback_stopped",
+	playbackEnded: "video_playback_ended",
+	bufferingStarted: "video_buffering_started",
+	bufferingEnded: "video_buffering_ended",
+	playbackSpeedChange: "playback_speed_change",
+	seeked: "video_seeking_ended",
+	playbackError: "video_playback_error_occurred",
+	playing: "play",
+	paused: "pause",
+	rewind: "rewind",
+	forward: "forward",
+	speedSettingChange: "speed_setting_change",
+	previousEpisode: "previous_episode",
+	nextEpisode: "next_episode",
+	openSettings: "setting_page_entered",
+	closeSettings: "setting_page_exited",
+	adPlaybackStarted: "ad_playback_started",
+	adPlaybackStopped: "ad_playback_stopped",
+	skip: "op_skip"
+};
+const mapLogEvents = ({ video, session = video, version, playerName, getPlaybackStatus = () => video }) => {
+	const emitter = mitt();
+	const state = {
+		status: "init",
+		seeking: false,
+		playerStartTime: Date.now(),
+		moduleStartTime: Date.now(),
+		content: session.getContent?.() || {},
+		temporaryEvent: null
+	};
+	const commonProperties = () => ({
+		player_name: playerName,
+		playback_module_version: version,
+		playback_mode: modes[state.content.type],
+		playback_session_id: state.sessionId,
+		id: state.content.id,
+		name: state.content.title,
+		...state.content.type === "videos" && {
+			current_position: state.currentTime,
+			video_total_duration: state.duration
+		},
+		...state.content.type === "lives" && {
+			section_id: state.content.section?.id,
+			name_2: state.content.channelName,
+			live_offset: state.liveOffset || 0
+		},
+		SSAI: state.ssaiProvider || "None"
+	});
+	const dispatchStart = () => {
+		if (state.status === "started") return;
+		state.status = "started";
+		state.lastStartTime = video.currentTime;
+		state.temporaryEvent = state.isPlayingAd ? "adPlaybackStarted" : "playbackStarted";
+	};
+	const dispatchStop = () => {
+		if (state.status !== "started") return;
+		state.status = "stopped";
+		const played = video.currentTime - state.lastStartTime;
+		if (state.isPlayingAd) state.adPlayedDuration += played;
+		else state.playedDuration += played;
+		const eventName = state.isPlayingAd ? "adPlaybackStopped" : "playbackStopped";
+		const durationPropertyName = state.isPlayingAd ? "ad_played_duration" : "video_played_duration";
+		emitter.emit(eventName, {
+			...commonProperties(),
+			[durationPropertyName]: played
+		});
+	};
+	const registered = [
+		on(video, "error", (event) => {
+			emitter.emit("playbackError", {
+				module_error_code: event.error?.code || event.error?.data?.code,
+				...commonProperties()
+			});
+		}),
+		once(video, "playerStarted", () => {
+			state.playerStartTime = Date.now();
+		}),
+		on(video, "durationchange", () => {
+			if (!state.duration) state.duration = getPlaybackStatus().duration;
+		}),
+		once(video, "loadeddata", () => {
+			state.status = "began";
+			state.sessionId = uuidv4_default();
+			state.playedDuration = 0;
+			emitter.emit("playbackBegan", {
+				player_startup_time: (state.playerStartTime - state.moduleStartTime) / 1e3,
+				video_startup_time: (Date.now() - state.moduleStartTime) / 1e3,
+				...commonProperties()
+			});
+		}),
+		on(video, "playing", dispatchStart),
+		on(video, "waiting", () => {
+			if (!state.bufferingStartTime) {
+				emitter.emit("bufferingStarted", commonProperties());
+				state.bufferingStartTime = Date.now();
+			}
+		}),
+		on(video, "timeupdate", () => {
+			const status = getPlaybackStatus();
+			state.currentTime = status.currentTime;
+			if (state.content.type === "lives") state.liveOffset = status.liveOffset < 10 ? 0 : status.liveOffset;
+			if (state.bufferingStartTime) {
+				emitter.emit("bufferingEnded", {
+					buffering_second: (Date.now() - state.bufferingStartTime) / 1e3,
+					...commonProperties()
+				});
+				state.bufferingStartTime = void 0;
+			}
+			if (state.temporaryEvent && !state.seeking) {
+				emitter.emit(state.temporaryEvent, commonProperties());
+				state.temporaryEvent = null;
+			}
+		}),
+		on(video, "pause", dispatchStop),
+		on(video, "seeking", () => {
+			state.seeking = true;
+			state.seekingFrom = state.currentTime;
+		}),
+		on(video, "seeked", () => {
+			emitter.emit("seeked", {
+				seeking_from: state.seekingFrom,
+				seeking_to: video.currentTime,
+				...commonProperties()
+			});
+			state.seeking = false;
+		}),
+		on(video, "skip", (data) => {
+			emitter.emit("skip", {
+				skip_from: data.skipFrom,
+				skip_to: data.skipTo,
+				trigger_method: data.triggerMethod,
+				...commonProperties()
+			});
+		}),
+		on(video, "ratechange", () => {
+			if (video.playbackRate === 0) return;
+			emitter.emit("playbackSpeedChange", {
+				playbackSpeed: video.playbackRate,
+				...commonProperties()
+			});
+		}),
+		on(session, "sectionChange", () => {
+			dispatchStop();
+			state.content = session.getContent();
+			dispatchStart();
+		}),
+		once(video, "ended", () => {
+			if (state.status === "started") dispatchStop();
+			state.status = "init";
+			emitter.emit("playbackEnded", {
+				video_playback_ended_at_percentage: state.currentTime / state.duration,
+				video_total_played_duration: state.playedDuration,
+				...state.ssaiProvider && { ad_total_played_duration: state.adPlayedDuration },
+				...commonProperties()
+			});
+		}),
+		once(video, "loadedAdMetadata", (event) => {
+			state.ssaiProvider = event.data.provider;
+			state.adPlayedDuration = 0;
+		}),
+		on(session, "adBreakStarted", () => {
+			dispatchStop();
+			state.isPlayingAd = true;
+			if (!state.seeking) dispatchStart();
+		}),
+		on(session, "adBreakEnded", () => {
+			dispatchStop();
+			state.isPlayingAd = false;
+			if (!state.seeking) dispatchStart();
+		})
+	];
+	return {
+		addEventListener: (name, handler) => emitter.on(name, handler),
+		all: (handler) => emitter.on("*", handler),
+		emit: (name, { currentTime }, properties) => {
+			if (name in logEventNames) emitter.emit(name, {
+				current_position: currentTime,
+				...properties,
+				...commonProperties()
+			});
+		},
+		updateContent: (content) => {
+			state.content = content;
+		},
+		reset: () => registered.forEach((off) => off())
+	};
+};
+
+//#endregion
+//#region src/playbackSession/getCache.js
+const getCache = async (cache, key, { load, isValid }) => {
+	if (!cache) return load();
+	if (cache[key] && (!isValid || isValid(cache[key]))) return cache[key];
+	if (!cache[key]) cache[key] = {};
+	cache[key] = {
+		...cache[key],
+		...await load()
+	};
+	return cache[key];
+};
+var getCache_default = getCache;
+
+//#endregion
+//#region src/playbackSession/startSession.js
+const deepEqual = (current, updated) => JSON.stringify(current) === JSON.stringify(updated);
+const HEARTBEAT_INTERVAL_MS = 1e4;
+const UPDATE_INTERVAL_MS = 1e4;
+const isFreshCache = (content) => !content.end && Date.now() <= content.end_time * 1e3;
+let lastSession = Promise.resolve();
+const programRemainTime = (content, { media = {} }) => {
+	const programCurrentTime = isLiveDuration(media.duration) ? Date.now() / 1e3 : content.start_time + media.currentTime;
+	return content.end_time - programCurrentTime;
+};
+const startPlaybackSession = async (playbackApi, options = {}) => {
+	await Promise.race([lastSession, new Promise((resolve) => {
+		setTimeout(resolve, UPDATE_INTERVAL_MS / 2);
+	})]);
+	let unlockSession;
+	lastSession = new Promise((resolve) => {
+		unlockSession = resolve;
+	});
+	const emitter = mitt();
+	const { type, id, getCurrentTime, cache } = options;
+	const cacheKey = options.key || `${type}/${id}`;
+	const { onChangeContent, onSessionStart, onReset, heartbeatTime = HEARTBEAT_INTERVAL_MS, updateTime = UPDATE_INTERVAL_MS } = options;
+	const state = {
+		content: { end_time: Date.now() / 1e3 },
+		currentContent: { end_time: Date.now() / 1e3 }
+	};
+	const updateContent = async ({ useCache } = {}) => {
+		const content = await getCache_default(cache, cacheKey, {
+			load: () => playbackApi.getContent({
+				type,
+				id
+			}),
+			isValid: (data) => useCache && isFreshCache(data)
+		});
+		if (content.end) emitter.emit("liveEnd", content);
+		if (!state.content?.end_time && content?.end_time) return onReset({
+			reason: "program start",
+			sourceChange: true
+		});
+		const timeBeforeEnd = programRemainTime(state.currentContent, options) * 1e3;
+		if (timeBeforeEnd > 0 && timeBeforeEnd <= UPDATE_INTERVAL_MS) setTimeout(() => {
+			if (programRemainTime(state.currentContent, options) > .5) return;
+			if (isLiveDuration(options.media.duration)) updateContent({ useCache: true });
+			else onReset({
+				reason: "program end",
+				sourceChange: true
+			});
+		}, timeBeforeEnd);
+		if (!deepEqual(content, state.content)) {
+			state.content = content;
+			const skipUiUpdate = !useCache;
+			if (!skipUiUpdate) state.currentContent = content;
+			onChangeContent?.({
+				type,
+				...content,
+				skipUiUpdate
+			});
+		}
+	};
+	const waitForContent = Promise.race([updateContent({ useCache: true }), new Promise((resolve) => {
+		setTimeout(resolve, UPDATE_INTERVAL_MS);
+	})]);
+	const sessionInfo = await playbackApi.startPlayback({
+		type,
+		id
+	}).catch((error) => {
+		unlockSession();
+		return Promise.reject(error);
+	});
+	onSessionStart?.(sessionInfo);
+	const requestParams = {
+		type,
+		id,
+		token: sessionInfo.token
+	};
+	state.token = sessionInfo.token;
+	state.sources = (await getCache_default(cache, cacheKey, {
+		load: () => playbackApi.getPlaybackInfo({
+			type,
+			id,
+			token: state.token
+		}),
+		isValid: (data) => data.sources && isFreshCache(data)
+	})).sources;
+	let updateIntervalId;
+	if (type === "lives") updateIntervalId = setInterval(updateContent, updateTime);
+	let lastPlayedTime;
+	const updateLastPlayed = () => {
+		const currentTime = getCurrentTime?.();
+		if (currentTime >= 0 && lastPlayedTime !== currentTime) {
+			lastPlayedTime = currentTime;
+			playbackApi.updateLastPlayed({
+				...requestParams,
+				time: currentTime
+			});
+		}
+	};
+	if (type === "videos") updateIntervalId = setInterval(updateLastPlayed, updateTime);
+	const heartbeatIntervalId = setInterval(() => playbackApi.heartbeat(requestParams).catch((error) => {
+		if (/4\d\d/.test(error.response?.status)) {
+			clearInterval(heartbeatIntervalId);
+			onReset?.({
+				sourceChange: false,
+				reason: "Invalid token"
+			});
+		}
+	}), heartbeatTime);
+	const end = ({ preserveSource } = {}) => {
+		if (!preserveSource && cache?.[cacheKey]) cache[cacheKey].sources = void 0;
+		updateLastPlayed();
+		clearInterval(updateIntervalId);
+		clearInterval(heartbeatIntervalId);
+		clearTimeout(state.endTimeoutId);
+		emitter.emit("playbackEnded");
+		return playbackApi.endPlayback(requestParams).finally(unlockSession);
+	};
+	if (state.content?.end) end();
+	emitter.on("liveEnd", end);
+	await waitForContent;
+	return {
+		...state,
+		token: sessionInfo.token,
+		drmPortalUrl: DEBUG_OPTIONS.DRM_PROTAL_URL || sessionInfo.drm_portal_url,
+		updateLastPlayed,
+		end,
+		replaceApi: (replacement) => {
+			playbackApi = replacement;
+		}
+	};
+};
+var startSession_default = startPlaybackSession;
+
+//#endregion
+//#region src/playbackSession/api.js
+const waitMs = (time) => new Promise((resolve) => {
+	setTimeout(resolve, time);
+});
+const handleRequestError = (request, { onError, retryTimes = 0 }) => request().catch((error) => onError(error, {
+	retry: () => handleRequestError(request, {
+		onError,
+		retryTimes: retryTimes + 1
+	}),
+	retryTimes
+}));
+const ignoreMinorError = async (event, { retry, retryTimes } = {}) => {
+	console.warn(event);
+	if ((event.response?.message === "Network Error" || /502|503/.test(event.response?.status)) && retryTimes < 3) {
+		await waitMs(3e3);
+		return retry();
+	}
+	const url = new URL(event.response?.url || "http://unknown/");
+	if (/start$|info$|heartbeat$/.test(url.pathname)) return Promise.reject(event);
+	if (/end$/.test(url.pathname)) return Promise.resolve();
+	console.log("Ignore non-critical playback API fail", event);
+	return new Promise(() => {});
+};
+/** @param {Response} response */
+const handleFetchResponse = (response) => {
+	if (response.ok) return response.status === 200 ? response.json() : "";
+	return response.json().then((errorData) => {
+		const error = /* @__PURE__ */ new Error(`HTTP error status: ${response.status} ${errorData.message}`);
+		error.data = errorData;
+		error.response = response;
+		return Promise.reject(error);
+	});
+};
+const createApi = (config, { onError = ignoreMinorError } = {}) => {
+	const { host, accessToken, deviceId, headers, params } = config;
+	const getHeaders = () => ({
+		...accessToken && { Authorization: accessToken },
+		...deviceId && { "X-Device-ID": deviceId },
+		"Content-type": "application/json",
+		...headers
+	});
+	const request = (url, { method } = {}) => handleRequestError(() => fetch(`${url}?${new URLSearchParams(params).toString()}`, {
+		method,
+		headers: getHeaders()
+	}).then(handleFetchResponse), { onError });
+	const sessionRequest = (path, { method = "POST", type, id, token }) => handleRequestError(() => fetch(`${host}/sessions/${type}/${id}/playback/${deviceId}/${path}?${new URLSearchParams({
+		...params,
+		playback_token: token
+	}).toString()}`, {
+		method,
+		headers: getHeaders()
+	}).then(handleFetchResponse), { onError });
+	return {
+		config,
+		getContent: ({ type, id }) => request(`${host}/${type}/${id}`, {}),
+		startPlayback: ({ type, id }) => request(`${host}/sessions/${type}/${id}/playback/${deviceId}/start`, { method: "POST" }),
+		getPlaybackInfo: ({ type, id, token }) => sessionRequest("info", {
+			method: "GET",
+			type,
+			id,
+			token
+		}),
+		heartbeat: ({ type, id, token }) => sessionRequest("heartbeat", {
+			type,
+			id,
+			token
+		}),
+		updateLastPlayed: ({ type, id, token, time }) => sessionRequest(`position/${Math.floor(time)}`, {
+			type,
+			id,
+			token
+		}),
+		endPlayback: ({ type, id, token }) => sessionRequest("end", {
+			type,
+			id,
+			token
+		})
+	};
+};
+const getStreamInfo = (sources = [], { type = "", licenseUri, certificateUri = `${licenseUri}/fairplay_cert`, licenseHeaders: headers, thumbnailEnabled } = {}) => {
+	const activeSource = sources.find((source) => (source.subdub || source.type || "").toLowerCase() === type) || sources[0];
+	return (activeSource?.manifests || []).map((manifest) => ({
+		...manifest,
+		type: manifest.protocol,
+		src: manifest.url,
+		drm: {
+			fairplay: {
+				licenseUri,
+				certificateUri,
+				headers
+			},
+			widevine: {
+				licenseUri,
+				headers
+			},
+			playready: {
+				licenseUri,
+				headers
+			}
+		},
+		qualityOptions: manifest.resolutions.map(({ height }) => ({
+			label: height,
+			value: height,
+			options: { maxHeight: height }
+		}))
+	})).concat(thumbnailEnabled && activeSource?.thumbnail_seeking_url ? {
+		type: "thumbnail",
+		src: activeSource.thumbnail_seeking_url
+	} : []);
+};
+const getOpeningSkipChapters = (data) => {
+	const { opening_begin_time: opBegin, opening_end_time: opEnd } = data.time || {};
+	if (opBegin !== null && opEnd !== null && opEnd - opBegin > 3) return [{
+		type: "opening",
+		startTime: opBegin + .2
+	}, {
+		name: "part a",
+		startTime: opEnd
+	}];
+	return [];
+};
+const getContentInfo = (data) => ({
+	title: data.title,
+	channelTitle: data.subtitle,
+	channelIcon: data.channel_info?.image_url,
+	end: data.end,
+	section: {
+		id: data.section_id,
+		start: data.start_time,
+		end: data.end_time
+	},
+	previous: data.prev_video,
+	next: data.next_video,
+	startTime: data.time?.last_position,
+	seekable: data.seekable,
+	chapters: [
+		{
+			type: "intro",
+			startTime: 0
+		},
+		...getOpeningSkipChapters(data),
+		data.time?.end_start_position && {
+			type: "ending",
+			startTime: data.time.end_start_position
+		}
+	].filter(Boolean),
+	skipUiUpdate: data.skipUiUpdate
+});
+
+//#endregion
+export { switchTracks as A, setVolume as C, subscribeCastState as D, startCastVideo as E, dispatchSkipEvent as F, getTimelineSegments as I, __commonJSMin as L, togglePlay as M, autoSkip as N, subscribeSessionState as O, dispatchChapterEvents as P, __exportAll as R, setAppId as S, startCastPlaylist as T, loadMedia as _, getCache_default as a, queuePrevious as b, uuidv4_default as c, ensureSenderFramework as d, getLiveTime as f, linkCast as g, initializeSenderState as h, startSession_default as i, toggleMute as j, subscribeVolumeChange as k, connect as l, initSender as m, getContentInfo as n, logEventNames as o, getMediaInfo as p, getStreamInfo as r, mapLogEvents as s, createApi as t, disconnect as u, parseMediaTracks as v, skipAd as w, seek as x, queueNext as y, __toESM as z };