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

package/dist/loadPlayer-CQdGA3Te.mjs

@@ -0,0 +1,1560 @@
+import { r as getVersion } from "./util-B2YBSBjR.mjs";
+import { b as isIOS, i as isLiveDuration, k as on, x as isSafari } from "./mediaBindings-CoY60lQw.mjs";
+import { t as fixDashManifest_default } from "./fixDashManifest-CJ63KKaA.mjs";
+
+//#region src/playerCore/errors.js
+const handleError = async ({ nativeEvent: event }, { media, displayError, delay = 5e3 }) => {
+	console.warn(event);
+	if (event.defaultPrevented) return;
+	const { code, name, data, message } = event.error || {};
+	if ([
+		code,
+		name,
+		data,
+		message
+	].every((it) => typeof it === "undefined")) {
+		setTimeout(() => {
+			if (!(media.readyState >= 1)) displayError({
+				code: `VIDEO:${media.error?.code || 0}`,
+				message: media.error?.message
+			});
+		}, delay);
+		console.warn("error from video element, let base player handle it", event);
+	} else displayError({
+		code,
+		name,
+		data,
+		message
+	});
+};
+const reloadOnLiveStall = (media, { reload, stallDuration = 6e3 }) => {
+	const getBufferedEnd = () => Math.max(0, ...Array.from({ length: media.buffered?.length || 0 }, (_, i) => media.buffered.end(i)));
+	let checkTimer;
+	const state = { lastBufferedEnd: 0 };
+	const removeListener = on(media, "loadeddata", () => {
+		if (!isLiveDuration(media.duration)) return;
+		const checkStall = () => {
+			const currentBufferedEnd = getBufferedEnd();
+			if (!media.paused && state.lastBufferedEnd === currentBufferedEnd && (media.buffered.length < 1 || state.lastPlayed === media.currentTime)) {
+				console.warn("Live stream stall, reload to recover");
+				state.lastBufferedEnd = 0;
+				reload();
+			}
+			state.lastBufferedEnd = currentBufferedEnd;
+			state.lastPlayed = media.currentTime;
+			clearTimeout(checkTimer);
+			checkTimer = setTimeout(checkStall, stallDuration);
+		};
+		clearTimeout(checkTimer);
+		checkTimer = setTimeout(checkStall, stallDuration);
+	});
+	return () => {
+		removeListener();
+		clearTimeout(checkTimer);
+	};
+};
+
+//#endregion
+//#region src/util/printVersion.js
+const printVersion = () => {
+	console.log([`%KKCompany Web Player SDK\n-----------\nVersion: ${getVersion()}`, `We are hiring, and looking for geeks like you! please join us at https://www.kkcompany.com/zh-tw/career/`].join("\n"), "color: #0E78F4");
+};
+var printVersion_default = printVersion;
+
+//#endregion
+//#region src/playerCore/native.js
+const loadNative = ({ videoElement }) => ({
+	load: ({ native: url }) => {
+		videoElement.src = url;
+		videoElement.style.height = "100%";
+		videoElement.style.width = "100%";
+	},
+	play: () => videoElement.play(),
+	pause: () => videoElement.pause(),
+	seek: (time) => {
+		videoElement.currentTime = time;
+	},
+	getVideoElement: () => videoElement,
+	getVideoQuality: () => ({}),
+	destroy: () => {}
+});
+
+//#endregion
+//#region src/util/getUrlObject.js
+const getUrlObject = (fn) => {
+	const createObjectURL = window.URL.createObjectURL.bind();
+	window.URL.createObjectURL = (blob) => {
+		if (blob.addSourceBuffer) fn(blob);
+		return createObjectURL(blob);
+	};
+};
+var getUrlObject_default = getUrlObject;
+
+//#endregion
+//#region src/plugins/shaka/HttpFetchPlugin.js
+/*! @license
+* Shaka Player
+* Copyright 2016 Google LLC
+* SPDX-License-Identifier: Apache-2.0
+*/
+let shaka$1;
+const shakaLog$1 = { v1: () => {} };
+const asMap = (object) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const key of Object.keys(object)) map.set(key, object[key]);
+	return map;
+};
+const makeResponse = (headers, data, status, uri, responseURL, requestType) => {
+	if (status >= 200 && status <= 299 && status != 202) return {
+		uri: responseURL || uri,
+		originalUri: uri,
+		data,
+		status,
+		headers,
+		fromCache: !!headers["x-shaka-from-cache"]
+	};
+	let responseText = null;
+	try {
+		responseText = shaka$1.util.StringUtils.fromBytesAutoDetect(data);
+	} catch (exception) {}
+	const severity = status == 401 || status == 403 ? shaka$1.util.Error.Severity.CRITICAL : shaka$1.util.Error.Severity.RECOVERABLE;
+	throw new shaka$1.util.Error(severity, shaka$1.util.Error.Category.NETWORK, shaka$1.util.Error.Code.BAD_HTTP_STATUS, uri, status, responseText, headers, requestType);
+};
+const goog$2 = { asserts: { assert: () => {} } };
+/**
+* @summary A networking plugin to handle http and https URIs via the Fetch API.
+* @export
+*/
+var HttpFetchPlugin = class HttpFetchPlugin {
+	/**
+	* @param {string} uri
+	* @param {shaka.extern.Request} request
+	* @param {shaka.net.NetworkingEngine.RequestType} requestType
+	* @param {shaka.extern.ProgressUpdated} progressUpdated Called when a
+	*   progress event happened.
+	* @param {shaka.extern.HeadersReceived} headersReceived Called when the
+	*   headers for the download are received, but before the body is.
+	* @return {!shaka.extern.IAbortableOperation.<shaka.extern.Response>}
+	* @export
+	*/
+	static parse(uri, request, requestType, progressUpdated, headersReceived) {
+		const headers = new HttpFetchPlugin.Headers_();
+		asMap(request.headers).forEach((value, key) => {
+			headers.append(key, value);
+		});
+		const controller = new HttpFetchPlugin.AbortController_();
+		/** @type {!RequestInit} */
+		const init = {
+			body: request.body || void 0,
+			headers,
+			method: request.method,
+			signal: controller.signal,
+			credentials: request.allowCrossSiteCredentials ? "include" : void 0
+		};
+		/** @type {shaka.net.HttpFetchPlugin.AbortStatus} */
+		const abortStatus = {
+			canceled: false,
+			timedOut: false
+		};
+		const pendingRequest = HttpFetchPlugin.request_(uri, requestType, init, abortStatus, progressUpdated, headersReceived, request.streamDataCallback);
+		/** @type {!shaka.util.AbortableOperation} */
+		const op = new shaka$1.util.AbortableOperation(pendingRequest, () => {
+			abortStatus.canceled = true;
+			controller.abort();
+			return Promise.resolve();
+		});
+		const timeoutMs = request.retryParameters.timeout;
+		if (timeoutMs) {
+			const timer = new shaka$1.util.Timer(() => {
+				abortStatus.timedOut = true;
+				controller.abort();
+			});
+			timer.tickAfter(timeoutMs / 1e3);
+			op.finally(() => {
+				timer.stop();
+			});
+		}
+		return op;
+	}
+	/**
+	* @param {string} uri
+	* @param {shaka.net.NetworkingEngine.RequestType} requestType
+	* @param {!RequestInit} init
+	* @param {shaka.net.HttpFetchPlugin.AbortStatus} abortStatus
+	* @param {shaka.extern.ProgressUpdated} progressUpdated
+	* @param {shaka.extern.HeadersReceived} headersReceived
+	* @param {?function(BufferSource):!Promise} streamDataCallback
+	* @return {!Promise<!shaka.extern.Response>}
+	* @private
+	*/
+	static async request_(uri, requestType, init, abortStatus, progressUpdated, headersReceived, streamDataCallback) {
+		const fetch = HttpFetchPlugin.fetch_;
+		const ReadableStream = HttpFetchPlugin.ReadableStream_;
+		let response;
+		let arrayBuffer;
+		let loaded = 0;
+		let lastLoaded = 0;
+		let lastTime = Date.now();
+		try {
+			response = await fetch(uri, init);
+			headersReceived(HttpFetchPlugin.headersToGenericObject_(response.headers));
+			const reader = response.clone().body.getReader();
+			const contentLengthRaw = response.headers.get("Content-Length");
+			const contentLength = contentLengthRaw ? parseInt(contentLengthRaw, 10) : 0;
+			const start = (controller) => {
+				const push = async () => {
+					let readObj;
+					try {
+						readObj = await reader.read();
+					} catch (e) {
+						shakaLog$1.v1("error reading from stream", e.message);
+						return;
+					}
+					if (!readObj.done) {
+						loaded += readObj.value.byteLength;
+						if (response.status === 200 && streamDataCallback) await streamDataCallback(readObj.value);
+					}
+					const currentTime = Date.now();
+					if (currentTime - lastTime > 100 || readObj.done) {
+						progressUpdated(currentTime - lastTime, loaded - lastLoaded, contentLength - loaded);
+						lastLoaded = loaded;
+						lastTime = currentTime;
+					}
+					if (readObj.done) {
+						goog$2.asserts.assert(!readObj.value, "readObj should be unset when \"done\" is true.");
+						controller.close();
+					} else {
+						controller.enqueue(readObj.value);
+						push();
+					}
+				};
+				push();
+			};
+			new ReadableStream({ start });
+			arrayBuffer = await response.arrayBuffer();
+		} catch (error) {
+			if (abortStatus.canceled) throw new shaka$1.util.Error(shaka$1.util.Error.Severity.RECOVERABLE, shaka$1.util.Error.Category.NETWORK, shaka$1.util.Error.Code.OPERATION_ABORTED, uri, requestType);
+			else if (abortStatus.timedOut) throw new shaka$1.util.Error(shaka$1.util.Error.Severity.RECOVERABLE, shaka$1.util.Error.Category.NETWORK, shaka$1.util.Error.Code.TIMEOUT, uri, requestType);
+			else throw new shaka$1.util.Error(shaka$1.util.Error.Severity.RECOVERABLE, shaka$1.util.Error.Category.NETWORK, shaka$1.util.Error.Code.HTTP_ERROR, uri, error, requestType);
+		}
+		return makeResponse(HttpFetchPlugin.headersToGenericObject_(response.headers), arrayBuffer, response.status, uri, response.url, requestType);
+	}
+	/**
+	* @param {!Headers} headers
+	* @return {!Object.<string, string>}
+	* @private
+	*/
+	static headersToGenericObject_(headers) {
+		const headersObj = {};
+		headers.forEach((value, key) => {
+			headersObj[key.trim()] = value;
+		});
+		return headersObj;
+	}
+};
+HttpFetchPlugin.register = (shakaNamespace) => {
+	shaka$1 = shakaNamespace;
+	/**
+	* Overridden in unit tests, but compiled out in production.
+	*
+	* @const {function(string, !RequestInit)}
+	* @private
+	*/
+	HttpFetchPlugin.fetch_ = window.fetch;
+	/**
+	* Overridden in unit tests, but compiled out in production.
+	*
+	* @const {function(new: AbortController)}
+	* @private
+	*/
+	HttpFetchPlugin.AbortController_ = window.AbortController;
+	/**
+	* Overridden in unit tests, but compiled out in production.
+	*
+	* @const {function(new: ReadableStream, !Object)}
+	* @private
+	*/
+	HttpFetchPlugin.ReadableStream_ = window.ReadableStream;
+	/**
+	* Overridden in unit tests, but compiled out in production.
+	*
+	* @const {function(new: Headers)}
+	* @private
+	*/
+	HttpFetchPlugin.Headers_ = window.Headers;
+	shaka$1.net.NetworkingEngine.registerScheme("http", HttpFetchPlugin.parse);
+	shaka$1.net.NetworkingEngine.registerScheme("https", HttpFetchPlugin.parse);
+	shaka$1.net.NetworkingEngine.registerScheme("blob", HttpFetchPlugin.parse);
+};
+var HttpFetchPlugin_default = HttpFetchPlugin;
+
+//#endregion
+//#region src/plugins/shaka/setupKKFariplay.js
+const defaultInitDataTransform = (initData, initDataType, drmInfo) => {
+	if (initDataType === "skd") {
+		const { defaultGetContentId, initDataTransform } = shaka.util.FairPlayUtils;
+		const cert = drmInfo.serverCertificate;
+		return initDataTransform(initData, defaultGetContentId(initData), cert);
+	}
+	return initData;
+};
+const wrapFairplayLicenseRequest = (request) => {
+	const base64Payload = encodeURIComponent(btoa(String.fromCharCode(...new Uint8Array(request.body))));
+	const contentId = encodeURIComponent(new TextDecoder("utf-8").decode(request.initData).slice(6));
+	request.headers["Content-Type"] = "application/x-www-form-urlencoded";
+	request.body = `spc=${base64Payload}&asset_id=${contentId}`;
+};
+const requestHandler = (type, request, player, extensionOptions) => {
+	const { LICENSE, SERVER_CERTIFICATE } = shaka.net.NetworkingEngine.RequestType;
+	if (type === SERVER_CERTIFICATE) Object.assign(request.headers, extensionOptions.drm[player.drmInfo().keySystem]?.headers);
+	if (type === LICENSE) wrapFairplayLicenseRequest(request);
+	return request;
+};
+const stripResponseCkc = (type, response) => {
+	if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) return response;
+	const keyMessage = new TextDecoder("utf-8").decode(response.data).trim();
+	if (keyMessage.slice(0, 5) === "<ckc>" && keyMessage.slice(-6) === "</ckc>") response.data = Uint8Array.from(atob(keyMessage.slice(5, -6)), (c) => c.charCodeAt(0));
+	return response;
+};
+const setupKKFariplay = (player, extensionOptions) => {
+	if (!window.WebKitMediaKeys) return;
+	shaka.polyfill.PatchedMediaKeysApple.install();
+	player.configure({ drm: { initDataTransform: defaultInitDataTransform } });
+	extensionOptions.requestHandlers.push(requestHandler);
+	extensionOptions.responseHandlers.push(stripResponseCkc);
+};
+var setupKKFariplay_default = setupKKFariplay;
+
+//#endregion
+//#region src/plugins/shaka/VttTextParser.js
+/*! @license
+* Shaka Player
+* Copyright 2016 Google LLC
+* SPDX-License-Identifier: Apache-2.0
+*/
+const goog$1 = { asserts: { assert: (condition, message) => {
+	if (!condition) console.warn("GOOG Assert!", message);
+} } };
+const addDefaultTextColor = (styles) => {
+	const textColor = shaka.text.Cue.defaultTextColor;
+	for (const [key, value] of Object.entries(textColor)) {
+		const cue = new shaka.text.Cue(0, 0, "");
+		cue.color = value;
+		styles.set(`.${key}`, cue);
+	}
+	const bgColor = shaka.text.Cue.defaultTextBackgroundColor;
+	for (const [key, value] of Object.entries(bgColor)) {
+		const cue = new shaka.text.Cue(0, 0, "");
+		cue.backgroundColor = value;
+		styles.set(`.${key}`, cue);
+	}
+};
+const parseTime = (text) => {
+	const results = Array.from(text.matchAll(/(?:(\d{1,}):)?(\d{2}):(\d{2})((\.(\d{1,3})))?/g))?.[0];
+	if (results == null) return null;
+	const hours = Number(results[1]) || 0;
+	const minutes = Number(results[2]);
+	const seconds = Number(results[3]);
+	const milliseconds = Number(results[6]) || 0;
+	if (minutes > 59 || seconds > 59) return null;
+	return milliseconds / 1e3 + seconds + minutes * 60 + hours * 3600;
+};
+const parseRegion = (block) => {
+	if (block[0].trim() !== "REGION") return [];
+	const region = new shaka.text.CueRegion();
+	block.slice(1).forEach((word) => {
+		let results = null;
+		if (results = /^id:(.*)$/.exec(word)) region.id = results[1];
+		else if (results = /^width:(\d{1,2}|100)%$/.exec(word)) region.width = Number(results[1]);
+		else if (results = /^lines:(\d+)$/.exec(word)) {
+			region.height = Number(results[1]);
+			region.heightUnits = shaka.text.CueRegion.units.LINES;
+		} else if (results = /^regionanchor:(\d{1,2}|100)%,(\d{1,2}|100)%$/.exec(word)) {
+			region.regionAnchorX = Number(results[1]);
+			region.regionAnchorY = Number(results[2]);
+		} else if (results = /^viewportanchor:(\d{1,2}|100)%,(\d{1,2}|100)%$/.exec(word)) {
+			region.viewportAnchorX = Number(results[1]);
+			region.viewportAnchorY = Number(results[2]);
+		} else if (results = /^scroll:up$/.exec(word)) region.scroll = shaka.text.CueRegion.scrollMode.UP;
+		else shaka.log.warning("VTT parser encountered an invalid VTTRegion setting: ", word, " The setting will be ignored.");
+	});
+	return [region];
+};
+/**
+* @implements {shaka.extern.TextParser}
+* @export
+*/
+var VttTextParser = class VttTextParser {
+	/** Constructs a VTT parser. */
+	constructor() {
+		/** @private {boolean} */
+		this.sequenceMode_ = false;
+		/** @private {string} */
+		this.manifestType_ = shaka.media.ManifestParser.UNKNOWN;
+	}
+	/**
+	* @override
+	* @export
+	*/
+	parseInit() {
+		goog$1.asserts.assert(false, "VTT does not have init segments");
+	}
+	/**
+	* @override
+	* @export
+	*/
+	setSequenceMode(sequenceMode) {
+		this.sequenceMode_ = sequenceMode;
+	}
+	/**
+	* @override
+	* @export
+	*/
+	setManifestType(manifestType) {
+		this.manifestType_ = manifestType;
+	}
+	/**
+	* @override
+	* @export
+	*/
+	parseMedia(data, time) {
+		let str = shaka.util.StringUtils.fromUTF8(data);
+		str = str.replace(/\r\n|\r(?=[^\n]|$)/gm, "\n");
+		const blocks = str.split(/\n{2,}/m);
+		if (!/^WEBVTT($|[ \t\n])/m.test(blocks[0])) throw new shaka.util.Error(shaka.util.Error.Severity.CRITICAL, shaka.util.Error.Category.TEXT, shaka.util.Error.Code.INVALID_TEXT_HEADER);
+		let offset = time.vttOffset;
+		if (this.manifestType_ == shaka.media.ManifestParser.HLS) {
+			if (blocks[0].includes("X-TIMESTAMP-MAP")) offset = this.computeHlsOffset_(blocks[0], time);
+			else if (time.periodStart && time.vttOffset == time.periodStart) offset = 0;
+		}
+		const regions = [];
+		/** @type {!Map<string, !shaka.text.Cue>} */
+		const styles = /* @__PURE__ */ new Map();
+		addDefaultTextColor(styles);
+		const ret = [];
+		for (const block of blocks.slice(1)) {
+			const lines = block.split("\n");
+			VttTextParser.parseStyle_(lines, styles);
+			regions.push(...parseRegion(lines));
+			const cue = VttTextParser.parseCue_(lines, offset, regions, styles);
+			if (cue) ret.push(cue);
+		}
+		return ret;
+	}
+	/**
+	* @param {string} headerBlock Contains X-TIMESTAMP-MAP.
+	* @param {shaka.extern.TextParser.TimeContext} time
+	* @return {number}
+	* @private
+	*/
+	computeHlsOffset_(headerBlock, time) {
+		const cueTimeMatch = headerBlock.match(/LOCAL:((?:(\d{1,}):)?(\d{2}):(\d{2})\.(\d{3}))/m);
+		const mpegTimeMatch = headerBlock.match(/MPEGTS:(\d+)/m);
+		if (!cueTimeMatch || !mpegTimeMatch) throw new shaka.util.Error(shaka.util.Error.Severity.CRITICAL, shaka.util.Error.Category.TEXT, shaka.util.Error.Code.INVALID_TEXT_HEADER);
+		const cueTime = parseTime(cueTimeMatch[1]);
+		if (cueTime == null) throw new shaka.util.Error(shaka.util.Error.Severity.CRITICAL, shaka.util.Error.Category.TEXT, shaka.util.Error.Code.INVALID_TEXT_HEADER);
+		let mpegTime = Number(mpegTimeMatch[1]);
+		const mpegTimescale = VttTextParser.MPEG_TIMESCALE_;
+		const rolloverSeconds = VttTextParser.TS_ROLLOVER_ / mpegTimescale;
+		let segmentStart = time.segmentStart - time.periodStart;
+		while (segmentStart >= rolloverSeconds) {
+			segmentStart -= rolloverSeconds;
+			mpegTime += VttTextParser.TS_ROLLOVER_;
+		}
+		return time.periodStart + mpegTime / mpegTimescale - cueTime;
+	}
+	/**
+	* Parses a style block into a Cue object.
+	*
+	* @param {!Array<string>} text
+	* @param {!Map<string, !shaka.text.Cue>} styles
+	* @private
+	*/
+	static parseStyle_(text, styles) {
+		if (text.length == 1 && !text[0]) return;
+		if (/^NOTE($|[ \t])/.test(text[0])) return;
+		if (text[0] != "STYLE") return;
+		/** @type {!Array<!Array<string>>} */
+		const styleBlocks = [];
+		let lastBlockIndex = -1;
+		for (let i = 1; i < text.length; i++) {
+			if (text[i].includes("::cue")) {
+				styleBlocks.push([]);
+				lastBlockIndex = styleBlocks.length - 1;
+			}
+			if (lastBlockIndex == -1) continue;
+			styleBlocks[lastBlockIndex].push(text[i]);
+			if (text[i].includes("}")) lastBlockIndex = -1;
+		}
+		for (const styleBlock of styleBlocks) {
+			let styleSelector = "global";
+			const selector = styleBlock[0].match(/\((.*)\)/);
+			if (selector) styleSelector = selector.pop();
+			let propertyLines = styleBlock.slice(1, -1);
+			if (styleBlock[0].includes("}")) {
+				const payload = /\{(.*?)\}/.exec(styleBlock[0]);
+				if (payload) propertyLines = payload[1].split(";");
+			}
+			let cue = styles.get(styleSelector);
+			if (!cue) cue = new shaka.text.Cue(0, 0, "");
+			let validStyle = false;
+			for (let i = 0; i < propertyLines.length; i++) {
+				const lineParts = /^\s*([^:]+):\s*(.*)/.exec(propertyLines[i]);
+				if (lineParts) {
+					const name = lineParts[1].trim();
+					const value = lineParts[2].trim().replace(";", "");
+					switch (name) {
+						case "background-color":
+						case "background":
+							validStyle = true;
+							cue.backgroundColor = value;
+							break;
+						case "color":
+							validStyle = true;
+							cue.color = value;
+							break;
+						case "font-family":
+							validStyle = true;
+							cue.fontFamily = value;
+							break;
+						case "font-size":
+							validStyle = true;
+							cue.fontSize = value;
+							break;
+						case "font-weight":
+							if (parseInt(value, 10) >= 700 || value == "bold") {
+								validStyle = true;
+								cue.fontWeight = shaka.text.Cue.fontWeight.BOLD;
+							}
+							break;
+						case "font-style":
+							switch (value) {
+								case "normal":
+									validStyle = true;
+									cue.fontStyle = shaka.text.Cue.fontStyle.NORMAL;
+									break;
+								case "italic":
+									validStyle = true;
+									cue.fontStyle = shaka.text.Cue.fontStyle.ITALIC;
+									break;
+								case "oblique":
+									validStyle = true;
+									cue.fontStyle = shaka.text.Cue.fontStyle.OBLIQUE;
+									break;
+							}
+							break;
+						case "opacity":
+							validStyle = true;
+							cue.opacity = parseFloat(value);
+							break;
+						case "text-combine-upright":
+							validStyle = true;
+							cue.textCombineUpright = value;
+							break;
+						case "text-shadow":
+							validStyle = true;
+							cue.textShadow = value;
+							break;
+						case "white-space":
+							validStyle = true;
+							cue.wrapLine = value != "noWrap";
+							break;
+						default:
+							shaka.log.warning("VTT parser encountered an unsupported style: ", lineParts);
+							break;
+					}
+				}
+			}
+			if (validStyle) styles.set(styleSelector, cue);
+		}
+	}
+	/**
+	* Parses a text block into a Cue object.
+	*
+	* @param {!Array<string>} text
+	* @param {number} timeOffset
+	* @param {!Array<!shaka.text.CueRegion>} regions
+	* @param {!Map<string, !shaka.text.Cue>} styles
+	* @return {shaka.text.Cue}
+	* @private
+	*/
+	static parseCue_(text, timeOffset, regions, styles) {
+		if (text.length == 1 && !text[0]) return null;
+		if (/^NOTE($|[ \t])/.test(text[0])) return null;
+		if (text[0] == "STYLE" || text[0] == "REGION") return null;
+		const skipIndex = text.findIndex((line) => /^#/.test(line.trim()));
+		if (skipIndex > 0) text = text.slice(skipIndex);
+		if (text.length < 2) return;
+		let id = null;
+		if (!text[0].includes("-->")) {
+			id = text[0];
+			text.splice(0, 1);
+		}
+		let [start, end] = text[0].split("-->").map((part) => parseTime(part.trim()));
+		if (start == null || end == null) {
+			shaka.log.alwaysWarn("Failed to parse VTT time code. Cue skipped:", id, text);
+			return null;
+		}
+		start += timeOffset;
+		end += timeOffset;
+		const payload = text.slice(1).join("\n").trim();
+		let cue = null;
+		if (styles.has("global")) {
+			cue = styles.get("global").clone();
+			cue.startTime = start;
+			cue.endTime = end;
+			cue.payload = payload;
+		} else cue = new shaka.text.Cue(start, end, payload);
+		text[0].split(/\s+/g).slice(3).forEach((word) => {
+			if (!word.trim()) return;
+			if (!VttTextParser.parseCueSetting(cue, word, regions)) shaka.log.warning("VTT parser encountered an invalid VTT setting: ", word, " The setting will be ignored.");
+		});
+		shaka.text.Cue.parseCuePayload(cue, styles);
+		if (id != null) cue.id = id;
+		return cue;
+	}
+	/**
+	* Parses a WebVTT setting from the given word.
+	*
+	* @param {!shaka.text.Cue} cue
+	* @param {string} word
+	* @param {!Array<!shaka.text.CueRegion>} regions
+	* @return {boolean} True on success.
+	*/
+	static parseCueSetting(cue, word, regions) {
+		let results = null;
+		if (results = /^align:(start|middle|center|end|left|right)$/.exec(word)) VttTextParser.setTextAlign_(cue, results[1]);
+		else if (results = /^vertical:(lr|rl)$/.exec(word)) VttTextParser.setVerticalWritingMode_(cue, results[1]);
+		else if (results = /^size:([\d.]+)%$/.exec(word)) cue.size = Number(results[1]);
+		else if (results = /^position:([\d.]+)%(?:,(line-left|line-right|middle|center|start|end|auto))?$/.exec(word)) {
+			cue.position = Number(results[1]);
+			if (results[2]) VttTextParser.setPositionAlign_(cue, results[2]);
+		} else if (results = /^region:(.*)$/.exec(word)) {
+			const region = VttTextParser.getRegionById_(regions, results[1]);
+			if (region) cue.region = region;
+		} else return VttTextParser.parsedLineValueAndInterpretation_(cue, word);
+		return true;
+	}
+	/**
+	*
+	* @param {!Array<!shaka.text.CueRegion>} regions
+	* @param {string} id
+	* @return {?shaka.text.CueRegion}
+	* @private
+	*/
+	static getRegionById_(regions, id) {
+		const regionsWithId = regions.filter((region) => region.id == id);
+		if (!regionsWithId.length) {
+			shaka.log.warning("VTT parser could not find a region with id: ", id, " The region will be ignored.");
+			return null;
+		}
+		goog$1.asserts.assert(regionsWithId.length == 1, "VTTRegion ids should be unique!");
+		return regionsWithId[0];
+	}
+	/**
+	* @param {!shaka.text.Cue} cue
+	* @param {string} align
+	* @private
+	*/
+	static setTextAlign_(cue, align) {
+		const Cue = shaka.text.Cue;
+		if (align == "middle") cue.textAlign = Cue.textAlign.CENTER;
+		else {
+			goog$1.asserts.assert(align.toUpperCase() in Cue.textAlign, `${align.toUpperCase()} Should be in Cue.textAlign values!`);
+			cue.textAlign = Cue.textAlign[align.toUpperCase()];
+		}
+	}
+	/**
+	* @param {!shaka.text.Cue} cue
+	* @param {string} align
+	* @private
+	*/
+	static setPositionAlign_(cue, align) {
+		const Cue = shaka.text.Cue;
+		if (align == "line-left" || align == "start") cue.positionAlign = Cue.positionAlign.LEFT;
+		else if (align == "line-right" || align == "end") cue.positionAlign = Cue.positionAlign.RIGHT;
+		else if (align == "center" || align == "middle") cue.positionAlign = Cue.positionAlign.CENTER;
+		else cue.positionAlign = Cue.positionAlign.AUTO;
+	}
+	/**
+	* @param {!shaka.text.Cue} cue
+	* @param {string} value
+	* @private
+	*/
+	static setVerticalWritingMode_(cue, value) {
+		const Cue = shaka.text.Cue;
+		if (value == "lr") cue.writingMode = Cue.writingMode.VERTICAL_LEFT_TO_RIGHT;
+		else cue.writingMode = Cue.writingMode.VERTICAL_RIGHT_TO_LEFT;
+	}
+	/**
+	* @param {!shaka.text.Cue} cue
+	* @param {string} word
+	* @return {boolean}
+	* @private
+	*/
+	static parsedLineValueAndInterpretation_(cue, word) {
+		const Cue = shaka.text.Cue;
+		let results = null;
+		if (results = /^line:([\d.]+)%(?:,(start|end|center))?$/.exec(word)) {
+			cue.lineInterpretation = Cue.lineInterpretation.PERCENTAGE;
+			cue.line = Number(results[1]);
+			if (results[2]) {
+				goog$1.asserts.assert(results[2].toUpperCase() in Cue.lineAlign, `${results[2].toUpperCase()} Should be in Cue.lineAlign values!`);
+				cue.lineAlign = Cue.lineAlign[results[2].toUpperCase()];
+			}
+		} else if (results = /^line:(-?\d+)(?:,(start|end|center))?$/.exec(word)) {
+			cue.lineInterpretation = Cue.lineInterpretation.LINE_NUMBER;
+			cue.line = Number(results[1]);
+			if (results[2]) {
+				goog$1.asserts.assert(results[2].toUpperCase() in Cue.lineAlign, `${results[2].toUpperCase()} Should be in Cue.lineAlign values!`);
+				cue.lineAlign = Cue.lineAlign[results[2].toUpperCase()];
+			}
+		} else return false;
+		return true;
+	}
+};
+/**
+* @const {number}
+* @private
+*/
+VttTextParser.MPEG_TIMESCALE_ = 9e4;
+/**
+* At this value, timestamps roll over in TS content.
+* @const {number}
+* @private
+*/
+VttTextParser.TS_ROLLOVER_ = 8589934592;
+VttTextParser.register = (shakaNameSpace) => {
+	shakaNameSpace.text.TextEngine.registerParser("text/vtt", () => new VttTextParser());
+	shakaNameSpace.text.TextEngine.registerParser("text/vtt; codecs=\"vtt\"", () => new VttTextParser());
+	shakaNameSpace.text.TextEngine.registerParser("text/vtt; codecs=\"wvtt\"", () => new VttTextParser());
+};
+var VttTextParser_default = VttTextParser;
+
+//#endregion
+//#region src/plugins/shaka/UITextDisplayer.js
+/*! @license
+* Shaka Player
+* Copyright 2016 Google LLC
+* SPDX-License-Identifier: Apache-2.0
+*/
+const shakaLog = {
+	debug: (...messages) => console.warn(...messages),
+	error: (...messages) => console.warn(...messages),
+	info: (...messages) => console.warn(...messages),
+	warning: (...messages) => console.warn(...messages),
+	alwaysWarn: (...messages) => console.warn(...messages)
+};
+const goog = { asserts: { assert: (result, message) => {
+	result || console.warn(message);
+} } };
+/**
+* Returns info about provided lengthValue
+* @example 100px => { value: 100, unit: 'px' }
+* @param {?string} lengthValue
+*
+* @return {?{ value: number, unit: string }}
+* @private
+*/
+const getLengthValueInfo_ = (lengthValue) => {
+	const matches = /(\d*\.?\d+)([a-z]+|%+)/.exec(lengthValue);
+	if (!matches) return null;
+	return {
+		value: Number(matches[1]),
+		unit: matches[2]
+	};
+};
+/**
+* Returns computed absolute length value in pixels based on cell
+* and a video container size
+* @param {number} value
+* @param {!shaka.text.Cue} cue
+* @param {HTMLElement} videoContainer
+* @return {string}
+*
+* @private
+*/
+const getAbsoluteLengthInPixels_ = (value, cue, videoContainer) => {
+	return `${videoContainer.clientHeight * value / cue.cellResolution.rows}px`;
+};
+/**
+* Inherits a property from the parent Cue elements.  If the value is falsy,
+* it is assumed to be inherited from the parent. This returns null if the
+* value isn't found.
+*
+* @param {!Array<!shaka.text.Cue>} parents
+* @param {function(!shaka.text.Cue):?T} cb
+* @return {?T}
+* @template T
+* @private
+*/
+const inheritProperty_ = (parents, cb) => {
+	for (let i = parents.length - 1; i >= 0; i--) {
+		const val = cb(parents[i]);
+		if (val || val === 0) return val;
+	}
+	return null;
+};
+/**
+* Converts length value to an absolute value in pixels.
+* If lengthValue is already an absolute value it will not
+* be modified. Relative lengthValue will be converted to an
+* absolute value in pixels based on Computed Cell Size
+*
+* @param {string} lengthValue
+* @param {!shaka.text.Cue} cue
+* @param {HTMLElement} videoContainer
+* @return {string}
+* @private
+*/
+const convertLengthValue_ = (lengthValue, cue, videoContainer) => {
+	const lengthValueInfo = getLengthValueInfo_(lengthValue);
+	if (!lengthValueInfo) return lengthValue;
+	const { unit, value } = lengthValueInfo;
+	switch (unit) {
+		case "%": return getAbsoluteLengthInPixels_(value / 100, cue, videoContainer);
+		case "c": return getAbsoluteLengthInPixels_(value, cue, videoContainer);
+		default: return lengthValue;
+	}
+};
+const removeDuplicates = (cues) => {
+	const uniqueCues = [];
+	for (const cue of cues) if (!uniqueCues.some((existingCue) => shaka.text.Cue.equal(cue, existingCue))) uniqueCues.push(cue);
+	return uniqueCues;
+};
+/**
+* The text displayer plugin for the Shaka Player UI.  Can also be used directly
+* by providing an appropriate container element.
+*
+* @implements {shaka.extern.TextDisplayer}
+* @final
+* @export
+*/
+var UITextDisplayer = class {
+	/**
+	* Constructor.
+	* @param {HTMLMediaElement} video
+	* @param {HTMLElement} videoContainer
+	*/
+	constructor(video, videoContainer) {
+		window.shaka.log = shakaLog;
+		goog.asserts.assert(videoContainer, "videoContainer should be valid.");
+		if (!document.fullscreenEnabled) shaka.log.alwaysWarn("Using UITextDisplayer in a browser without Fullscreen API support causes subtitles to not be rendered in fullscreen");
+		/** @private {boolean} */
+		this.isTextVisible_ = false;
+		/** @private {!Array<!shaka.text.Cue>} */
+		this.cues_ = [];
+		/** @private {HTMLMediaElement} */
+		this.video_ = video;
+		/** @private {HTMLElement} */
+		this.videoContainer_ = videoContainer;
+		/** @private {?number} */
+		this.aspectRatio_ = null;
+		/** @private {?shaka.extern.TextDisplayerConfiguration} */
+		this.config_ = null;
+		/** @type {HTMLElement} */
+		this.textContainer_ = document.createElement("div");
+		this.textContainer_.classList.add("shaka-text-container");
+		this.textContainer_.style.textAlign = "center";
+		this.textContainer_.style.display = "flex";
+		this.textContainer_.style.flexDirection = "column";
+		this.textContainer_.style.alignItems = "center";
+		this.textContainer_.style.justifyContent = "flex-end";
+		this.videoContainer_.appendChild(this.textContainer_);
+		/** @private {shaka.util.Timer} */
+		this.captionsTimer_ = new shaka.util.Timer(() => {
+			if (!this.video_.paused) this.updateCaptions_();
+		});
+		this.configureCaptionsTimer_();
+		/**
+		* Maps cues to cue elements. Specifically points out the wrapper element of
+		* the cue (e.g. the HTML element to put nested cues inside).
+		* @private {Map<!shaka.text.Cue, !{
+		*   cueElement: !HTMLElement,
+		*   regionElement: HTMLElement,
+		*   wrapper: !HTMLElement
+		* }>}
+		*/
+		this.currentCuesMap_ = /* @__PURE__ */ new Map();
+		/** @private {shaka.util.EventManager} */
+		this.eventManager_ = new shaka.util.EventManager();
+		this.eventManager_.listen(document, "fullscreenchange", () => {
+			this.updateCaptions_(true);
+		});
+		this.eventManager_.listen(this.video_, "seeking", () => {
+			this.updateCaptions_(true);
+		});
+		this.eventManager_.listen(this.video_, "ratechange", () => {
+			this.configureCaptionsTimer_();
+		});
+		this.eventManager_.listen(this.video_, "resize", () => {
+			const element = this.video_;
+			const width = element.videoWidth;
+			const height = element.videoHeight;
+			if (width && height) this.aspectRatio_ = width / height;
+			else this.aspectRatio_ = null;
+		});
+		/** @private {ResizeObserver} */
+		this.resizeObserver_ = null;
+		if ("ResizeObserver" in window) {
+			this.resizeObserver_ = new ResizeObserver(() => {
+				this.updateCaptions_(true);
+			});
+			this.resizeObserver_.observe(this.textContainer_);
+		}
+		/** @private {Map<string, !HTMLElement>} */
+		this.regionElements_ = /* @__PURE__ */ new Map();
+	}
+	/**
+	* @override
+	* @export
+	*/
+	configure(config) {
+		this.config_ = config;
+		this.configureCaptionsTimer_();
+	}
+	/**
+	* @override
+	* @export
+	*/
+	append(cues) {
+		const cuesList = [...this.cues_];
+		for (const cue of removeDuplicates(cues)) if (!cuesList.some((cueInList) => shaka.text.Cue.equal(cueInList, cue))) this.cues_.push(cue);
+		this.updateCaptions_();
+	}
+	/**
+	* @override
+	* @export
+	*/
+	destroy() {
+		if (!this.textContainer_) return Promise.resolve();
+		this.videoContainer_.removeChild(this.textContainer_);
+		this.textContainer_ = null;
+		this.isTextVisible_ = false;
+		this.cues_ = [];
+		if (this.captionsTimer_) {
+			this.captionsTimer_.stop();
+			this.captionsTimer_ = null;
+		}
+		this.currentCuesMap_.clear();
+		if (this.eventManager_) {
+			this.eventManager_.release();
+			this.eventManager_ = null;
+		}
+		if (this.resizeObserver_) {
+			this.resizeObserver_.disconnect();
+			this.resizeObserver_ = null;
+		}
+		return Promise.resolve();
+	}
+	/**
+	* @override
+	* @export
+	*/
+	remove(start, end) {
+		if (!this.textContainer_) return false;
+		const oldNumCues = this.cues_.length;
+		this.cues_ = this.cues_.filter((cue) => cue.startTime < start || cue.endTime >= end);
+		const forceUpdate = oldNumCues > this.cues_.length;
+		this.updateCaptions_(forceUpdate);
+		return true;
+	}
+	/**
+	* @override
+	* @export
+	*/
+	isTextVisible() {
+		return this.isTextVisible_;
+	}
+	/**
+	* @override
+	* @export
+	*/
+	setTextVisibility(on$1) {
+		this.isTextVisible_ = on$1;
+		this.updateCaptions_(true);
+	}
+	/**
+	* @override
+	* @export
+	*/
+	setTextLanguage(language) {
+		if (language && language != "und") this.textContainer_.setAttribute("lang", language);
+		else this.textContainer_.setAttribute("lang", "");
+	}
+	/**
+	* @override
+	* @export
+	*/
+	enableTextDisplayer() {}
+	/**
+	* @private
+	*/
+	configureCaptionsTimer_() {
+		if (this.captionsTimer_) {
+			const updateTime = (this.config_ ? this.config_.captionsUpdatePeriod : .25) / Math.max(1, Math.abs(this.video_.playbackRate));
+			this.captionsTimer_.tickEvery(updateTime);
+		}
+	}
+	/**
+	* @private
+	*/
+	isElementUnderTextContainer_(elemToCheck) {
+		while (elemToCheck != null) {
+			if (elemToCheck == this.textContainer_) return true;
+			elemToCheck = elemToCheck.parentElement;
+		}
+		return false;
+	}
+	/**
+	* @param {!Array<!shaka.text.Cue>} cues
+	* @param {!HTMLElement} container
+	* @param {number} currentTime
+	* @param {!Array<!shaka.text.Cue>} parents
+	* @private
+	*/
+	updateCuesRecursive_(cues, container, currentTime, parents) {
+		let updateDOM = false;
+		/**
+		* The elements to remove from the DOM.
+		* Some of these elements may be added back again, if their corresponding
+		* cue is in toPlant.
+		* These elements are only removed if updateDOM is true.
+		* @type {!Array<!HTMLElement>}
+		*/
+		const toUproot = [];
+		/**
+		* The cues whose corresponding elements should be in the DOM.
+		* Some of these might be new, some might have been displayed beforehand.
+		* These will only be added if updateDOM is true.
+		* @type {!Array<!shaka.text.Cue>}
+		*/
+		const toPlant = [];
+		for (const cue of cues) {
+			parents.push(cue);
+			let cueRegistry = this.currentCuesMap_.get(cue);
+			const shouldBeDisplayed = cue.startTime <= currentTime && cue.endTime > currentTime;
+			let wrapper = cueRegistry ? cueRegistry.wrapper : null;
+			if (cueRegistry) {
+				toUproot.push(cueRegistry.cueElement);
+				if (cueRegistry.regionElement) toUproot.push(cueRegistry.regionElement);
+				if (!shouldBeDisplayed) {
+					updateDOM = true;
+					this.currentCuesMap_.delete(cue);
+					cueRegistry = null;
+				}
+			}
+			if (shouldBeDisplayed) {
+				toPlant.push(cue);
+				if (!cueRegistry) {
+					this.createCue_(cue, parents);
+					cueRegistry = this.currentCuesMap_.get(cue);
+					wrapper = cueRegistry.wrapper;
+					updateDOM = true;
+				} else if (!this.isElementUnderTextContainer_(wrapper)) updateDOM = true;
+			}
+			if (cue.nestedCues.length > 0 && wrapper) this.updateCuesRecursive_(cue.nestedCues, wrapper, currentTime, parents);
+			const topCue = parents.pop();
+			goog.asserts.assert(topCue == cue, "Parent cues should be kept in order");
+		}
+		if (updateDOM) {
+			for (const element of toUproot) if (element.parentElement) element.parentElement.removeChild(element);
+			toPlant.sort((a, b) => {
+				if (a.startTime != b.startTime) return a.startTime - b.startTime;
+				return a.endTime - b.endTime;
+			});
+			for (const cue of toPlant) {
+				const cueRegistry = this.currentCuesMap_.get(cue);
+				goog.asserts.assert(cueRegistry, "cueRegistry should exist.");
+				if (cueRegistry.regionElement) {
+					if (cueRegistry.regionElement.contains(container)) cueRegistry.regionElement.removeChild(container);
+					container.appendChild(cueRegistry.regionElement);
+					cueRegistry.regionElement.appendChild(cueRegistry.cueElement);
+				} else container.appendChild(cueRegistry.cueElement);
+			}
+		}
+	}
+	/**
+	* Display the current captions.
+	* @param {boolean=} forceUpdate
+	* @private
+	*/
+	updateCaptions_(forceUpdate = false) {
+		if (!this.textContainer_) return;
+		const { currentTime } = this.video_;
+		if (!this.isTextVisible_ || forceUpdate) {
+			for (const regionElement of this.regionElements_.values()) regionElement.replaceChildren();
+			this.textContainer_.replaceChildren();
+			this.currentCuesMap_.clear();
+			this.regionElements_.clear();
+		}
+		if (this.isTextVisible_) {
+			const previousCuesMap = /* @__PURE__ */ new Map();
+			if (goog.DEBUG) for (const cue of this.currentCuesMap_.keys()) previousCuesMap.set(cue, this.currentCuesMap_.get(cue));
+			this.updateCuesRecursive_(this.cues_, this.textContainer_, currentTime, []);
+			if (goog.DEBUG) {
+				for (const cue of previousCuesMap.keys()) if (!this.currentCuesMap_.has(cue)) {
+					const { cueElement } = previousCuesMap.get(cue);
+					goog.asserts.assert(!cueElement.parentNode, "Cue was not properly removed!");
+				}
+			}
+		}
+	}
+	/**
+	* Compute a unique internal id:
+	* Regions can reuse the id but have different dimensions, we need to
+	* consider those differences
+	* @param {shaka.text.CueRegion} region
+	* @private
+	*/
+	generateRegionId_(region) {
+		const percentageUnit = shaka.text.CueRegion.units.PERCENTAGE;
+		const heightUnit = region.heightUnits == percentageUnit ? "%" : "px";
+		const viewportAnchorUnit = region.viewportAnchorUnits == percentageUnit ? "%" : "px";
+		return `${region.id}_${region.width}x${region.height}${heightUnit}-${region.viewportAnchorX}x${region.viewportAnchorY}${viewportAnchorUnit}`;
+	}
+	/**
+	* Get or create a region element corresponding to the cue region.  These are
+	* cached by ID.
+	*
+	* @param {!shaka.text.Cue} cue
+	* @return {!HTMLElement}
+	* @private
+	*/
+	getRegionElement_(cue) {
+		const { region } = cue;
+		const lineWidthMultiple = this.aspectRatio_ === 4 / 3 ? 2.5 : 1.9;
+		const lineHeightMultiple = 5.33;
+		const regionId = this.generateRegionId_(region);
+		if (this.regionElements_.has(regionId)) return this.regionElements_.get(regionId);
+		const regionElement = document.createElement("span");
+		const linesUnit = shaka.text.CueRegion.units.LINES;
+		const percentageUnit = shaka.text.CueRegion.units.PERCENTAGE;
+		const pixelUnit = shaka.text.CueRegion.units.PX;
+		let heightUnit = region.heightUnits == percentageUnit ? "%" : "px";
+		let widthUnit = region.widthUnits == percentageUnit ? "%" : "px";
+		const viewportAnchorUnit = region.viewportAnchorUnits == percentageUnit ? "%" : "px";
+		regionElement.id = `shaka-text-region---${regionId}`;
+		regionElement.classList.add("shaka-text-region");
+		regionElement.style.position = "absolute";
+		let regionHeight = region.height;
+		let regionWidth = region.width;
+		if (region.heightUnits === linesUnit) {
+			regionHeight = region.height * lineHeightMultiple;
+			heightUnit = "%";
+		}
+		if (region.widthUnits === linesUnit) {
+			regionWidth = region.width * lineWidthMultiple;
+			widthUnit = "%";
+		}
+		regionElement.style.height = regionHeight + heightUnit;
+		regionElement.style.width = regionWidth + widthUnit;
+		if (region.viewportAnchorUnits === linesUnit) {
+			let top = region.viewportAnchorY / 75 * 100;
+			const windowWidth = this.aspectRatio_ === 4 / 3 ? 160 : 210;
+			let left = region.viewportAnchorX / windowWidth * 100;
+			top -= region.regionAnchorY * regionHeight / 100;
+			left -= region.regionAnchorX * regionWidth / 100;
+			regionElement.style.top = `${top}%`;
+			regionElement.style.left = `${left}%`;
+		} else {
+			regionElement.style.top = region.viewportAnchorY - region.regionAnchorY * regionHeight / 100 + viewportAnchorUnit;
+			regionElement.style.left = region.viewportAnchorX - region.regionAnchorX * regionWidth / 100 + viewportAnchorUnit;
+		}
+		if (region.heightUnits !== pixelUnit && region.widthUnits !== pixelUnit && region.viewportAnchorUnits !== pixelUnit) {
+			const top = parseInt(regionElement.style.top.slice(0, -1), 10) || 0;
+			const left = parseInt(regionElement.style.left.slice(0, -1), 10) || 0;
+			const height = parseInt(regionElement.style.height.slice(0, -1), 10) || 0;
+			const width = parseInt(regionElement.style.width.slice(0, -1), 10) || 0;
+			const realTop = Math.max(0, Math.min(100 - height, top));
+			const realLeft = Math.max(0, Math.min(100 - width, left));
+			regionElement.style.top = `${realTop}%`;
+			regionElement.style.left = `${realLeft}%`;
+		}
+		regionElement.style.display = "flex";
+		regionElement.style.flexDirection = "column";
+		regionElement.style.alignItems = "center";
+		if (cue.displayAlign == shaka.text.Cue.displayAlign.BEFORE) regionElement.style.justifyContent = "flex-start";
+		else if (cue.displayAlign == shaka.text.Cue.displayAlign.CENTER) regionElement.style.justifyContent = "center";
+		else regionElement.style.justifyContent = "flex-end";
+		this.regionElements_.set(regionId, regionElement);
+		return regionElement;
+	}
+	/**
+	* Creates the object for a cue.
+	*
+	* @param {!shaka.text.Cue} cue
+	* @param {!Array<!shaka.text.Cue>} parents
+	* @private
+	*/
+	createCue_(cue, parents) {
+		const isNested = parents.length > 1;
+		let type = isNested ? "span" : "div";
+		if (cue.lineBreak) type = "br";
+		if (cue.rubyTag) type = cue.rubyTag;
+		const needWrapper = !isNested && cue.nestedCues.length > 0;
+		const cueElement = document.createElement(type);
+		if (type != "br") {
+			this.setCaptionStyles_(cueElement, cue, parents, needWrapper);
+			if (!cue.line) cueElement.classList.add(`shaka-cue-${cue.writingMode}`);
+		}
+		let regionElement = null;
+		if (cue.region && cue.region.id) regionElement = this.getRegionElement_(cue);
+		let wrapper = cueElement;
+		if (needWrapper) {
+			wrapper = document.createElement("span");
+			wrapper.classList.add("shaka-text-wrapper");
+			wrapper.style.backgroundColor = cue.backgroundColor;
+			wrapper.style.lineHeight = "normal";
+			cueElement.appendChild(wrapper);
+		}
+		this.currentCuesMap_.set(cue, {
+			cueElement,
+			wrapper,
+			regionElement
+		});
+	}
+	/**
+	* Compute cue position alignment
+	* See https://www.w3.org/TR/webvtt1/#webvtt-cue-position-alignment
+	*
+	* @param {!shaka.text.Cue} cue
+	* @private
+	*/
+	computeCuePositionAlignment_(cue) {
+		const { Cue } = shaka.text;
+		const { direction, positionAlign, textAlign } = cue;
+		if (positionAlign !== Cue.positionAlign.AUTO) return positionAlign;
+		if (textAlign === Cue.textAlign.LEFT || textAlign === Cue.textAlign.START && direction === Cue.direction.HORIZONTAL_LEFT_TO_RIGHT || textAlign === Cue.textAlign.END && direction === Cue.direction.HORIZONTAL_RIGHT_TO_LEFT) return Cue.positionAlign.LEFT;
+		if (textAlign === Cue.textAlign.RIGHT || textAlign === Cue.textAlign.START && direction === Cue.direction.HORIZONTAL_RIGHT_TO_LEFT || textAlign === Cue.textAlign.END && direction === Cue.direction.HORIZONTAL_LEFT_TO_RIGHT) return Cue.positionAlign.RIGHT;
+		return Cue.positionAlign.CENTER;
+	}
+	/**
+	* @param {!HTMLElement} cueElement
+	* @param {!shaka.text.Cue} cue
+	* @param {!Array<!shaka.text.Cue>} parents
+	* @param {boolean} hasWrapper
+	* @private
+	*/
+	setCaptionStyles_(cueElement, cue, parents, hasWrapper) {
+		const { Cue } = shaka.text;
+		const inherit = (cb) => inheritProperty_(parents, cb);
+		const { style } = cueElement;
+		const isLeaf = cue.nestedCues.length == 0;
+		const isNested = parents.length > 1;
+		style.whiteSpace = "pre-wrap";
+		const text = cue.payload.replace(/\s+$/g, (match) => {
+			return "\xA0".repeat(match.length);
+		});
+		style.webkitTextStrokeColor = cue.textStrokeColor;
+		style.webkitTextStrokeWidth = cue.textStrokeWidth;
+		style.color = cue.color;
+		style.direction = cue.direction;
+		style.opacity = cue.opacity;
+		style.paddingLeft = convertLengthValue_(cue.linePadding, cue, this.videoContainer_);
+		style.paddingRight = convertLengthValue_(cue.linePadding, cue, this.videoContainer_);
+		style.textCombineUpright = cue.textCombineUpright;
+		style.textShadow = cue.textShadow;
+		if (cue.backgroundImage) {
+			style.backgroundImage = `url('${cue.backgroundImage}')`;
+			style.backgroundRepeat = "no-repeat";
+			style.backgroundSize = "contain";
+			style.backgroundPosition = "center";
+			if (cue.backgroundColor) style.backgroundColor = cue.backgroundColor;
+			style.width = "100%";
+			style.height = "100%";
+		} else {
+			let elem;
+			if (cue.nestedCues.length) elem = cueElement;
+			else {
+				elem = document.createElement("span");
+				cueElement.appendChild(elem);
+			}
+			if (cue.border) elem.style.border = cue.border;
+			if (!hasWrapper) {
+				const bgColor = inherit((c) => c.backgroundColor);
+				if (bgColor) elem.style.backgroundColor = bgColor;
+				else if (text) elem.style.backgroundColor = "rgba(0, 0, 0, 0)";
+			}
+			if (text) elem.textContent = text;
+		}
+		if (/ruby|rt/i.test(cueElement.tagName)) {} else if (isNested && !parents[parents.length - 1].isContainer) style.display = "inline";
+		else {
+			style.display = "flex";
+			style.flexDirection = "column";
+			style.alignItems = "center";
+			if (cue.textAlign == Cue.textAlign.LEFT || cue.textAlign == Cue.textAlign.START) {
+				style.width = "100%";
+				style.alignItems = "start";
+			} else if (cue.textAlign == Cue.textAlign.RIGHT || cue.textAlign == Cue.textAlign.END) {
+				style.width = "100%";
+				style.alignItems = "end";
+			}
+			if (/vertical/.test(cue.writingMode)) style.justifyContent = "flex-start";
+			else if (cue.displayAlign == Cue.displayAlign.BEFORE) style.justifyContent = "flex-start";
+			else if (cue.displayAlign == Cue.displayAlign.CENTER) style.justifyContent = "center";
+			else style.justifyContent = "flex-end";
+		}
+		if (!isLeaf) style.margin = "0";
+		style.fontFamily = cue.fontFamily;
+		style.fontWeight = cue.fontWeight.toString();
+		style.fontStyle = cue.fontStyle;
+		style.letterSpacing = cue.letterSpacing;
+		style.fontSize = convertLengthValue_(cue.fontSize, cue, this.videoContainer_);
+		let line = !isNested && /vertical/.test(cue.writingMode) && cue.line == null ? 0 : cue.line;
+		if (line != null) {
+			let { lineInterpretation } = cue;
+			if (lineInterpretation == Cue.lineInterpretation.LINE_NUMBER) {
+				lineInterpretation = Cue.lineInterpretation.PERCENTAGE;
+				let maxLines = 16;
+				if (this.aspectRatio_ && this.aspectRatio_ < 1) maxLines = 32;
+				if (line < 0) line = 100 + line / maxLines * 100;
+				else line = line / maxLines * 100;
+			}
+			if (lineInterpretation == Cue.lineInterpretation.PERCENTAGE) {
+				style.position = "absolute";
+				if (cue.writingMode == Cue.writingMode.HORIZONTAL_TOP_TO_BOTTOM) {
+					style.width = "100%";
+					if (cue.lineAlign == Cue.lineAlign.START) style.top = `${line}%`;
+					else if (cue.lineAlign == Cue.lineAlign.END) style.bottom = `${100 - line}%`;
+				} else if (cue.writingMode == Cue.writingMode.VERTICAL_LEFT_TO_RIGHT) {
+					style.height = "100%";
+					if (cue.lineAlign == Cue.lineAlign.START) style.left = `${3 + line}%`;
+					else if (cue.lineAlign == Cue.lineAlign.END) style.right = `${97 - line}%`;
+				} else {
+					style.height = "100%";
+					if (cue.lineAlign == Cue.lineAlign.START) style.right = `${3 + line}%`;
+					else if (cue.lineAlign == Cue.lineAlign.END) style.left = `${97 - line}%`;
+				}
+			}
+		}
+		style.lineHeight = cue.lineHeight;
+		if (!isNested && /vertical/.test(cue.writingMode) && cue.position == null) cue.position = 1;
+		const computedPositionAlign = this.computeCuePositionAlignment_(cue);
+		const computedCuePosition = !isNested && /vertical/.test(cue.writingMode) && cue.position == null ? 1 : cue.position;
+		if (/ruby|rt/i.test(cueElement.tagName)) {} else if (computedPositionAlign == Cue.positionAlign.LEFT) {
+			style.cssFloat = "left";
+			if (computedCuePosition !== null) {
+				style.position = "absolute";
+				if (cue.writingMode == Cue.writingMode.HORIZONTAL_TOP_TO_BOTTOM) {
+					style.left = `${computedCuePosition}%`;
+					style.width = "auto";
+				} else style.top = `${computedCuePosition}%`;
+			}
+		} else if (computedPositionAlign == Cue.positionAlign.RIGHT) {
+			style.cssFloat = "right";
+			if (computedCuePosition !== null) {
+				style.position = "absolute";
+				if (cue.writingMode == Cue.writingMode.HORIZONTAL_TOP_TO_BOTTOM) {
+					style.right = `${100 - computedCuePosition}%`;
+					style.width = "auto";
+				} else style.bottom = `${computedCuePosition}%`;
+			}
+		} else if (computedCuePosition !== null && computedCuePosition != 50) {
+			style.position = "absolute";
+			if (cue.writingMode == Cue.writingMode.HORIZONTAL_TOP_TO_BOTTOM) {
+				style.left = `${computedCuePosition}%`;
+				style.width = "auto";
+			} else style.top = `${computedCuePosition}%`;
+		}
+		style.textAlign = cue.textAlign;
+		style.textDecoration = cue.textDecoration.join(" ");
+		style.writingMode = cue.writingMode;
+		if (!("writingMode" in document.documentElement.style) || style.writingMode != cue.writingMode) style.webkitWritingMode = cue.writingMode;
+		if (cue.size) {
+			if (cue.writingMode != Cue.writingMode.HORIZONTAL_TOP_TO_BOTTOM) style.height = `${cue.size}%`;
+		}
+	}
+};
+var UITextDisplayer_default = UITextDisplayer;
+
+//#endregion
+//#region src/playerCore/shaka.js
+const getQualityItem = (track) => ({
+	id: track.originalVideoId,
+	bitrate: track.videoBandwidth,
+	width: track.width,
+	height: track.height,
+	codec: track.videoCodec,
+	frameRate: track.frameRate
+});
+const rewriteDashManifest = (type, response) => {
+	const { MANIFEST } = window.shaka.net.NetworkingEngine.RequestType;
+	if (type !== MANIFEST) return response;
+	const data = new TextDecoder().decode(response.data);
+	if (/<MPD/i.test(data)) response.data = new TextEncoder().encode(fixDashManifest_default(data));
+	return response;
+};
+const sleep = (ms) => new Promise((r) => {
+	setTimeout(r, ms);
+});
+const MAX_ERROR_RETRY = 3;
+const RETRY_DELAY = 5e3;
+const isSegmentNotFound = (detail) => detail?.code === window.shaka.util.Error.Code.BAD_HTTP_STATUS && detail.severity === window.shaka.util.Error.Severity.RECOVERABLE && detail?.data[1] === 404;
+const syncStartOver = (media, player) => {
+	media.addEventListener("timeupdate", () => {
+		const { start, end } = player.seekRange();
+		const defaultLiveOffset = end - Date.now() / 1e3;
+		const seekDurationDiff = end - start - Date.now() / 1e3;
+		if (media.defaultLiveOffset && Math.abs(defaultLiveOffset - media.defaultLiveOffset) + Math.abs(seekDurationDiff - media.seekDurationDiff) > 7) {
+			media.defaultLiveOffset = defaultLiveOffset;
+			media.seekDurationDiff = seekDurationDiff;
+		}
+	});
+};
+const proxyTextTrackEvents = (media, { player }) => {
+	const handleTextTrackChange = () => media.dispatchEvent(new CustomEvent("textTrackChange", { detail: { getTextTracks: () => player.isTextTrackVisible() ? player.getTextTracks() : [] } }));
+	player.addEventListener("texttrackvisibility", handleTextTrackChange);
+	player.addEventListener("textchange", handleTextTrackChange);
+};
+const loadShaka = async (videoElement, config = {}, options = {}) => {
+	window.shakaMediaKeysPolyfill = true;
+	const shakaModule = await import("shaka-player");
+	const shaka$2 = shakaModule.default || shakaModule;
+	window.shaka = shaka$2;
+	shaka$2.polyfill.installAll();
+	const player = new shaka$2.Player();
+	getUrlObject_default((mediaSource) => {
+		if (player) player.mediaSource = mediaSource;
+	});
+	player.attach(videoElement);
+	player.configure({
+		...config,
+		manifest: {
+			dash: { ignoreSuggestedPresentationDelay: true },
+			retryParameters: { maxAttempts: 6 },
+			...config.manifest
+		},
+		streaming: {
+			autoLowLatencyMode: true,
+			safeSeekOffset: 0,
+			rebufferingGoal: 0,
+			...isSafari() && { preferNativeHls: true },
+			...config.streaming
+		},
+		...options.container && document.fullscreenEnabled && { textDisplayFactory: () => new UITextDisplayer_default(videoElement, options.container) }
+	});
+	syncStartOver(videoElement, player);
+	player.addEventListener("error", (event) => {
+		console.log(event);
+		const { detail = {} } = event;
+		const error = /* @__PURE__ */ new Error(`Player: ${detail.code}/${detail.name}`);
+		if (!detail || /The video element has thrown a media error|Video element triggered an Error/.test(detail.message) || detail.data?.some?.((message) => /Unsupported source type/i.test(message))) return;
+		if (detail.code == 3016) return;
+		if (isSegmentNotFound(detail)) {
+			setTimeout(() => {
+				if (player.errorRetry < MAX_ERROR_RETRY) {
+					player.errorRetry += 1;
+					player.reload();
+				}
+			}, RETRY_DELAY);
+			return;
+		}
+		videoElement.dispatchEvent(Object.assign(new CustomEvent("error"), {
+			error: detail,
+			message: `Player Error: ${detail.code}/${detail.message?.split(" ", 3)[2]}`
+		}));
+		if (detail.code === 1001 || detail.severity === 2) {
+			console.info("Stream unavailable, unload source");
+			player.unload();
+		}
+		window.Sentry?.captureException(error);
+	});
+	player.addEventListener("loaded", () => {
+		videoElement.dispatchEvent(new CustomEvent("canplay", {}));
+	});
+	player.addEventListener("adaptation", (event) => {
+		const { videoBandwidth, width, height } = event.newTrack;
+		if (event.oldTrack.height !== height) videoElement.dispatchEvent(new CustomEvent("downloadQualityChange", { detail: {
+			bitrate: parseInt(videoBandwidth / 1e3, 10),
+			height,
+			width
+		} }));
+	});
+	player.addEventListener("variantchanged", (event) => {
+		const { language } = event.newTrack;
+		if (event.oldTrack.language !== language) videoElement.dispatchEvent(new CustomEvent("audioTrackChange", { detail: { lang: language } }));
+	});
+	proxyTextTrackEvents(videoElement, { player });
+	const extensionOptions = {
+		requestHandlers: [],
+		responseHandlers: [rewriteDashManifest]
+	};
+	if (isSafari()) setupKKFariplay_default(player, extensionOptions);
+	const getAvailableVideoQualities = () => player.getVariantTracks().reduce((trackList, currentTrack) => {
+		if (!trackList.find((track) => track.height === currentTrack.height)) trackList.push(getQualityItem(currentTrack));
+		return trackList;
+	}, []);
+	const getVideoQuality = () => {
+		const activeTrack = player.getVariantTracks().find((track) => track.active);
+		if (!activeTrack) return {};
+		return getQualityItem(activeTrack);
+	};
+	VttTextParser_default.register(shaka$2);
+	HttpFetchPlugin_default.register(shaka$2);
+	const networkEngine = player.getNetworkingEngine();
+	networkEngine.registerRequestFilter((type, request) => extensionOptions.requestHandlers.reduce((merged, handler) => handler(type, merged, player, extensionOptions), request));
+	networkEngine.registerResponseFilter((type, response) => extensionOptions.responseHandlers.reduce((merged, handler) => handler(type, merged, player, extensionOptions), response));
+	const load = player.load.bind(player);
+	const extensions = {
+		shaka: shaka$2,
+		errorRetry: 0,
+		lastLoad: {},
+		get mediaSource() {
+			return player.mediaSource;
+		},
+		configureExtensions: ({ drm } = {}) => {
+			extensionOptions.drm = drm;
+		},
+		load: async (assetUri, startTime, mimeType) => {
+			await sleep(0);
+			player.lastLoad = {
+				assetUri,
+				startTime,
+				mimeType
+			};
+			return load(assetUri, startTime, mimeType);
+		},
+		reload: async () => {
+			await player.unload();
+			const { assetUri, startTime, mimeType } = player.lastLoad;
+			return player.load(assetUri, startTime, mimeType);
+		},
+		getPlaybackSpeed: () => videoElement.playbackRate,
+		getVideoElement: () => videoElement,
+		getVideoQuality,
+		getAvailableVideoQualities,
+		isAlive: () => player.getLoadMode() !== shaka$2.Player.LoadMode.DESTROYED,
+		on: player.addEventListener.bind(player)
+	};
+	Object.assign(player, extensions);
+	return player;
+};
+
+//#endregion
+//#region src/playerCore/loadPlayer.js
+const loadPlayer = async (videoElement, { container, source, shaka: shaka$2, bitmovin }) => {
+	if (isIOS()) on(document, "visibilitychange", () => setTimeout(() => videoElement.pause(), 50));
+	printVersion_default();
+	let player;
+	if (source?.native) player = await loadNative({ videoElement });
+	else if (shaka$2 || !bitmovin) {
+		player = await loadShaka(videoElement, shaka$2, { container });
+		videoElement.dispatchEvent(new CustomEvent("playerStarted"));
+	} else if (bitmovin?.load) {
+		player = await bitmovin.load({
+			container,
+			videoElement,
+			config: bitmovin
+		});
+		videoElement.dispatchEvent(new CustomEvent("playerStarted"));
+	}
+	reloadOnLiveStall(videoElement, { reload: () => player.reload() });
+	player.preferredSettings = {};
+	player.modules = {};
+	return player;
+};
+var loadPlayer_default = loadPlayer;
+
+//#endregion
+export { handleError as n, loadPlayer_default as t };