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

package/dist/loadScript-Ct19kU9g.mjs

@@ -0,0 +1,13 @@
+//#region src/util/loadScript.js
+const loadScript = (url) => new Promise((resolve) => {
+	const script = Object.assign(document.createElement("script"), {
+		async: true,
+		src: url
+	});
+	script.addEventListener("load", resolve);
+	document.body.appendChild(script);
+});
+var loadScript_default = loadScript;
+
+//#endregion
+export { loadScript_default as t };

package/dist/mediaBindings-CoY60lQw.mjs

@@ -0,0 +1,542 @@
+import UAParser from "ua-parser-js";
+
+//#region src/util/events.js
+const on = (target, name, handler, ...rest) => {
+	target.addEventListener(name, handler, ...rest);
+	return () => target.removeEventListener(name, handler, ...rest);
+};
+const once = (target, name, handler) => {
+	const oneTime = (...args) => {
+		handler(...args);
+		target.removeEventListener(name, oneTime);
+	};
+	target.addEventListener(name, oneTime);
+	return () => target.removeEventListener(name, oneTime);
+};
+const waitFor = (check, handler) => {
+	const checkInterval = setInterval(() => {
+		if (check()) {
+			clearInterval(checkInterval);
+			handler();
+		}
+	}, 50);
+	return () => clearInterval(checkInterval);
+};
+const dispatchCustomEvent = (element, name, detail) => {
+	if (element && typeof element.dispatchEvent === "function") return element.dispatchEvent(new CustomEvent(name, { detail }));
+	else console.error("The media element is undefined or does not have the dispatchEvent method");
+};
+
+//#endregion
+//#region src/Enum.js
+const LanguageCode = {
+	EN: "en",
+	JA: "ja",
+	ZHTW: "zh-TW"
+};
+const EnvironmentErrorName = {
+	NOT_SUPPORT_DEVICE: "KKS.ERROR.DEVICE_IS_NOT_SUPPORTED",
+	NOT_SUPPORT_OS: "KKS.ERROR.OS_IS_NOT_SUPPORTED",
+	NOT_SUPPORT_OS_VERSION: "KKS.ERROR.PLEASE_UPGRADE_OS",
+	NOT_SUPPORT_BROWSER: "KKS.ERROR.BROWSER_IS_NOT_SUPPORTED",
+	NOT_SUPPORT_BROWSER_VERSION: "KKS.ERROR.PLEASE_UPGRADE_BROWSER"
+};
+const SeekOrigin = {
+	START: "START",
+	CURRENT: "CURRENT"
+};
+const CastState = {
+	NO_DEVICES_AVAILABLE: "NO_DEVICES_AVAILABLE",
+	CONNECTED: "CONNECTED",
+	CONNECTING: "CONNECTING",
+	NOT_CONNECTED: "NOT_CONNECTED"
+};
+const ItemType = {
+	VIDEOS: "videos",
+	LIVES: "lives"
+};
+
+//#endregion
+//#region src/util/environment.js
+const parser = new UAParser();
+function getOS() {
+	return parser.getOS();
+}
+function getDevice() {
+	const device = parser.getDevice();
+	const osName = getOS().name;
+	if (device.type === void 0 && osName === "Android") device.type = "tablet";
+	return device;
+}
+function getBrowser() {
+	return parser.getBrowser();
+}
+const isSafari = () => /^((?!chrome|android|X11|Linux).)*(safari|iPad|iPhone|Version)/i.test(navigator.userAgent);
+function needNativeHls() {
+	return /android|X11|Linux/i.test(navigator.userAgent) || /firefox/i.test(navigator.userAgent) ? "" : isSafari() ? "maybe" : document.createElement("video").canPlayType("application/vnd.apple.mpegURL");
+}
+const isDesktop = () => !getDevice().type;
+const isIOS = () => /iPad|iPhone|iPod/.test(navigator.platform) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1;
+function compareVersion(v1, v2) {
+	if (!/\d+(\.\d+)*/.test(v1)) throw Error(`the version format ${v1} is wrong`);
+	if (!/\d+(\.\d+)*/.test(v2)) throw Error(`the version format ${v2} is wrong`);
+	const v1parts = v1.split(".").map((p) => Number(p));
+	const v2parts = v2.split(".").map((p) => Number(p));
+	for (let i = 0, I = Math.max(v1parts.length, v2parts.length); i < I; i++) if (v1parts[i] !== v2parts[i]) return (v1parts[i] || 0) - (v2parts[i] || 0);
+	return 0;
+}
+const validateEnvironment = (supportEnvironmentList = []) => {
+	if (supportEnvironmentList.length === 0) return;
+	const device = getDevice();
+	const os = getOS();
+	const browser = getBrowser();
+	const toUnique = (list) => Array.from(new Set(list));
+	const validators = [
+		{
+			filter: ({ device: { name, type } }) => name === "*" || type === "desktop" && device.type === void 0 || type === device.type,
+			errorName: EnvironmentErrorName.NOT_SUPPORT_DEVICE,
+			getErrorProps: (list) => ({ allowDevices: toUnique(list.map((env) => env.device.type)) })
+		},
+		{
+			filter: ({ os: { name } }) => name === "*" || name === os.name,
+			errorName: EnvironmentErrorName.NOT_SUPPORT_OS,
+			getErrorProps: (list) => ({ allowOSs: toUnique(list.map((env) => env.os.name)) })
+		},
+		{
+			filter: ({ os: { version } }) => version === "*" || compareVersion(os.version, version) >= 0,
+			errorName: EnvironmentErrorName.NOT_SUPPORT_OS_VERSION,
+			getErrorProps: (list) => ({ minVersion: list[0].os.version })
+		},
+		{
+			filter: ({ browser: { name } }) => name === browser.name,
+			errorName: EnvironmentErrorName.NOT_SUPPORT_BROWSER,
+			getErrorProps: (list) => ({ allowBrowsers: toUnique(list.map((env) => env.browser.name)) })
+		},
+		{
+			filter: ({ browser: { version } }) => compareVersion(browser.version, version) >= 0,
+			errorName: EnvironmentErrorName.NOT_SUPPORT_BROWSER_VERSION,
+			getErrorProps: (list) => ({ minVersion: list[0].browser.version })
+		}
+	];
+	let scopes = supportEnvironmentList;
+	for (let i = 0; i < validators.length; i++) {
+		const validator = validators[i];
+		const newScopes = scopes.filter(validator.filter);
+		if (newScopes.length === 0) return {
+			name: validator.errorName,
+			...validator.getErrorProps(scopes)
+		};
+		scopes = newScopes;
+	}
+};
+const havePointer = () => {
+	if (havePointer.memo) return havePointer.memo;
+	havePointer.memo = typeof window !== "undefined" && ["(hover: hover) and (pointer: fine)", "not all and (any-pointer: coarse)"].every((query) => window.matchMedia(query).matches);
+	return havePointer.memo;
+};
+
+//#endregion
+//#region src/playerCore/source.js
+const protocolExtensions = {
+	hls: "m3u8",
+	dash: "mpd"
+};
+const mimeTypes = {
+	hls: "application/x-mpegurl",
+	dash: "application/dash+xml"
+};
+const matchType = (source, manifestType) => source.type?.toLowerCase().includes(manifestType) || source.type?.toLowerCase() === mimeTypes[manifestType] || (source.src || source)?.endsWith?.(protocolExtensions[manifestType]);
+const getDrmOptions$1 = (fallbackDrm) => {
+	if (!fallbackDrm?.url) return;
+	const drmOptions = {
+		licenseUri: fallbackDrm.url,
+		headers: fallbackDrm.headers
+	};
+	return {
+		widevine: drmOptions,
+		fairplay: {
+			...drmOptions,
+			certificateUri: `${fallbackDrm.url}/fairplay_cert`,
+			...fallbackDrm.fairplay
+		},
+		playready: drmOptions
+	};
+};
+/**
+* @typedef {{src: string, type: string}} SourceObject
+* @typedef {{hls: string, dash: string}} SourceObjectAlt backward compatiable form
+*
+* @param {SourceObject[]|SourceObject|SourceObjectAlt|string} sourceOptions
+* @param {{preferManifestType?: ('dash'|'hls'|'platform')}} options
+* @return {{src: string, type: string, drm: Object}}
+*/
+const getSource = (sourceOptions, { preferManifestType, fallbackDrm } = {}) => {
+	if (sourceOptions.dash || sourceOptions.hls) {
+		const { dash, hls } = sourceOptions;
+		return getSource([hls && {
+			src: hls,
+			type: mimeTypes.hls
+		}, dash && {
+			src: dash,
+			type: mimeTypes.dash
+		}].filter(Boolean), {
+			preferManifestType,
+			fallbackDrm
+		});
+	}
+	if (!Array.isArray(sourceOptions)) return getSource([sourceOptions], {
+		preferManifestType,
+		fallbackDrm
+	});
+	if (fallbackDrm) return getSource(sourceOptions.map((option) => ({
+		...option.src ? option : { src: option },
+		drm: getDrmOptions$1(fallbackDrm)
+	})), { preferManifestType });
+	const targetType = preferManifestType !== "platform" ? preferManifestType : isSafari() ? "hls" : "dash";
+	const matched = sourceOptions.find((source) => matchType(source, targetType));
+	const selected = matched || sourceOptions[0];
+	if (!selected) return;
+	const type = matched && preferManifestType === "hls" && mimeTypes.hls;
+	return {
+		...selected.src ? selected : { src: selected },
+		type
+	};
+};
+const getSourceText = (source) => [].concat(source).filter((item) => item.type === "text/vtt");
+
+//#endregion
+//#region src/playerCore/drm.js
+const keySystems = {
+	widevine: "com.widevine.alpha",
+	fairplay: "com.apple.fps.1_0",
+	playready: "com.microsoft.playready"
+};
+const getDrmOptions = (source) => {
+	return [source.drm && Object.entries(source.drm).reduce((result, [keySystemId, options]) => {
+		const uri = typeof options === "string" ? options : options.licenseUri;
+		if (uri) {
+			const keySystemName = keySystems[keySystemId] || keySystemId;
+			result.servers[keySystemName] = uri;
+			const { headers, certificateUri } = options;
+			const advanced = [headers && { headers }, certificateUri && { serverCertificateUri: certificateUri }].filter(Boolean);
+			if (advanced.length > 0) result.advanced[keySystemName] = Object.assign({}, ...advanced);
+		}
+		return result;
+	}, {
+		servers: {},
+		advanced: {}
+	}), { drm: source.drm && Object.entries(source.drm).reduce((result, [keySystemId, options]) => {
+		const keySystemName = keySystems[keySystemId] || keySystemId;
+		if (options.headers || options.certificateHeaders) result[keySystemName] = {
+			headers: options.headers,
+			...options.certificateHeaders && { certificateHeaders: options.certificateHeaders }
+		};
+		return result;
+	}, {}) }];
+};
+
+//#endregion
+//#region src/playerCore/mediaBindings.js
+const LIVE_EDGE_GAP = 10;
+const SHAKA_LIVE_DURATION = 4294967296;
+const isLiveDuration = (duration) => duration >= SHAKA_LIVE_DURATION;
+const isEnded = (media) => !isLiveDuration(media.initialDuration) && media.initialDuration - media.currentTime < 1;
+const isBuffered = (media) => isSafari() || Array.from({ length: media.buffered.length }, (_, index) => ({
+	start: media.buffered.start(index),
+	end: media.buffered.end(index)
+})).some((range) => range.start <= media.currentTime && media.currentTime <= range.end + 1);
+const getLiveTime = (media, { player }) => {
+	const now = Date.now() / 1e3;
+	const currentOffset = media.currentTime - media.defaultLiveOffset - now;
+	const seekDuration = media.seekDurationDiff + now;
+	const { start, end } = player.seekRange();
+	return {
+		streamType: "live",
+		startTime: -seekDuration,
+		currentTime: currentOffset < -LIVE_EDGE_GAP ? currentOffset : 0,
+		duration: end - start > 5 * LIVE_EDGE_GAP ? seekDuration : 0
+	};
+};
+const getMediaTime = (media, { player, plugins = [] }) => {
+	const { duration, ...data } = Object.assign(isLiveDuration(media.initialDuration) ? getLiveTime(media, {
+		player,
+		plugins
+	}) : {
+		currentTime: media.currentTime,
+		bufferTime: Math.max(...Array.from({ length: media.buffered.length }, (_, index) => media.buffered.end(index))),
+		duration: media.initialDuration
+	}, ...plugins.map((plugin) => plugin.getPlaybackStatus?.()));
+	return {
+		...data,
+		...(isLiveDuration(media.initialDuration) || Math.abs(media.duration - media.initialDuration) < .5) && { duration }
+	};
+};
+const HAVE_METADATA = 1;
+const getCurrentPlaybackState = (media) => media.autoplay ? "playing" : "paused";
+const subscribePlaybackState = (media, updateState, { iOSFullscreenDetectThreshold = 500 } = {}) => {
+	const lastUpdate = {
+		state: "",
+		time: 0
+	};
+	const updateIfChanged = (event, state) => {
+		if (media.currentTime > 0x9184e72a000) return;
+		lastUpdate.time = media.currentTime;
+		lastUpdate.eventTime = Date.now();
+		lastUpdate.eventType = event.type;
+		if (state !== lastUpdate.state) {
+			lastUpdate.state = state;
+			lastUpdate.batched = media.webkitDisplayingFullscreen;
+			if (!lastUpdate.batched) updateState(event, state);
+		}
+	};
+	const updateBufferingState = (event) => {
+		if (!media.paused && !media.ended) updateIfChanged(event, "buffering");
+	};
+	const updatePlaybackTime = (event) => {
+		if (!media.paused && isBuffered(media) && media.currentTime - lastUpdate.time > .01) updateIfChanged(event, "playing");
+	};
+	const updateEnd = (event) => {
+		if (event.type === "emptied" && lastUpdate.state !== "loading") {
+			updateIfChanged(event, "emptied");
+			return true;
+		}
+		if (isEnded(media) || event.type === "ended") {
+			updateIfChanged(event, "ended");
+			return true;
+		}
+	};
+	const registered = [
+		on(media, "error", (event) => updateIfChanged(event, "error")),
+		on(media, "waiting", updateBufferingState),
+		on(media, "loadsource", (event) => updateIfChanged(event, "loading")),
+		on(media, "loadedmetadata", (event) => setTimeout(() => {
+			if (media.paused && !(media.readyState > HAVE_METADATA)) updateIfChanged(event, getCurrentPlaybackState(media));
+		}, 1500)),
+		on(media, "loadeddata", (event) => setTimeout(() => {
+			if (media.paused && !event.defaultPrevented) updateIfChanged(event, getCurrentPlaybackState(media));
+		}, 1)),
+		on(media, "canplay", (event) => {
+			if (media.paused && (lastUpdate.state !== "loading" || isIOS())) updateIfChanged(event, getCurrentPlaybackState(media));
+			updatePlaybackTime(event);
+		}),
+		on(media, "pause", (event) => {
+			if (Date.now() - lastUpdate.endFullscreenAt < 5 * iOSFullscreenDetectThreshold) {
+				lastUpdate.endFullscreenAt = 0;
+				media.play();
+				console.debug("Ignore pause from iOS exit fullscreen");
+				return;
+			}
+			if (!updateEnd(event)) updateIfChanged(event, "paused");
+		}),
+		on(media, "seeking", updateBufferingState),
+		on(media, "seeked", (event) => {
+			if (lastUpdate.state === "loading") updateIfChanged(event, getCurrentPlaybackState(media));
+		}),
+		on(media, "timeupdate", updatePlaybackTime),
+		on(media, "ended", updateEnd),
+		on(media, "emptied", updateEnd),
+		on(media, "webkitendfullscreen", (event) => {
+			if (lastUpdate.state === "paused" && Date.now() - lastUpdate.eventTime < iOSFullscreenDetectThreshold) {
+				lastUpdate.endFullscreenAt = Date.now();
+				waitFor(() => !media.webkitDisplayingFullscreen, () => updateState(event, "playing"));
+			} else updateState(event, lastUpdate.state);
+		})
+	];
+	return () => registered.forEach((off) => off());
+};
+const seek = async (media, { player, plugins = [] }, time, issuer) => {
+	if (media.readyState < HAVE_METADATA) await new Promise((resolve) => {
+		media.addEventListener("loadeddata", resolve, { once: true });
+	});
+	const seekPlugin = plugins.find((plugin) => typeof plugin.handleSeek === "function" && plugin.isActive());
+	const seekInternal = (seekTime) => {
+		if (seekTime <= media.duration + 7 && seekTime >= media.duration - 1) return seekInternal(media.duration - 1.1);
+		player.shouldPlayFromEdge = false;
+		const seekOrigin = player.isLive?.() ? media.defaultLiveOffset + Date.now() / 1e3 : 0;
+		player.seek?.(seekTime, issuer);
+		if (Math.abs(seekTime) <= LIVE_EDGE_GAP && seekOrigin !== 0) player.goToLive();
+		else media.currentTime = seekTime + seekOrigin;
+		once(media, "seeked", () => {
+			if (Math.abs(seekTime + seekOrigin - media.currentTime) > .5) media.currentTime = seekTime + seekOrigin;
+		});
+	};
+	if (seekPlugin) seekPlugin.handleSeek(time, seekInternal);
+	else seekInternal(time);
+};
+const load = async (media, { player, startTime, plugins = [] }, source) => {
+	const preferred = getSource(source, { preferManifestType: "platform" });
+	if (player.lastSrc === preferred?.src) {
+		console.info("src is unchanged, skip load", preferred.src);
+		return;
+	}
+	player.lastSrc = preferred?.src;
+	media.dispatchEvent(new CustomEvent("loadsource"));
+	const merged = await plugins.reduce(async (loadChain, plugin) => {
+		const currentSource = await loadChain;
+		const overrides = await plugin.load?.(currentSource, {
+			video: media,
+			player,
+			source: currentSource,
+			startTime,
+			streamFormat: source.type,
+			reload: async () => {
+				const restoreMuted = player.isMuted && { muted: player.isMuted() };
+				player.lastSrc = "";
+				await load(media, {
+					player,
+					startTime,
+					plugins
+				}, source);
+				if (restoreMuted) player[restoreMuted.muted ? "mute" : "unmute"]();
+			}
+		});
+		return overrides ? {
+			...currentSource,
+			...overrides.url && { src: overrides.url },
+			...overrides.startTime >= 0 && { startTime: overrides.startTime }
+		} : currentSource;
+	}, {
+		...preferred,
+		startTime
+	});
+	media.addEventListener("durationchange", () => {
+		media.initialDuration = media.duration;
+	}, { once: true });
+	once(media, "loadeddata", () => {
+		const seekToStart = (delay = 1) => {
+			if (merged.startTime > 0 || merged.startTime < 0) setTimeout(() => seek(media, {
+				player,
+				plugins
+			}, merged.startTime), delay);
+		};
+		if (player.isLive()) {
+			player.shouldPlayFromEdge = player.isLive() && !(merged.startTime < 0);
+			once(media, "timeupdate", () => {
+				player.shouldPlayFromEdge = false;
+				const { start, end } = player.seekRange();
+				media.defaultLiveOffset = media.currentTime - Date.now() / 1e3;
+				media.seekDurationDiff = end - start - Date.now() / 1e3;
+				seekToStart();
+			});
+		} else seekToStart();
+	});
+	const [drmOptions, extensions] = getDrmOptions(preferred);
+	player.configure({ drm: drmOptions });
+	player.configureExtensions(extensions);
+	let loadStartTime;
+	if (merged.type !== "application/x-mpegurl") loadStartTime = merged.startTime;
+	return player.unload().then(() => player.load(merged.src, loadStartTime, merged.type)).then((loadResult) => {
+		getSourceText(source).forEach(({ src, language = "en", type = "text/vtt", label = language }) => player.addTextTrackAsync(src, language, "subtitles", type, "", label).catch((error) => console.warn("Failed to add text track", error)));
+		return loadResult;
+	}).catch((error) => {
+		media.dispatchEvent(Object.assign(new CustomEvent("error"), { error }));
+	});
+};
+const waitMediaReady = (media) => media.readyState >= HAVE_METADATA || new Promise((resolve) => {
+	media.addEventListener("loadedmetadata", resolve, { once: true });
+});
+const toggleMute = (media) => {
+	media.muted = !media.muted;
+	if (!media.muted) media.volume = Math.max(media.volume, .05);
+};
+const setVolume = (media, { player }, level) => {
+	const capped = Math.max(0, Math.min(level, 1));
+	media.muted = capped <= 0;
+	if (capped > 0) {
+		player?.setVolume?.(capped * 100);
+		media.volume = capped;
+	}
+	if (capped <= 0) player?.mute?.();
+};
+const syncPlaybackState = async (media, { player, liveResume }, target) => {
+	if (media.webkitDisplayingFullscreen || media.paused === (target === "paused")) return;
+	await player?.pendingOperation?.catch(() => 1);
+	if (target === "paused") {
+		media.autoplay = false;
+		if (player) player.pendingOperation = new Promise((resolve) => {
+			once(media, "pause", resolve);
+			setTimeout(resolve, 1);
+		});
+		return media.pause();
+	}
+	await waitMediaReady(media);
+	if (isEnded(media)) seek(media, { player }, 0);
+	if (media.paused) {
+		media.autoplay = true;
+		const { streamType, duration, currentTime } = getMediaTime(media, { player });
+		if (streamType === "live" && (liveResume || player.shouldPlayFromEdge || duration === 0) && currentTime < 0) seek(media, { player }, 0);
+		player.play?.().catch((error) => console.warn(error));
+		player.pendingOperation = media.play().catch((error) => {
+			media.autoplay = false;
+			media.dispatchEvent(new CustomEvent("pause"));
+			console.log("autoplay blocked", error);
+			return Promise.reject(error);
+		});
+		return player.pendingOperation;
+	}
+};
+const setPlaybackRate = (media, { player }, rate) => {
+	if (!rate) return;
+	player?.setPlaybackSpeed?.(rate);
+	media.playbackRate = rate;
+};
+const getTextTracks = (_, { player }) => {
+	if (!player) return [];
+	return (player.getTextTracks?.() || []).map((track) => {
+		const label = track.label?.trim() || track.language;
+		const id = `${track.language}:${label}`;
+		return {
+			...track,
+			label,
+			type: "subtitles",
+			selected: player.isTextTrackVisible() ? track.active : false,
+			value: {
+				id,
+				label,
+				language: track.language
+			}
+		};
+	}).filter((track) => track.label !== "unknown" && track.language && !/^un/i.test(track.language));
+};
+const textTrackOptionOff = {
+	label: "none",
+	language: "none"
+};
+const textTrackLabel = "playcraft-text-track";
+/** @param media HTMLMediaElement */
+const syncTextTrack = (media, { player }, selected) => {
+	if (!media) return;
+	const { label, language, textTracks = [] } = selected === textTrackOptionOff.label ? textTrackOptionOff : selected;
+	const cues = textTracks.find((track) => track.mode === "showing" && track.cues?.length > 0)?.cues;
+	let customTextTrack = Array.from(media.textTracks).find((track) => track.label === textTrackLabel);
+	Array.from(customTextTrack?.cues || []).forEach((cue) => customTextTrack.removeCue(cue));
+	player.setTextTrackVisibility(true);
+	if (cues) {
+		player?.setTextTrackVisibility(false);
+		if (!customTextTrack) customTextTrack = media.addTextTrack("subtitles", textTrackLabel);
+		Array.from(cues).forEach((cue) => customTextTrack.addCue(new VTTCue(cue.startTime, cue.endTime, cue.text)));
+		customTextTrack.mode = "showing";
+		return;
+	}
+	if (customTextTrack) customTextTrack.mode = "hidden";
+	const matchedTrack = getTextTracks(media, { player }).find((t) => (!language || t.language === language) && (!label || t.label === label));
+	if (matchedTrack) {
+		player?.selectTextTrack(matchedTrack);
+		return;
+	}
+	player.setTextTrackVisibility(false);
+	if (!/off|none/i.test(label + language)) console.warn(`turn off text track: ${label} ${language} is not found`);
+	return media.textTracks?.addEventListener && once(media.textTracks, "change", () => player.setTextTrackVisibility(false));
+};
+const setAudioTrack = (_, { player }, next) => {
+	if (!next || !player) return;
+	try {
+		player.selectAudioLanguage(next.language);
+		if (next.label) player.selectVariantsByLabel(next.label);
+	} catch (error) {
+		console.warn("Unable to set audio", error, next);
+	}
+};
+
+//#endregion
+export { once as A, validateEnvironment as C, SeekOrigin as D, LanguageCode as E, dispatchCustomEvent as O, needNativeHls as S, ItemType as T, getOS as _, load as a, isIOS as b, setPlaybackRate as c, syncPlaybackState as d, syncTextTrack as f, getBrowser as g, mimeTypes as h, isLiveDuration as i, on as k, setVolume as l, getSource as m, getTextTracks as n, seek as o, toggleMute as p, isBuffered as r, setAudioTrack as s, getMediaTime as t, subscribePlaybackState as u, havePointer as v, CastState as w, isSafari as x, isDesktop as y };

package/dist/modules.d.mts

@@ -0,0 +1,51 @@
+import { getVersion } from "util/index";
+import { dispatchChapterEvents } from "premium/timeline";
+import latencyManager from "playerCore/latencyManager";
+import { createApi, getContentInfo, getStreamInfo } from "playbackSession/api";
+import startSession from "playbackSession/startSession";
+import { logEventNames, mapLogEvents } from "playerCore/playlogv2";
+import * as playlogv3 from "playerCore/playlogv3";
+import { selectHlsQualities } from "playerCore/adaptation";
+import fixDashManifest from "plugins/shaka/fixDashManifest";
+import ensureTabLock from "util/ensureTabLock";
+import { validateEnvironment } from "util/environment";
+import addSentry from "util/addSentry";
+import handleIOSHeadphonesDisconnection from "util/handleIOSHeadphonesDisconnection";
+import { disconnect, initSender, linkCast, loadMedia, subscribeCastState } from "cast/framework";
+
+//#region src/modules/retrieveModuleConfig.d.ts
+type ModulesConfig = {
+  [key: string]: string;
+};
+//#endregion
+//#region src/modules/analytics.d.ts
+type createAnalyticsParameter = {
+  video: HTMLVideoElement;
+  sessionId: string;
+  onPlaylogFired: any;
+  modulesConfig: ModulesConfig;
+};
+/**
+ * This method creates analytics module instance and return it.
+ * @param createAnalyticsParameter
+ * @returns Analytics module instance
+ */
+declare const createAnalytics: ({
+  video,
+  onPlaylogFired,
+  modulesConfig
+}: createAnalyticsParameter) => {
+  sendEvent: (name: any, {
+    currentTime
+  }: {
+    currentTime?: string | undefined;
+  }, properties: any) => void;
+  sendLog: (name: any, {
+    currentTime
+  }: {
+    currentTime?: string | undefined;
+  }, properties: any) => void;
+  reset: () => void;
+};
+//#endregion
+export { addSentry, loadMedia as castMedia, createAnalytics, createApi, dispatchChapterEvents, ensureTabLock, fixDashManifest, getContentInfo, getStreamInfo, getVersion, handleIOSHeadphonesDisconnection, initSender, latencyManager, linkCast, logEventNames, mapLogEvents, playlogv3, selectHlsQualities, startSession, disconnect as stopCast, subscribeCastState, validateEnvironment };