dasha 4.0.0-alpha.13 → 4.0.0-alpha.15

package/dist/index.mjs

@@ -0,0 +1,1751 @@
+import { ADTS, CustomPathedSource, FilePathSource, HLS_FORMATS, Input as Input$1, InputFormat, InputTrack, MATROSKA, MP3, MP4, QTFF, UrlSource, WEBM, asc, desc, prefer } from "mediabunny";
+import { DOMParser } from "@xmldom/xmldom";
+import { Temporal } from "temporal-polyfill";
+import { readFile } from "node:fs/promises";
+import { setTimeout } from "node:timers/promises";
+//#region src/util.ts
+const combineUrl = (baseUrl, relativeUrl) => {
+	if (!baseUrl.trim()) return relativeUrl;
+	const url1 = new URL(baseUrl);
+	return new URL(relativeUrl, url1).toString();
+};
+const parseMimes = (codecs) => codecs.toLowerCase().split(",").map((codec) => codec.trim().split(".")[0]);
+//#endregion
+//#region src/audio.ts
+const parseAudioCodecFromMime = (mime) => {
+	switch (mime.toLowerCase().trim().split(".")[0]) {
+		case "mp4a": return "aac";
+		case "ac-3": return "ac3";
+		case "ec-3": return "eac3";
+		case "opus": return "opus";
+		case "dtsc": return "dts";
+		case "alac": return "alac";
+		case "flac": return "flac";
+		default: throw new Error(`The MIME ${mime} is not supported as audio codec`);
+	}
+};
+const parseAudioCodec = (codecs) => {
+	const mimes = parseMimes(codecs);
+	for (const mime of mimes) try {
+		return parseAudioCodecFromMime(mime);
+	} catch {
+		continue;
+	}
+	throw new Error(`No MIME types matched any supported Audio Codecs in ${codecs}`);
+};
+const tryParseAudioCodec = (codecs) => {
+	try {
+		return parseAudioCodec(codecs);
+	} catch {
+		return;
+	}
+};
+const getDolbyDigitalPlusComplexityIndex = (supplementalProps = []) => {
+	const targetScheme = "tag:dolby.com,2018:dash:EC3_ExtensionComplexityIndex:2018";
+	for (const prop of supplementalProps) if (prop.schemeIdUri === targetScheme && prop.value) return parseInt(prop.value);
+};
+const checkIsDescriptive = (accessibilities = []) => {
+	for (const accessibility of accessibilities) {
+		const { schemeIdUri, value } = accessibility;
+		if (schemeIdUri == "urn:mpeg:dash:role:2011" && value === "descriptive" || schemeIdUri == "urn:tva:metadata:cs:AudioPurposeCS:2007" && value === "1") return true;
+	}
+	return false;
+};
+const parseChannels = (channels) => {
+	const isDigit = (char) => char >= "0" && char <= "9";
+	if (typeof channels === "string") {
+		if (channels.toUpperCase() == "A000") return 2;
+		else if (channels.toUpperCase() == "F801") return 5.1;
+		else if (isDigit(channels.replace("ch", "").replace(".", "")[0])) return parseFloat(channels.replace("ch", ""));
+		throw new Error(`Unsupported audio channels value, '${channels}'`);
+	}
+	return parseFloat(channels);
+};
+//#endregion
+//#region src/encrypt-method.ts
+const ENCRYPT_METHODS = {
+	NONE: "none",
+	AES_128: "aes-128",
+	AES_128_ECB: "aes-128-ecb",
+	SAMPLE_AES: "sample-aes",
+	SAMPLE_AES_CTR: "sample-aes-ctr",
+	CENC: "cenc",
+	CHACHA20: "chacha20",
+	UNKNOWN: "unknown"
+};
+//#endregion
+//#region src/role-type.ts
+const ROLE_TYPE = {
+	Subtitle: 0,
+	Main: 1,
+	Alternate: 2,
+	Supplementary: 3,
+	Commentary: 4,
+	Dub: 5,
+	Description: 6,
+	Sign: 7,
+	Metadata: 8,
+	ForcedSubtitle: 9
+};
+//#endregion
+//#region src/subtitle.ts
+const parseSubtitleCodecFromMime = (mime) => {
+	switch (mime.toLowerCase().trim().split(".")[0]) {
+		case "srt":
+		case "x-subrip": return "srt";
+		case "ssa": return "ssa";
+		case "ass": return "ass";
+		case "ttml": return "ttml";
+		case "vtt": return "vtt";
+		case "stpp": return "stpp";
+		case "wvtt": return "wvtt";
+		default: throw new Error(`The MIME ${mime} is not supported as subtitle codec`);
+	}
+};
+const parseSubtitleCodec = (codecs) => {
+	const mimes = parseMimes(codecs);
+	for (const mime of mimes) try {
+		return parseSubtitleCodecFromMime(mime);
+	} catch {
+		continue;
+	}
+	throw new Error(`No MIME types matched any supported Subtitle Codecs in ${codecs}`);
+};
+const tryParseSubtitleCodec = (codecs) => {
+	try {
+		return parseSubtitleCodec(codecs);
+	} catch {
+		return;
+	}
+};
+const checkIsClosedCaption = (roles = []) => {
+	for (const role of roles) if (role.schemeIdUri === "urn:mpeg:dash:role:2011" && role.value === "caption") return true;
+	return false;
+};
+const checkIsSdh = (accessibilities = []) => {
+	for (const accessibility of accessibilities) {
+		const { schemeIdUri, value } = accessibility;
+		if (schemeIdUri === "urn:tva:metadata:cs:AudioPurposeCS:2007" && value === "2") return true;
+	}
+	return false;
+};
+//#endregion
+//#region src/video.ts
+const PRIMARIES = {
+	Unspecified: 0,
+	BT_709: 1,
+	BT_601_625: 5,
+	BT_601_525: 6,
+	BT_2020_and_2100: 9,
+	SMPTE_ST_2113_and_EG_4321: 12
+};
+const TRANSFER = {
+	Unspecified: 0,
+	BT_709: 1,
+	BT_601: 6,
+	BT_2020: 14,
+	BT_2100: 15,
+	BT_2100_PQ: 16,
+	BT_2100_HLG: 18
+};
+const MATRIX = {
+	RGB: 0,
+	YCbCr_BT_709: 1,
+	YCbCr_BT_601_625: 5,
+	YCbCr_BT_601_525: 6,
+	YCbCr_BT_2020_and_2100: 9,
+	ICtCp_BT_2100: 14
+};
+const parseVideoCodecFromMime = (mime) => {
+	const target = mime.toLowerCase().trim().split(".")[0];
+	const avc = [
+		"avc1",
+		"avc2",
+		"avc3",
+		"dva1",
+		"dvav"
+	];
+	const hevc = [
+		"hev1",
+		"hev2",
+		"hev3",
+		"hvc1",
+		"hvc2",
+		"hvc3",
+		"dvh1",
+		"dvhe",
+		"lhv1",
+		"lhe1"
+	];
+	const vc1 = ["vc-1"];
+	const vp8 = ["vp08", "vp8"];
+	const vp9 = ["vp09", "vp9"];
+	const av1 = ["av01"];
+	if (avc.includes(target)) return "avc";
+	if (hevc.includes(target)) return "hevc";
+	if (vc1.includes(target)) return "vc1";
+	if (vp8.includes(target)) return "vp8";
+	if (vp9.includes(target)) return "vp9";
+	if (av1.includes(target)) return "av1";
+	throw new Error(`The MIME ${mime} is not supported as video codec`);
+};
+const parseDynamicRangeFromCicp = (primaries, transfer, matrix) => {
+	if (transfer == 5) transfer = TRANSFER.BT_601;
+	if (primaries == PRIMARIES.Unspecified && transfer == TRANSFER.Unspecified && matrix == MATRIX.RGB) return "sdr";
+	else if ([PRIMARIES.BT_601_625, PRIMARIES.BT_601_525].includes(primaries)) return "sdr";
+	else if (TRANSFER.BT_2100_PQ === transfer) return "hdr10";
+	else if (TRANSFER.BT_2100_HLG === transfer) return "hlg";
+	else return "sdr";
+};
+const parseVideoCodec = (codecs) => {
+	for (const codec of codecs.toLowerCase().split(",")) {
+		const mime = codec.trim().split(".")[0];
+		try {
+			return parseVideoCodecFromMime(mime);
+		} catch {
+			continue;
+		}
+	}
+	throw new Error(`No MIME types matched any supported Video Codecs in ${codecs}`);
+};
+const tryParseVideoCodec = (codecs) => {
+	try {
+		return parseVideoCodec(codecs);
+	} catch {
+		return;
+	}
+};
+const parseDynamicRange = (codecs, supplementalProps = [], essentialProps = []) => {
+	if ([
+		"dva1",
+		"dvav",
+		"dvhe",
+		"dvh1"
+	].some((value) => codecs.startsWith(value))) return "dv";
+	const primariesScheme = "urn:mpeg:mpegB:cicp:ColourPrimaries";
+	const transferScheme = "urn:mpeg:mpegB:cicp:TransferCharacteristics";
+	const matrixScheme = "urn:mpeg:mpegB:cicp:MatrixCoefficients";
+	const allProps = [...essentialProps, ...supplementalProps];
+	const getValues = (schemeIdUri) => allProps.filter((prop) => prop.schemeIdUri === schemeIdUri).flatMap((prop) => prop.value ? [parseInt(prop.value)] : []);
+	return parseDynamicRangeFromCicp(getValues(primariesScheme).reduce((acc, current) => acc + current, 0), getValues(transferScheme).reduce((acc, current) => acc + current, 0), getValues(matrixScheme).reduce((acc, current) => acc + current, 0));
+};
+//#endregion
+//#region src/dash/dash-misc.ts
+const DASH_MIME_TYPE = "application/dash+xml";
+const DASH_TEMPLATE_REPRESENTATION_ID = "$RepresentationID$";
+const DASH_TEMPLATE_BANDWIDTH = "$Bandwidth$";
+const DASH_TEMPLATE_NUMBER = "$Number$";
+const DASH_TEMPLATE_TIME = "$Time$";
+const getDashTrackMatchKey = (track) => JSON.stringify({
+	type: track.type,
+	codecString: track.codecString,
+	groupId: track.groupId,
+	width: track.type === "video" ? track.width : null,
+	height: track.type === "video" ? track.height : null,
+	languageCode: track.languageCode ?? null,
+	name: track.name,
+	role: track.role ?? null,
+	extension: track.extension
+});
+const getSourcePath = (source) => {
+	if ("rootPath" in source && typeof source.rootPath === "string") return source.rootPath;
+};
+const normalizeHeaders = (headers) => {
+	if (!headers) return {};
+	if (headers instanceof Headers) return Object.fromEntries(headers.entries());
+	if (Array.isArray(headers)) return Object.fromEntries(headers);
+	return { ...headers };
+};
+const getSourceHeaders = (source) => {
+	const requestHeaders = "_url" in source && source._url instanceof Request ? normalizeHeaders(source._url.headers) : {};
+	const optionHeaders = normalizeHeaders(("_options" in source && source._options && typeof source._options === "object" ? source._options : void 0)?.requestInit?.headers);
+	return {
+		...requestHeaders,
+		...optionHeaders
+	};
+};
+const parseOriginalUrlFromManifest = (text) => text.match(/<!--\s*URL:\s*([^\n]+?)\s*-->/)?.[1]?.trim();
+const loadDashManifest = async (source) => {
+	const manifestPath = getSourcePath(source);
+	if (!manifestPath) throw new Error("DASH input currently requires a pathed source such as UrlSource.");
+	if (manifestPath.startsWith("http://") || manifestPath.startsWith("https://")) {
+		const response = await fetch(manifestPath, { headers: getSourceHeaders(source) });
+		if (!response.ok) throw new Error(`Failed to fetch DASH manifest: ${response.status} ${response.statusText} (${response.url})`);
+		return {
+			text: await response.text(),
+			url: response.url
+		};
+	}
+	if (manifestPath.startsWith("file:")) {
+		const text = await readFile(new URL(manifestPath), "utf8");
+		return {
+			text,
+			url: parseOriginalUrlFromManifest(text) ?? manifestPath
+		};
+	}
+	const text = await readFile(manifestPath, "utf8");
+	return {
+		text,
+		url: parseOriginalUrlFromManifest(text) ?? manifestPath
+	};
+};
+const isLikelyDashPath = (source) => {
+	const path = getSourcePath(source);
+	if (!path) return false;
+	return path.toLowerCase().split(/[?#]/, 1)[0]?.endsWith(".mpd") ?? false;
+};
+const isDashManifestText = (text) => /<MPD(?:\s|>)/i.test(text);
+const replaceDashVariables = (text, variables) => {
+	let result = "";
+	for (let index = 0; index < text.length;) {
+		if (text[index] !== "$") {
+			result += text[index];
+			index += 1;
+			continue;
+		}
+		if (text[index + 1] === "$") {
+			result += "$";
+			index += 2;
+			continue;
+		}
+		const endIndex = text.indexOf("$", index + 1);
+		if (endIndex < 0) {
+			result += "$";
+			index += 1;
+			continue;
+		}
+		const match = text.slice(index + 1, endIndex).match(/^(RepresentationID|Bandwidth|Number|Time)(?:%([0-9]+)d)?$/);
+		if (!match) {
+			result += text.slice(index, endIndex + 1);
+			index = endIndex + 1;
+			continue;
+		}
+		const [, variableName, width] = match;
+		const value = variables[`$${variableName}$`];
+		if (value == null) {
+			result += text.slice(index, endIndex + 1);
+			index = endIndex + 1;
+			continue;
+		}
+		result += !width || variableName === "RepresentationID" ? value : value.padStart(Number.parseInt(width, 10), "0");
+		index = endIndex + 1;
+	}
+	return result;
+};
+const createDashTrackDescriptor = (params) => {
+	const shouldUseCodecsFromMime = params.contentType === "text" && !params.mimeType?.includes("mp4");
+	const codecString = params.codecs ?? (shouldUseCodecsFromMime ? params.mimeType?.split("/")[1] : null);
+	if (codecString) {
+		const videoCodec = tryParseVideoCodec(codecString);
+		if (videoCodec) return {
+			type: "video",
+			codec: videoCodec,
+			codecString
+		};
+		const audioCodec = tryParseAudioCodec(codecString);
+		if (audioCodec) return {
+			type: "audio",
+			codec: audioCodec,
+			codecString
+		};
+		const subtitleCodec = tryParseSubtitleCodec(codecString);
+		if (subtitleCodec) return {
+			type: "subtitle",
+			codec: subtitleCodec,
+			codecString
+		};
+	} else {
+		const type = params.contentType || params.mimeType?.split("/")[0];
+		if (type === "video") return {
+			type: "video",
+			codecString: null
+		};
+		if (type === "audio") return {
+			type: "audio",
+			codecString: null
+		};
+		if (type === "text") {
+			const subtitleCodecString = params.mimeType?.split("/")[1] ?? null;
+			return {
+				type: "subtitle",
+				codec: subtitleCodecString ? tryParseSubtitleCodec(subtitleCodecString) : void 0,
+				codecString: subtitleCodecString
+			};
+		}
+	}
+	throw new Error("Unable to determine the type of a track, cannot continue...");
+};
+const getDirectDashChildren = (node, tag) => node.getElementsByTagName(tag).filter((child) => !!child.parentNode?.isSameNode(node));
+const getDirectDashChild = (node, tag) => getDirectDashChildren(node, tag)[0];
+const getInheritedDashChild = (tag, ...nodes) => {
+	for (const node of nodes) {
+		const child = getDirectDashChild(node, tag);
+		if (child) return child;
+	}
+};
+const getDashTagAttrs = (tag, ...elements) => {
+	for (const element of elements) {
+		const matches = getDirectDashChildren(element, tag);
+		if (!matches.length) continue;
+		return matches.flatMap((match) => {
+			const schemeIdUri = match.getAttribute("schemeIdUri");
+			if (!schemeIdUri) return [];
+			return {
+				schemeIdUri,
+				value: match.getAttribute("value") ?? void 0
+			};
+		});
+	}
+	return [];
+};
+const extendDashBaseUrl = (node, baseUrl) => {
+	const target = getDirectDashChild(node, "BaseURL");
+	if (target?.textContent) return combineUrl(baseUrl, target.textContent);
+	return baseUrl;
+};
+const getDashFrameRate = (node) => {
+	const frameRate = node.getAttribute("frameRate");
+	if (!frameRate || !frameRate.includes("/")) return;
+	const value = Number(frameRate.split("/")[0]) / Number(frameRate.split("/")[1]);
+	return Number(value.toFixed(3));
+};
+const parseDashRange = (range) => {
+	const [startRange, end] = range.split("-").map(Number);
+	return [startRange, end - startRange + 1];
+};
+//#endregion
+//#region src/mediabunny-input.ts
+const requireSync = (value, getterName, asyncName) => {
+	if (value instanceof Promise) throw new Error(`'${getterName}' is not available synchronously for this track. Use '${asyncName}()' instead.`);
+	return value;
+};
+const queryTracks = async (tracks, query) => {
+	let matched = tracks;
+	if (query?.filter) {
+		const filterMatches = tracks.map((track) => query.filter(track));
+		const resolvedFilterMatches = await Promise.all(filterMatches);
+		matched = tracks.filter((_, index) => resolvedFilterMatches[index]);
+	}
+	if (!query?.sortBy) return matched;
+	const resolvedSortValues = await Promise.all(matched.map((track) => query.sortBy(track)));
+	return matched.map((track, index) => ({
+		track,
+		sortValue: resolvedSortValues[index]
+	})).sort((left, right) => {
+		const leftValues = Array.isArray(left.sortValue) ? left.sortValue : [left.sortValue];
+		const rightValues = Array.isArray(right.sortValue) ? right.sortValue : [right.sortValue];
+		const maxLength = Math.max(leftValues.length, rightValues.length);
+		for (let index = 0; index < maxLength; index++) {
+			const leftValue = leftValues[index] ?? 0;
+			const rightValue = rightValues[index] ?? 0;
+			if (leftValue === rightValue) continue;
+			return leftValue - rightValue;
+		}
+		return 0;
+	}).map(({ track }) => track);
+};
+const BACKING_TYPE_SUBTITLE = "subtitle";
+const BACKING_TYPE_AUDIO = "audio";
+const BACKING_TYPE_VIDEO = "video";
+const BASE_INPUT_PATCHED = Symbol.for("dasha.base-mediabunny-input-patched");
+const PRESERVE_SUBTITLE_BACKINGS = Symbol.for("dasha.preserve-subtitle-backings");
+const getBackingType = (backing) => backing.getType?.();
+const queryWrappedTracks = (input, backings, query) => {
+	return queryTracks(backings.map((backing) => input._wrapBackingAsTrack(backing)), query);
+};
+const getTrackBackingsByType = async (input, type) => {
+	const backings = await input._getTrackBackings();
+	if (!type) return backings;
+	return backings.filter((backing) => getBackingType(backing) === type);
+};
+const patchBaseMediabunnyInput = () => {
+	const prototype = Input$1.prototype;
+	if (prototype[BASE_INPUT_PATCHED]) return;
+	prototype.getTracks = function(query) {
+		return getTrackBackingsByType(this).then((backings) => queryWrappedTracks(this, this[PRESERVE_SUBTITLE_BACKINGS] ? backings : backings.filter((backing) => getBackingType(backing) !== BACKING_TYPE_SUBTITLE), query));
+	};
+	prototype.getAudioTracks = function(query) {
+		return getTrackBackingsByType(this, BACKING_TYPE_AUDIO).then((backings) => queryWrappedTracks(this, backings, query));
+	};
+	prototype[BASE_INPUT_PATCHED] = true;
+};
+const getSegmentedInputForTrack = (track) => {
+	const backing = track._backing;
+	if ("getSegmentedInput" in backing && typeof backing.getSegmentedInput === "function") return backing.getSegmentedInput();
+	const internalTrack = backing.internalTrack;
+	return internalTrack.demuxer.getSegmentedInputForPath(internalTrack.fullPath);
+};
+const addSegmentAccess = (track) => new Proxy(track, { get(target, prop) {
+	if (prop === "getSegmentedInput") return () => getSegmentedInputForTrack(target);
+	if (prop === "getSegments") return async () => {
+		const segmentedInput = getSegmentedInputForTrack(target);
+		await segmentedInput.runUpdateSegments();
+		return segmentedInput.segments;
+	};
+	const value = Reflect.get(target, prop, target);
+	return typeof value === "function" ? value.bind(target) : value;
+} });
+var MediabunnyInputSubtitleTrack = class extends InputTrack {
+	#backing;
+	constructor(input, backing) {
+		super();
+		Object.assign(this, {
+			input,
+			_backing: backing
+		});
+		this.#backing = backing;
+	}
+	get type() {
+		return "subtitle";
+	}
+	async getCodec() {
+		return this.#backing.getCodec();
+	}
+	get codec() {
+		return requireSync(this.#backing.getCodec(), "codec", "getCodec");
+	}
+	async getCodecParameterString() {
+		return await this.#backing.getMetadataCodecParameterString?.() ?? null;
+	}
+	async canDecode() {
+		return true;
+	}
+	async determinePacketType(_packet) {
+		return null;
+	}
+	async hasOnlyKeyPackets() {
+		return true;
+	}
+};
+patchBaseMediabunnyInput();
+const preserveSubtitleBackingsOnInput = (input) => {
+	Object.assign(input, { [PRESERVE_SUBTITLE_BACKINGS]: true });
+	return input;
+};
+var SegmentedMediabunnyInput = class extends Input$1 {
+	#trackCache = /* @__PURE__ */ new WeakMap();
+	#subtitleTrackCache = /* @__PURE__ */ new WeakMap();
+	async #queryTracks(query, type) {
+		const backings = await getTrackBackingsByType(this, type);
+		return queryWrappedTracks(this, backings, query);
+	}
+	_wrapBackingAsTrack(backing) {
+		const track = backing.getType?.() === "subtitle" ? this.#wrapSubtitleBacking(backing) : super._wrapBackingAsTrack(backing);
+		const existing = this.#trackCache.get(track);
+		if (existing) return existing;
+		const wrapped = addSegmentAccess(track);
+		this.#trackCache.set(track, wrapped);
+		return wrapped;
+	}
+	#wrapSubtitleBacking(backing) {
+		const existing = this.#subtitleTrackCache.get(backing);
+		if (existing) return existing;
+		const track = new MediabunnyInputSubtitleTrack(this, backing);
+		this.#subtitleTrackCache.set(backing, track);
+		return track;
+	}
+	async getTracks(query) {
+		return await this.#queryTracks(query);
+	}
+	async getVideoTracks(query) {
+		return await this.#queryTracks(query, BACKING_TYPE_VIDEO);
+	}
+	async getAudioTracks(query) {
+		return await this.#queryTracks(query, BACKING_TYPE_AUDIO);
+	}
+	async getPrimaryVideoTrack(query) {
+		return await super.getPrimaryVideoTrack(query);
+	}
+	async getPrimaryAudioTrack(query) {
+		return await super.getPrimaryAudioTrack(query);
+	}
+};
+//#endregion
+//#region src/dash/dash-segmented-input.ts
+const roundToDivisor = (value, multiple) => Math.round(value * multiple) / multiple;
+const binarySearchLessOrEqual = (array, value, getValue) => {
+	let left = 0;
+	let right = array.length - 1;
+	let result = -1;
+	while (left <= right) {
+		const mid = left + right >> 1;
+		if (getValue(array[mid]) <= value) {
+			result = mid;
+			left = mid + 1;
+		} else right = mid - 1;
+	}
+	return result;
+};
+const getLeastRecentlyUsedIndex = (entries) => {
+	let bestIndex = -1;
+	let bestAge = Infinity;
+	for (const [index, entry] of entries.entries()) if (entry.age < bestAge) {
+		bestAge = entry.age;
+		bestIndex = index;
+	}
+	return bestIndex;
+};
+const getSegmentLocation = (segment) => ({
+	path: segment.url,
+	offset: segment.startRange ?? 0,
+	length: segment.expectLength ?? null
+});
+const createInitSegment = (segment) => ({
+	timestamp: 0,
+	duration: 0,
+	relativeToUnixEpoch: false,
+	firstSegment: null,
+	sequenceNumber: segment.sequenceNumber,
+	location: getSegmentLocation(segment),
+	encryption: segment.encryption,
+	initSegment: null,
+	lastProgramDateTimeSeconds: null
+});
+const trackToDashSegments = (internalTrack) => {
+	const mediaSegments = internalTrack.track.mediaSegments;
+	if (mediaSegments.length === 0) return [];
+	let nextTimestamp = 0;
+	const segments = [];
+	for (const mediaSegment of mediaSegments) {
+		const timestamp = mediaSegment.timestamp ?? nextTimestamp;
+		const dashSegment = {
+			timestamp,
+			duration: mediaSegment.duration,
+			relativeToUnixEpoch: false,
+			firstSegment: null,
+			sequenceNumber: mediaSegment.sequenceNumber,
+			location: getSegmentLocation(mediaSegment),
+			encryption: mediaSegment.encryption,
+			initSegment: null,
+			lastProgramDateTimeSeconds: null
+		};
+		segments.push(dashSegment);
+		nextTimestamp = timestamp + mediaSegment.duration;
+	}
+	const firstSegment = segments[0] ?? null;
+	const initSegment = internalTrack.track.initSegment ? createInitSegment(internalTrack.track.initSegment) : null;
+	for (const segment of segments) {
+		segment.firstSegment = firstSegment;
+		segment.initSegment = initSegment;
+	}
+	return segments;
+};
+var DashSegmentedInput = class {
+	internalTrack;
+	demuxer;
+	segments = [];
+	currentUpdateSegmentsPromise = null;
+	lastSegmentUpdateTime = -Infinity;
+	nextInputCacheAge = 0;
+	inputCache = [];
+	firstTrackPromise = null;
+	packetInfos = /* @__PURE__ */ new WeakMap();
+	firstSegmentFirstTimestamps = /* @__PURE__ */ new WeakMap();
+	firstTimestampCache = /* @__PURE__ */ new WeakMap();
+	constructor(internalTrack) {
+		this.internalTrack = internalTrack;
+		this.demuxer = internalTrack.demuxer;
+	}
+	runUpdateSegments() {
+		return this.currentUpdateSegmentsPromise ??= (async () => {
+			try {
+				const remainingWaitTimeMs = this.getRemainingWaitTimeMs();
+				if (remainingWaitTimeMs > 0) await setTimeout(remainingWaitTimeMs);
+				this.lastSegmentUpdateTime = performance.now();
+				await this.updateSegments();
+			} finally {
+				this.currentUpdateSegmentsPromise = null;
+			}
+		})();
+	}
+	async updateSegments() {
+		await this.demuxer.refreshTrackSegments(this.internalTrack);
+		this.segments = trackToDashSegments(this.internalTrack);
+	}
+	getRemainingWaitTimeMs() {
+		if (!this.internalTrack.track.isLive) return 0;
+		const elapsed = performance.now() - this.lastSegmentUpdateTime;
+		const result = Math.max(0, this.internalTrack.track.refreshIntervalMs - elapsed);
+		if (result <= 50) return 0;
+		return result;
+	}
+	async getFirstSegment() {
+		if (this.segments.length === 0) await this.runUpdateSegments();
+		return this.segments[0] ?? null;
+	}
+	async getSegmentAt(timestamp, options) {
+		if (this.segments.length === 0) await this.runUpdateSegments();
+		let isLazy = !!options.skipLiveWait && this.getRemainingWaitTimeMs() > 0;
+		while (true) {
+			const index = binarySearchLessOrEqual(this.segments, timestamp, (segment) => segment.timestamp);
+			if (index === -1) return null;
+			if (index < this.segments.length - 1 || !this.internalTrack.track.isLive || isLazy) return this.segments[index];
+			const segment = this.segments[index];
+			if (timestamp < segment.timestamp + segment.duration) return segment;
+			await this.runUpdateSegments();
+			if (options.skipLiveWait) isLazy = true;
+		}
+	}
+	getNextSegmentIndex(segment) {
+		const currentIndex = this.segments.indexOf(segment);
+		if (currentIndex !== -1) return currentIndex + 1;
+		if (segment.sequenceNumber !== null) {
+			const matchingSequenceIndex = this.segments.findIndex((candidate) => candidate.sequenceNumber === segment.sequenceNumber);
+			if (matchingSequenceIndex !== -1) return matchingSequenceIndex + 1;
+			return this.segments.findIndex((candidate) => candidate.sequenceNumber !== null && candidate.sequenceNumber > segment.sequenceNumber);
+		}
+		const matchingLocationIndex = this.segments.findIndex((candidate) => candidate.timestamp === segment.timestamp && candidate.duration === segment.duration && candidate.location.path === segment.location.path && candidate.location.offset === segment.location.offset && candidate.location.length === segment.location.length);
+		if (matchingLocationIndex !== -1) return matchingLocationIndex + 1;
+		return this.segments.findIndex((candidate) => candidate.timestamp > segment.timestamp);
+	}
+	async getNextSegment(segment, options) {
+		let isLazy = !!options.skipLiveWait && this.getRemainingWaitTimeMs() > 0;
+		while (true) {
+			const nextIndex = this.getNextSegmentIndex(segment);
+			if (nextIndex !== -1 && nextIndex < this.segments.length) return this.segments[nextIndex];
+			if (!this.internalTrack.track.isLive || isLazy) return null;
+			await this.runUpdateSegments();
+			if (options.skipLiveWait) isLazy = true;
+		}
+	}
+	async getPreviousSegment(segment) {
+		const index = this.segments.indexOf(segment);
+		if (index === -1) throw new Error("Segment was not created by this segmented input.");
+		return this.segments[index - 1] ?? null;
+	}
+	getInputForSegment(segment) {
+		const input = this.demuxer.input;
+		const cacheEntry = this.inputCache.find((entry) => entry.segment === segment);
+		if (cacheEntry) {
+			cacheEntry.age = this.nextInputCacheAge++;
+			return cacheEntry.input;
+		}
+		let initInput = null;
+		if (segment.initSegment && segment.initSegment !== segment) initInput = this.getInputForSegment(segment.initSegment);
+		const formatOptions = { ...input._formatOptions };
+		const segmentInput = preserveSubtitleBackingsOnInput(new Input$1({
+			source: new CustomPathedSource(segment.location.path, async (request) => {
+				if (!request.isRoot) throw new Error("Nested requests are not supported for DASH segments.");
+				const proxiedRequest = {
+					...request,
+					isRoot: false
+				};
+				let ref = await input._getSourceCached(proxiedRequest);
+				if (segment.location.offset > 0 || segment.location.length !== null) {
+					const sliceRef = ref.source.slice(segment.location.offset, segment.location.length ?? void 0).ref();
+					ref.free();
+					ref = sliceRef;
+				}
+				return ref;
+			}),
+			formats: input._formats.filter((format) => format.mimeType !== DASH_MIME_TYPE),
+			initInput: initInput ?? void 0,
+			formatOptions
+		}));
+		this.inputCache.push({
+			age: this.nextInputCacheAge++,
+			input: segmentInput,
+			segment
+		});
+		if (this.inputCache.length > 4) {
+			const minAgeIndex = getLeastRecentlyUsedIndex(this.inputCache);
+			if (minAgeIndex === -1) throw new Error("Failed to evict cached DASH segment input.");
+			this.inputCache.splice(minAgeIndex, 1);
+		}
+		return segmentInput;
+	}
+	async getTrackForSegment(segment) {
+		const matchingType = (await this.getInputForSegment(segment).getTracks()).filter((track) => track.type === this.internalTrack.info.type);
+		if (matchingType.length === 1) return matchingType[0];
+		if (this.internalTrack.track.codec) {
+			for (const track of matchingType) if (await track.getCodec() === this.internalTrack.track.codec) return track;
+		}
+		return matchingType[0] ?? null;
+	}
+	async getFirstTrack() {
+		return this.firstTrackPromise ??= (async () => {
+			const firstSegment = await this.getFirstSegment();
+			if (!firstSegment) throw new Error("Missing first DASH segment, cannot hydrate track.");
+			const track = await this.getTrackForSegment(firstSegment);
+			if (!track) throw new Error("No matching track found in DASH segment media data.");
+			return track;
+		})();
+	}
+	async getFirstTimestampForInput(input) {
+		const existing = this.firstTimestampCache.get(input);
+		if (existing !== void 0) return existing;
+		const firstTimestamp = await input.getFirstTimestamp();
+		this.firstTimestampCache.set(input, firstTimestamp);
+		return firstTimestamp;
+	}
+	async getMediaOffset(segment, input, track) {
+		const firstSegment = segment.firstSegment ?? segment;
+		let firstSegmentFirstTimestamp;
+		if (this.firstSegmentFirstTimestamps.has(firstSegment)) firstSegmentFirstTimestamp = this.firstSegmentFirstTimestamps.get(firstSegment);
+		else {
+			const firstInput = this.getInputForSegment(firstSegment);
+			firstSegmentFirstTimestamp = await this.getFirstTimestampForInput(firstInput);
+			this.firstSegmentFirstTimestamps.set(firstSegment, firstSegmentFirstTimestamp);
+		}
+		if (firstSegment === segment) return firstSegment.timestamp - firstSegmentFirstTimestamp;
+		const segmentFirstTimestamp = await this.getFirstTimestampForInput(input);
+		const segmentElapsed = segment.timestamp - firstSegment.timestamp;
+		const difference = segmentFirstTimestamp - firstSegmentFirstTimestamp - segmentElapsed;
+		if (Math.abs(difference) <= Math.min(.25, segmentElapsed)) return firstSegment.timestamp - firstSegmentFirstTimestamp;
+		return segment.timestamp - segmentFirstTimestamp;
+	}
+	async createAdjustedPacket(packet, segment, track) {
+		if (packet.sequenceNumber < 0) throw new Error("DASH packet sequence number must be non-negative.");
+		const input = track.input;
+		const mediaOffset = await this.getMediaOffset(segment, input, track);
+		const firstSegment = segment.firstSegment ?? segment;
+		const segmentTimestampRelativeToFirst = segment.timestamp - firstSegment.timestamp;
+		const modified = packet.clone({
+			timestamp: roundToDivisor(packet.timestamp + mediaOffset, await track.getTimeResolution()),
+			sequenceNumber: Math.floor(1e8 * segmentTimestampRelativeToFirst) + packet.sequenceNumber
+		});
+		this.packetInfos.set(modified, {
+			segment,
+			track,
+			sourcePacket: packet
+		});
+		return modified;
+	}
+	async getDecoderConfig() {
+		return (await this.getFirstTrack())._backing.getDecoderConfig();
+	}
+	async getHasOnlyKeyPackets() {
+		return await (await this.getFirstTrack())._backing.getHasOnlyKeyPackets?.() ?? null;
+	}
+	async getFirstPacket(options) {
+		const firstSegment = await this.getFirstSegment();
+		if (!firstSegment) return null;
+		const track = await this.getTrackForSegment(firstSegment);
+		if (!track) return null;
+		const packet = await track._backing.getFirstPacket(options);
+		if (!packet) return null;
+		return this.createAdjustedPacket(packet, firstSegment, track);
+	}
+	getNextPacket(packet, options) {
+		return this.getNextPacketInternal(packet, options, false);
+	}
+	getNextKeyPacket(packet, options) {
+		return this.getNextPacketInternal(packet, options, true);
+	}
+	async getNextPacketInternal(packet, options, keyframesOnly) {
+		const info = this.packetInfos.get(packet);
+		if (!info) throw new Error("Packet was not created from this DASH track.");
+		const nextPacket = keyframesOnly ? await info.track._backing.getNextKeyPacket(info.sourcePacket, options) : await info.track._backing.getNextPacket(info.sourcePacket, options);
+		if (nextPacket) return this.createAdjustedPacket(nextPacket, info.segment, info.track);
+		let currentSegment = info.segment;
+		while (true) {
+			const nextSegment = await this.getNextSegment(currentSegment, { skipLiveWait: options.skipLiveWait });
+			if (!nextSegment) return null;
+			const nextTrack = await this.getTrackForSegment(nextSegment);
+			if (!nextTrack) {
+				currentSegment = nextSegment;
+				continue;
+			}
+			const firstPacket = await nextTrack._backing.getFirstPacket(options);
+			if (!firstPacket) {
+				currentSegment = nextSegment;
+				continue;
+			}
+			return this.createAdjustedPacket(firstPacket, nextSegment, nextTrack);
+		}
+	}
+	getPacket(timestamp, options) {
+		return this.getPacketInternal(timestamp, options, false);
+	}
+	getKeyPacket(timestamp, options) {
+		return this.getPacketInternal(timestamp, options, true);
+	}
+	async getPacketInternal(timestamp, options, keyframesOnly) {
+		let currentSegment = await this.getSegmentAt(timestamp, { skipLiveWait: options.skipLiveWait });
+		if (!currentSegment) return null;
+		while (currentSegment) {
+			const track = await this.getTrackForSegment(currentSegment);
+			if (!track) {
+				currentSegment = await this.getPreviousSegment(currentSegment);
+				continue;
+			}
+			const input = track.input;
+			const offsetTimestamp = timestamp - await this.getMediaOffset(currentSegment, input, track);
+			const packet = keyframesOnly ? await track._backing.getKeyPacket(offsetTimestamp, options) : await track._backing.getPacket(offsetTimestamp, options);
+			if (!packet) {
+				currentSegment = await this.getPreviousSegment(currentSegment);
+				continue;
+			}
+			return this.createAdjustedPacket(packet, currentSegment, track);
+		}
+		return null;
+	}
+	async getLiveRefreshInterval() {
+		if (this.getRemainingWaitTimeMs() === 0) await this.runUpdateSegments();
+		return this.internalTrack.track.isLive ? this.internalTrack.track.refreshIntervalMs / 1e3 : null;
+	}
+};
+//#endregion
+//#region src/dash/dash-demuxer.ts
+const DASH_NAMESPACE_MAP = new Map([
+	["cenc", "urn:mpeg:cenc:2013"],
+	["mspr", "urn:microsoft:playready"],
+	["mas", "urn:marlin:mas:1-0:services:schemas:mpd"]
+]);
+const WIDEVINE_SYSTEM_ID = "edef8ba9-79d6-4ace-a3c8-27dcd51d21ed";
+const PLAYREADY_SYSTEM_ID = "9a04f079-9840-4286-ab92-e65be0885f95";
+const DEFAULT_TRACK_DISPOSITION = {
+	commentary: false,
+	default: true,
+	forced: false,
+	hearingImpaired: false,
+	original: false,
+	primary: true,
+	visuallyImpaired: false
+};
+const isMissingNamespace = (rawText, tag) => !rawText.includes(`xmlns:${tag}`) && rawText.includes(`<${tag}:`);
+const replaceFirst = (source, oldValue, newValue) => {
+	const index = source.indexOf(oldValue);
+	return index < 0 ? source : source.slice(0, index) + newValue + source.slice(index + oldValue.length);
+};
+const processDashContent = (mpdContent) => {
+	const missingNamespaceKeys = Array.from(DASH_NAMESPACE_MAP.keys().filter((key) => isMissingNamespace(mpdContent, key)));
+	if (!missingNamespaceKeys.length) return mpdContent;
+	return replaceFirst(mpdContent, "<MPD ", `<MPD ${missingNamespaceKeys.map((key) => `xmlns:${key}="${DASH_NAMESPACE_MAP.get(key)}"`).join(" ")} `);
+};
+const getDashRefreshIntervalMs = (timeShiftBufferDepth) => Temporal.Duration.from(timeShiftBufferDepth).total("milliseconds") / 2;
+const getDisposition = (track) => ({
+	...DEFAULT_TRACK_DISPOSITION,
+	commentary: track.role === ROLE_TYPE.Commentary,
+	default: !!track.default,
+	forced: track.role === ROLE_TYPE.ForcedSubtitle || !!(track.type === "subtitle" && track.forced),
+	hearingImpaired: !!(track.type === "subtitle" && track.sdh),
+	visuallyImpaired: !!(track.type === "audio" && track.descriptive)
+});
+const canPairTracks = (left, right) => {
+	if (left === right || left.type === right.type) return false;
+	if (left.type === "video" && right.type === "audio") return !left.audioGroupId || left.audioGroupId === right.groupId;
+	if (left.type === "audio" && right.type === "video") return !right.audioGroupId || right.audioGroupId === left.groupId;
+	if (left.type === "video" && right.type === "subtitle") return !left.subtitleGroupId || left.subtitleGroupId === right.groupId;
+	if (left.type === "subtitle" && right.type === "video") return !right.subtitleGroupId || right.subtitleGroupId === left.groupId;
+	return false;
+};
+const createPairingMasks = (tracks) => {
+	const masks = /* @__PURE__ */ new Map();
+	let nextPairIndex = 0;
+	for (const [leftIndex, left] of tracks.entries()) for (const right of tracks.slice(leftIndex + 1)) {
+		if (!canPairTracks(left, right)) continue;
+		const bit = 1n << BigInt(nextPairIndex++);
+		masks.set(left, (masks.get(left) ?? 0n) | bit);
+		masks.set(right, (masks.get(right) ?? 0n) | bit);
+	}
+	return masks;
+};
+const createTrackInfo = (track) => {
+	if (track.type === "video") return {
+		type: "video",
+		width: track.width ?? null,
+		height: track.height ?? null
+	};
+	if (track.type === "audio") return {
+		type: "audio",
+		numberOfChannels: track.numberOfChannels ?? null
+	};
+	return { type: "subtitle" };
+};
+const createInternalTracks = (demuxer, tracks) => {
+	const pairingMasks = createPairingMasks(tracks);
+	return tracks.map((track, index) => ({
+		id: index + 1,
+		demuxer,
+		backingTrack: null,
+		pairingMask: pairingMasks.get(track) ?? 0n,
+		track,
+		info: createTrackInfo(track)
+	}));
+};
+const getTrackNumber = (internalTrack) => {
+	const internalTracks = internalTrack.demuxer.internalTracks;
+	if (!internalTracks) return 1;
+	let number = 0;
+	for (const track of internalTracks) {
+		if (track.info.type === internalTrack.info.type) number++;
+		if (track === internalTrack) break;
+	}
+	return number;
+};
+const addWholeResourceSegment = (track, url, duration) => {
+	track.mediaSegments.push({
+		sequenceNumber: 0,
+		duration,
+		url,
+		encryption: null
+	});
+};
+const appendDashSegment = (track, segment) => {
+	track.mediaSegments.push(segment);
+};
+const createDashRangedSegment = (url, sequenceNumber, range) => {
+	const segment = {
+		sequenceNumber,
+		duration: 0,
+		url,
+		encryption: null
+	};
+	if (range) {
+		const [start, expect] = parseDashRange(range);
+		segment.startRange = start;
+		segment.expectLength = expect;
+	}
+	return segment;
+};
+const getSegmentTimelineEntries = (timeline, timescale, limit) => {
+	const entries = [];
+	let currentTime = 0;
+	for (const entry of getDirectDashChildren(timeline, "S")) {
+		const duration = Number(entry.getAttribute("d"));
+		if (!Number.isFinite(duration)) continue;
+		const startTime = entry.getAttribute("t");
+		if (startTime) currentTime = Number(startTime);
+		let repeatCount = Number(entry.getAttribute("r"));
+		if (!Number.isFinite(repeatCount)) repeatCount = 0;
+		const remaining = limit - entries.length;
+		if (remaining <= 0) break;
+		const totalEntries = repeatCount < 0 ? remaining : Math.min(repeatCount + 1, remaining);
+		for (let i = 0; i < totalEntries; i++) {
+			entries.push({
+				duration: duration / timescale,
+				timestamp: currentTime / timescale
+			});
+			currentTime += duration;
+		}
+	}
+	return entries;
+};
+const getRoleType = (roleValue) => {
+	const capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
+	return ROLE_TYPE[roleValue.split("-").map(capitalize).join("")];
+};
+const createDashTrack = (params) => {
+	const { adaptationSet, contentType, frameRate, isLive, mimeType, period, representation, timeShiftBufferDepth } = params;
+	const bitrate = params.bitrate;
+	const descriptor = createDashTrackDescriptor({
+		codecs: representation.getAttribute("codecs") || adaptationSet.getAttribute("codecs"),
+		contentType,
+		mimeType
+	});
+	const track = {
+		type: descriptor.type,
+		codec: descriptor.codec,
+		codecString: descriptor.codecString,
+		peakBitrate: bitrate,
+		averageBitrate: bitrate,
+		name: null,
+		default: false,
+		groupId: representation.getAttribute("id"),
+		periodId: period.getAttribute("id"),
+		extension: null,
+		isLive,
+		refreshIntervalMs: getDashRefreshIntervalMs(timeShiftBufferDepth),
+		initSegment: null,
+		mediaSegments: []
+	};
+	const roles = getDashTagAttrs("Role", representation, adaptationSet);
+	const supplementalProps = getDashTagAttrs("SupplementalProperty", representation, adaptationSet);
+	const essentialProps = getDashTagAttrs("EssentialProperty", representation, adaptationSet);
+	const accessibilities = getDashTagAttrs("Accessibility", representation, adaptationSet);
+	const channelsString = getDashTagAttrs("AudioChannelConfiguration", representation, adaptationSet)[0]?.value;
+	const width = representation.getAttribute("width");
+	const height = representation.getAttribute("height");
+	track.languageCode = representation.getAttribute("lang") || adaptationSet.getAttribute("lang") || void 0;
+	const volumeAdjust = representation.getAttribute("volumeAdjust");
+	if (volumeAdjust) track.groupId = `${track.groupId}-${volumeAdjust}`;
+	const actualMimeType = representation.getAttribute("mimeType") || adaptationSet.getAttribute("mimeType");
+	if (actualMimeType) {
+		const mimeTypeSplit = actualMimeType.split("/");
+		track.extension = mimeTypeSplit.length === 2 ? mimeTypeSplit[1] : null;
+	}
+	if (track.type === "video") {
+		if (width) track.width = Number(width);
+		if (height) track.height = Number(height);
+		track.frameRate = frameRate ?? getDashFrameRate(representation);
+		if (track.codecString && supplementalProps && essentialProps) track.dynamicRange = parseDynamicRange(track.codecString, supplementalProps, essentialProps);
+	} else if (track.type === "audio") {
+		if (accessibilities) track.descriptive = checkIsDescriptive(accessibilities);
+		if (supplementalProps) track.joc = getDolbyDigitalPlusComplexityIndex(supplementalProps);
+		if (channelsString) track.numberOfChannels = parseChannels(channelsString);
+	} else {
+		if (roles) track.cc = checkIsClosedCaption(roles);
+		if (accessibilities) track.sdh = checkIsSdh(accessibilities);
+	}
+	const role = roles[0];
+	if (role?.value) track.role = getRoleType(role.value);
+	return track;
+};
+const normalizeDashTrackExtension = (track) => {
+	if (track.type === "subtitle" && track.extension === "mp4") track.extension = "m4s";
+	if (track.type !== "subtitle" && (track.extension == null || track.mediaSegments.length > 1)) track.extension = "m4s";
+};
+const getDashSegmentSourceChild = (tag, representation, adaptationSet, period) => getInheritedDashChild(tag, representation, adaptationSet, period);
+const applySegmentBase = (params) => {
+	const { adaptationSet, period, representation, track, segmentBaseUrl } = params;
+	const segmentBaseElement = getDashSegmentSourceChild("SegmentBase", representation, adaptationSet, period);
+	if (!segmentBaseElement) return;
+	const initialization = getDirectDashChild(segmentBaseElement, "Initialization");
+	if (!initialization) return;
+	track.initSegment = createDashRangedSegment(combineUrl(segmentBaseUrl, initialization.getAttribute("sourceURL") || ""), -1, initialization.getAttribute("range"));
+};
+const applySegmentList = (params) => {
+	const { adaptationSet, period, representation, track, segmentBaseUrl } = params;
+	const segmentList = getDashSegmentSourceChild("SegmentList", representation, adaptationSet, period);
+	if (!segmentList) return;
+	const initialization = getDirectDashChild(segmentList, "Initialization");
+	if (initialization) track.initSegment = createDashRangedSegment(combineUrl(segmentBaseUrl, initialization.getAttribute("sourceURL") || ""), -1, initialization.getAttribute("range"));
+	const timescale = Number(segmentList.getAttribute("timescale") || "1");
+	const segmentUrls = getDirectDashChildren(segmentList, "SegmentURL");
+	const segmentTimeline = getDirectDashChild(segmentList, "SegmentTimeline");
+	const timelineEntries = segmentTimeline ? getSegmentTimelineEntries(segmentTimeline, timescale, segmentUrls.length) : null;
+	const fixedDurationAttr = segmentList.getAttribute("duration");
+	const fixedDuration = fixedDurationAttr ? Number(fixedDurationAttr) : NaN;
+	for (const [segmentIndex, segmentUrl] of segmentUrls.entries()) {
+		const media = segmentUrl.getAttribute("media");
+		if (!media) continue;
+		const duration = timelineEntries?.[segmentIndex]?.duration ?? fixedDuration / timescale;
+		if (!Number.isFinite(duration)) break;
+		const segment = createDashRangedSegment(combineUrl(segmentBaseUrl, media), segmentIndex, segmentUrl.getAttribute("mediaRange"));
+		segment.timestamp = timelineEntries?.[segmentIndex]?.timestamp;
+		segment.duration = duration;
+		appendDashSegment(track, segment);
+	}
+};
+const appendTemplatedSegment = (params) => {
+	const { currentTime, duration, index, mediaTemplate, track } = params;
+	const { segmentNumber, segBaseUrl, timescale, variables } = params;
+	variables[DASH_TEMPLATE_TIME] = String(currentTime);
+	variables[DASH_TEMPLATE_NUMBER] = String(segmentNumber);
+	appendDashSegment(track, {
+		sequenceNumber: index,
+		timestamp: currentTime / timescale,
+		duration: duration / timescale,
+		url: combineUrl(segBaseUrl, replaceDashVariables(mediaTemplate, variables)),
+		encryption: null
+	});
+};
+const applySegmentTimeline = (params) => {
+	const { mediaTemplate, periodDurationSeconds, track, segBaseUrl } = params;
+	const { startNumberString, timeline, timescaleString, variables } = params;
+	const timelineEntries = getDirectDashChildren(timeline, "S");
+	const timescale = Number(timescaleString);
+	let segmentNumber = Number(startNumberString);
+	let currentTime = 0;
+	let segmentIndex = 0;
+	for (const entry of timelineEntries) {
+		const startTime = entry.getAttribute("t");
+		if (startTime) currentTime = Number(startTime);
+		const duration = Number(entry.getAttribute("d"));
+		let repeatCount = Number(entry.getAttribute("r"));
+		appendTemplatedSegment({
+			currentTime,
+			duration,
+			index: segmentIndex++,
+			mediaTemplate,
+			track,
+			segmentNumber: segmentNumber++,
+			segBaseUrl,
+			timescale,
+			variables
+		});
+		if (repeatCount < 0) repeatCount = Math.ceil(periodDurationSeconds * timescale / duration) - 1;
+		for (let i = 0; i < repeatCount; i++) {
+			currentTime += duration;
+			appendTemplatedSegment({
+				currentTime,
+				duration,
+				index: segmentIndex++,
+				mediaTemplate,
+				track,
+				segmentNumber: segmentNumber++,
+				segBaseUrl,
+				timescale,
+				variables
+			});
+		}
+		currentTime += duration;
+	}
+};
+const applyFixedDurationTemplate = (params) => {
+	const { availabilityStartTime, durationString, isLive, mediaTemplate, periodDurationSeconds } = params;
+	const { presentationTimeOffset, segBaseUrl, startNumberString, timeShiftBufferDepth } = params;
+	const { timescaleString, track, variables } = params;
+	const timescale = Number(timescaleString);
+	const duration = Number(durationString);
+	let startNumber = Number(startNumberString);
+	let totalNumber = Math.ceil(periodDurationSeconds * timescale / duration);
+	if (totalNumber === 0 && isLive) {
+		if (!availabilityStartTime) throw new Error("Invalid live MPD: availabilityStartTime is required.");
+		const now = Date.now();
+		const availableTime = new Date(availabilityStartTime);
+		const offsetMs = Number(presentationTimeOffset) / 1e3;
+		availableTime.setUTCMilliseconds(availableTime.getUTCMilliseconds() + offsetMs);
+		const elapsedSeconds = (now - availableTime.getTime()) / 1e3;
+		const updateWindowSeconds = Temporal.Duration.from(timeShiftBufferDepth).total("seconds");
+		startNumber += (elapsedSeconds - updateWindowSeconds) * timescale / duration;
+		totalNumber = updateWindowSeconds * timescale / duration;
+	}
+	for (let number = startNumber, segmentIndex = 0; number < startNumber + totalNumber; number++) {
+		variables[DASH_TEMPLATE_TIME] = String((number - startNumber) * duration);
+		variables[DASH_TEMPLATE_NUMBER] = String(number);
+		appendDashSegment(track, {
+			sequenceNumber: isLive ? number : segmentIndex++,
+			timestamp: (number - startNumber) * (duration / timescale),
+			duration: duration / timescale,
+			url: combineUrl(segBaseUrl, replaceDashVariables(mediaTemplate, variables)),
+			encryption: null
+		});
+	}
+};
+const applySegmentTemplate = (params) => {
+	const { adaptationSet, availabilityStartTime, bitrate, isLive, period } = params;
+	const { periodDurationSeconds, representation, representationId, segBaseUrl, track, timeShiftBufferDepth } = params;
+	const segmentTemplates = [
+		getDirectDashChild(representation, "SegmentTemplate"),
+		getDirectDashChild(adaptationSet, "SegmentTemplate"),
+		getDirectDashChild(period, "SegmentTemplate")
+	].filter((template) => !!template);
+	if (!segmentTemplates[0]) return;
+	const getTemplateAttribute = (name) => {
+		for (const template of segmentTemplates) {
+			const value = template.getAttribute(name);
+			if (value) return value;
+		}
+		return null;
+	};
+	const getTemplateTimeline = () => {
+		for (const template of segmentTemplates) {
+			const timeline = getDirectDashChild(template, "SegmentTimeline");
+			if (timeline) return timeline;
+		}
+	};
+	const variables = {
+		[DASH_TEMPLATE_BANDWIDTH]: String(bitrate),
+		[DASH_TEMPLATE_REPRESENTATION_ID]: representationId ?? ""
+	};
+	const presentationTimeOffset = getTemplateAttribute("presentationTimeOffset") || "0";
+	const timescaleString = getTemplateAttribute("timescale") || "1";
+	const durationString = getTemplateAttribute("duration");
+	const startNumberString = getTemplateAttribute("startNumber") || "1";
+	const initialization = getTemplateAttribute("initialization");
+	if (initialization) track.initSegment = {
+		sequenceNumber: -1,
+		duration: 0,
+		url: combineUrl(segBaseUrl, replaceDashVariables(initialization, variables)),
+		encryption: null
+	};
+	const mediaTemplate = getTemplateAttribute("media");
+	if (!mediaTemplate) return;
+	const segmentTimeline = getTemplateTimeline();
+	if (segmentTimeline) {
+		applySegmentTimeline({
+			mediaTemplate,
+			periodDurationSeconds,
+			track,
+			segBaseUrl,
+			startNumberString,
+			timeline: segmentTimeline,
+			timescaleString,
+			variables
+		});
+		return;
+	}
+	if (!durationString) return;
+	applyFixedDurationTemplate({
+		availabilityStartTime,
+		durationString,
+		isLive,
+		mediaTemplate,
+		periodDurationSeconds,
+		track,
+		presentationTimeOffset,
+		segBaseUrl,
+		startNumberString,
+		timeShiftBufferDepth,
+		timescaleString,
+		variables
+	});
+};
+const ensureFallbackMediaSegment = (track, segBaseUrl, periodDurationSeconds) => {
+	if (track.mediaSegments.length > 0) return;
+	addWholeResourceSegment(track, segBaseUrl, periodDurationSeconds);
+};
+const cloneEncryption = (encryption) => encryption ? {
+	method: encryption.method,
+	key: encryption.key,
+	iv: encryption.iv,
+	drm: { ...encryption.drm }
+} : null;
+const applyContentProtection = (adaptationSet, representation, track) => {
+	const representationProtections = getDirectDashChildren(representation, "ContentProtection");
+	const adaptationSetProtections = getDirectDashChildren(adaptationSet, "ContentProtection");
+	const contentProtections = representationProtections.length ? representationProtections : adaptationSetProtections;
+	if (!contentProtections.length) return;
+	const encryption = {
+		method: ENCRYPT_METHODS.CENC,
+		drm: {}
+	};
+	for (const contentProtection of contentProtections) {
+		const schemeIdUri = contentProtection.getAttribute("schemeIdUri");
+		const drmData = {
+			keyId: contentProtection.getAttribute("cenc:default_KID") || void 0,
+			pssh: getDirectDashChild(contentProtection, "cenc:pssh")?.textContent?.trim() || void 0
+		};
+		if (schemeIdUri?.includes(WIDEVINE_SYSTEM_ID)) encryption.drm.widevine = drmData;
+		else if (schemeIdUri?.includes(PLAYREADY_SYSTEM_ID)) encryption.drm.playready = drmData;
+	}
+	if (track.initSegment) track.initSegment.encryption = cloneEncryption(encryption);
+	for (const segment of track.mediaSegments) if (!segment.encryption) segment.encryption = cloneEncryption(encryption);
+};
+const mergeDashPeriodTrack = (tracks, track, isLive) => {
+	const existingTrackIndex = tracks.findIndex((item) => item.type === track.type && item.periodId !== track.periodId && item.groupId === track.groupId && (item.type === "video" && track.type === "video" ? item.width === track.width && item.height === track.height : true));
+	if (existingTrackIndex < 0) {
+		tracks.push(track);
+		return;
+	}
+	if (isLive) return;
+	const existingTrack = tracks[existingTrackIndex];
+	if (!existingTrack) return;
+	const lastSegment = existingTrack.mediaSegments.at(-1);
+	const incomingSegments = track.mediaSegments;
+	const incomingLastSegment = incomingSegments.at(-1);
+	if (!lastSegment || !incomingLastSegment) return;
+	if (lastSegment.url !== incomingLastSegment.url) {
+		const startIndex = (lastSegment.sequenceNumber ?? 0) + 1;
+		for (const segment of incomingSegments) if (segment.sequenceNumber !== null) segment.sequenceNumber += startIndex;
+		existingTrack.mediaSegments.push(...incomingSegments);
+		return;
+	}
+	lastSegment.duration += incomingSegments.reduce((sum, segment) => sum + segment.duration, 0);
+};
+const linkDefaultDashGroups = (tracks) => {
+	const audioList = tracks.filter((track) => track.type === "audio");
+	const subtitleList = tracks.filter((track) => track.type === "subtitle");
+	const videoList = tracks.filter((track) => track.type === "video");
+	for (const video of videoList) {
+		const audioGroupId = audioList.toSorted((a, b) => (b.peakBitrate || 0) - (a.peakBitrate || 0)).at(0)?.groupId;
+		const subtitleGroupId = subtitleList.toSorted((a, b) => (b.peakBitrate || 0) - (a.peakBitrate || 0)).at(0)?.groupId;
+		if (audioGroupId) video.audioGroupId = audioGroupId;
+		if (subtitleGroupId) video.subtitleGroupId = subtitleGroupId;
+	}
+};
+var DashDemuxer = class {
+	input;
+	metadataPromise = null;
+	trackBackings = null;
+	internalTracks = null;
+	segmentedInputs = [];
+	manifestUrl = "";
+	originalUrl = "";
+	headers;
+	mpdUrl = "";
+	baseUrl = "";
+	constructor(input) {
+		this.input = input;
+		this.headers = getSourceHeaders(input.source);
+	}
+	readMetadata() {
+		return this.metadataPromise ??= (async () => {
+			const { text, url } = await loadDashManifest(this.input.source);
+			this.manifestUrl = url;
+			this.originalUrl = url;
+			this.resetManifestUrls();
+			const tracks = this.extractTracks(text.trim());
+			const internalTracks = createInternalTracks(this, tracks);
+			this.internalTracks = internalTracks;
+			this.trackBackings = createTrackBackings(internalTracks);
+		})();
+	}
+	async getTrackBackings() {
+		await this.readMetadata();
+		if (!this.trackBackings) throw new Error("DASH track metadata did not initialize correctly.");
+		return this.trackBackings;
+	}
+	getSegmentedInputForTrack(track) {
+		let segmentedInput = this.segmentedInputs.find((value) => value.internalTrack === track);
+		if (segmentedInput) return segmentedInput;
+		segmentedInput = new DashSegmentedInput(track);
+		this.segmentedInputs.push(segmentedInput);
+		return segmentedInput;
+	}
+	async refreshTrackSegments(track) {
+		await this.readMetadata();
+		if (!track.track.isLive) return;
+		if (!this.manifestUrl.startsWith("http://") && !this.manifestUrl.startsWith("https://")) return;
+		const tracks = this.internalTracks?.map((internalTrack) => internalTrack.track) ?? [];
+		await this.refreshTracks(tracks);
+	}
+	async getMimeType() {
+		return DASH.mimeType;
+	}
+	async getMetadataTags() {
+		return {};
+	}
+	dispose() {
+		this.segmentedInputs.length = 0;
+	}
+	extractTracks(rawText) {
+		const manifest = this.parseManifest(rawText);
+		const tracks = [];
+		for (const period of getDirectDashChildren(manifest.mpdElement, "Period")) this.appendPeriodTracks(tracks, manifest, period);
+		linkDefaultDashGroups(tracks);
+		return tracks;
+	}
+	parseManifest(rawText) {
+		const mpdContent = processDashContent(rawText);
+		const mpdElement = new DOMParser().parseFromString(mpdContent, "text/xml").getElementsByTagName("MPD")[0];
+		const manifest = {
+			mpdElement,
+			isLive: mpdElement.getAttribute("type") === "dynamic",
+			availabilityStartTime: mpdElement.getAttribute("availabilityStartTime"),
+			timeShiftBufferDepth: mpdElement.getAttribute("timeShiftBufferDepth") || "PT1M",
+			mediaPresentationDuration: mpdElement.getAttribute("mediaPresentationDuration")
+		};
+		const baseUrlElement = getDirectDashChild(mpdElement, "BaseURL");
+		if (baseUrlElement?.textContent) {
+			let baseUrl = baseUrlElement.textContent;
+			if (baseUrl.includes("kkbox.com.tw/")) baseUrl = baseUrl.replace("//https:%2F%2F", "//");
+			this.baseUrl = combineUrl(this.mpdUrl, baseUrl);
+		}
+		return manifest;
+	}
+	appendPeriodTracks(tracks, manifest, period) {
+		const periodDurationSeconds = Temporal.Duration.from(period.getAttribute("duration") || manifest.mediaPresentationDuration || "PT0S").total("seconds");
+		const periodBaseUrl = extendDashBaseUrl(period, this.baseUrl);
+		for (const adaptationSet of getDirectDashChildren(period, "AdaptationSet")) this.appendAdaptationSetTracks({
+			tracks,
+			manifest,
+			period,
+			periodDurationSeconds,
+			periodBaseUrl,
+			adaptationSet
+		});
+	}
+	appendAdaptationSetTracks(params) {
+		const { tracks, manifest, period, periodDurationSeconds, periodBaseUrl, adaptationSet } = params;
+		const adaptationSetBaseUrl = extendDashBaseUrl(adaptationSet, periodBaseUrl);
+		const adaptationSetFrameRate = getDashFrameRate(adaptationSet);
+		let contentType = adaptationSet.getAttribute("contentType");
+		let mimeType = adaptationSet.getAttribute("mimeType");
+		for (const representation of getDirectDashChildren(adaptationSet, "Representation")) {
+			const segmentBaseUrl = extendDashBaseUrl(representation, adaptationSetBaseUrl);
+			contentType ||= representation.getAttribute("contentType");
+			mimeType ||= representation.getAttribute("mimeType");
+			const bitrate = Number(representation.getAttribute("bandwidth") ?? "");
+			const track = this.createTrack({
+				adaptationSet,
+				representation,
+				period,
+				manifest,
+				bitrate,
+				contentType,
+				mimeType,
+				frameRate: adaptationSetFrameRate
+			});
+			this.populateTrackSegments({
+				adaptationSet,
+				period,
+				representation,
+				track,
+				manifest,
+				segmentBaseUrl,
+				periodDurationSeconds,
+				bitrate
+			});
+			mergeDashPeriodTrack(tracks, track, manifest.isLive);
+		}
+	}
+	createTrack(params) {
+		const { adaptationSet, representation, period, manifest, bitrate, contentType, mimeType, frameRate } = params;
+		return createDashTrack({
+			adaptationSet,
+			bitrate,
+			contentType,
+			frameRate,
+			isLive: manifest.isLive,
+			mimeType,
+			period,
+			representation,
+			timeShiftBufferDepth: manifest.timeShiftBufferDepth
+		});
+	}
+	populateTrackSegments(params) {
+		const { adaptationSet, period, representation, track, manifest, segmentBaseUrl, periodDurationSeconds, bitrate } = params;
+		applySegmentBase({
+			adaptationSet,
+			period,
+			representation,
+			track,
+			segmentBaseUrl
+		});
+		applySegmentList({
+			adaptationSet,
+			period,
+			representation,
+			track,
+			segmentBaseUrl
+		});
+		applySegmentTemplate({
+			adaptationSet,
+			availabilityStartTime: manifest.availabilityStartTime,
+			bitrate,
+			isLive: manifest.isLive,
+			period,
+			periodDurationSeconds,
+			representationId: representation.getAttribute("id"),
+			representation,
+			segBaseUrl: segmentBaseUrl,
+			track,
+			timeShiftBufferDepth: manifest.timeShiftBufferDepth
+		});
+		ensureFallbackMediaSegment(track, segmentBaseUrl, periodDurationSeconds);
+		normalizeDashTrackExtension(track);
+		applyContentProtection(adaptationSet, representation, track);
+	}
+	findMatchingTrack(nextTracks, currentTrack) {
+		let matchingTracks = nextTracks.filter((candidate) => getDashTrackMatchKey(candidate) === getDashTrackMatchKey(currentTrack));
+		const currentInitSegmentUrl = currentTrack.initSegment?.url;
+		if (!matchingTracks.length && currentInitSegmentUrl) matchingTracks = nextTracks.filter((candidate) => candidate.initSegment?.url === currentInitSegmentUrl);
+		return matchingTracks[0];
+	}
+	async refreshTracks(tracks) {
+		if (!tracks.length) return;
+		const response = await this.fetchManifest(this.manifestUrl).catch(() => this.fetchManifest(this.originalUrl));
+		const rawText = await response.text();
+		this.manifestUrl = response.url;
+		this.resetManifestUrls();
+		const nextTracks = this.extractTracks(rawText);
+		for (const track of tracks) {
+			const nextTrack = this.findMatchingTrack(nextTracks, track);
+			if (!nextTrack) continue;
+			track.isLive = nextTrack.isLive;
+			track.refreshIntervalMs = nextTrack.refreshIntervalMs;
+			track.periodId = nextTrack.periodId;
+			track.initSegment = nextTrack.initSegment;
+			track.mediaSegments = nextTrack.mediaSegments;
+			track.audioGroupId = nextTrack.audioGroupId;
+			track.subtitleGroupId = nextTrack.subtitleGroupId;
+		}
+	}
+	async fetchManifest(url) {
+		const response = await fetch(url, { headers: this.headers });
+		if (!response.ok) throw new Error(`Failed to fetch DASH manifest: ${response.status} ${response.statusText} (${response.url})`);
+		return response;
+	}
+	resetManifestUrls() {
+		this.mpdUrl = this.manifestUrl;
+		this.baseUrl = this.mpdUrl;
+	}
+};
+var DashTrackBackingBase = class {
+	internalTrack;
+	hydratedTrackPromise = null;
+	constructor(internalTrack) {
+		this.internalTrack = internalTrack;
+	}
+	hydrate() {
+		return this.hydratedTrackPromise ??= this.getSegmentedInput().getFirstTrack();
+	}
+	delegate(fn) {
+		if (this.hydratedTrackPromise) return this.hydratedTrackPromise.then(fn);
+		return this.hydrate().then(fn);
+	}
+	getId() {
+		return this.internalTrack.id;
+	}
+	getNumber() {
+		return getTrackNumber(this.internalTrack);
+	}
+	getCodec() {
+		return this.internalTrack.track.codec ?? null;
+	}
+	getInternalCodecId() {
+		return null;
+	}
+	getName() {
+		return this.internalTrack.track.name;
+	}
+	getLanguageCode() {
+		return this.internalTrack.track.languageCode ?? "und";
+	}
+	getTimeResolution() {
+		return this.delegate((track) => track.getTimeResolution());
+	}
+	isRelativeToUnixEpoch() {
+		return false;
+	}
+	getDisposition() {
+		return getDisposition(this.internalTrack.track);
+	}
+	getPairingMask() {
+		return this.internalTrack.pairingMask;
+	}
+	getBitrate() {
+		return this.internalTrack.track.peakBitrate;
+	}
+	getAverageBitrate() {
+		return this.internalTrack.track.averageBitrate;
+	}
+	async getDurationFromMetadata(_options) {
+		return this.internalTrack.track.mediaSegments.reduce((sum, segment) => sum + segment.duration, 0);
+	}
+	async getLiveRefreshInterval() {
+		if (!this.internalTrack.track.isLive) return null;
+		return this.internalTrack.track.refreshIntervalMs / 1e3;
+	}
+	getHasOnlyKeyPackets() {
+		return false;
+	}
+	async getDecoderConfig() {
+		return this.getSegmentedInput().getDecoderConfig();
+	}
+	getMetadataCodecParameterString() {
+		return this.internalTrack.track.codecString;
+	}
+	async getFirstPacket(options) {
+		return this.getSegmentedInput().getFirstPacket(options);
+	}
+	async getPacket(timestamp, options) {
+		return this.getSegmentedInput().getPacket(timestamp, options);
+	}
+	async getNextPacket(packet, options) {
+		return this.getSegmentedInput().getNextPacket(packet, options);
+	}
+	async getKeyPacket(timestamp, options) {
+		return this.getSegmentedInput().getKeyPacket(timestamp, options);
+	}
+	async getNextKeyPacket(packet, options) {
+		return this.getSegmentedInput().getNextKeyPacket(packet, options);
+	}
+	getSegmentedInput() {
+		return this.internalTrack.demuxer.getSegmentedInputForTrack(this.internalTrack);
+	}
+	async getSegments() {
+		const segmentedInput = this.getSegmentedInput();
+		await segmentedInput.runUpdateSegments();
+		return segmentedInput.segments;
+	}
+};
+var DashInputVideoTrackBacking = class extends DashTrackBackingBase {
+	internalTrack;
+	constructor(internalTrack) {
+		super(internalTrack);
+		this.internalTrack = internalTrack;
+	}
+	getType() {
+		return "video";
+	}
+	getCodec() {
+		return this.internalTrack.track.codec ?? null;
+	}
+	getCodedWidth() {
+		return this.internalTrack.info.width ?? this.delegate((track) => track.getCodedWidth());
+	}
+	getCodedHeight() {
+		return this.internalTrack.info.height ?? this.delegate((track) => track.getCodedHeight());
+	}
+	getSquarePixelWidth() {
+		return this.internalTrack.info.width ?? this.delegate((track) => track.getSquarePixelWidth());
+	}
+	getSquarePixelHeight() {
+		return this.internalTrack.info.height ?? this.delegate((track) => track.getSquarePixelHeight());
+	}
+	getMetadataDisplayWidth() {
+		return this.internalTrack.info.width;
+	}
+	getMetadataDisplayHeight() {
+		return this.internalTrack.info.height;
+	}
+	getRotation() {
+		return 0;
+	}
+	async getColorSpace() {
+		return this.delegate((track) => track.getColorSpace());
+	}
+	async canBeTransparent() {
+		return this.delegate((track) => track.canBeTransparent());
+	}
+};
+var DashInputAudioTrackBacking = class extends DashTrackBackingBase {
+	internalTrack;
+	constructor(internalTrack) {
+		super(internalTrack);
+		this.internalTrack = internalTrack;
+	}
+	getType() {
+		return "audio";
+	}
+	getCodec() {
+		return this.internalTrack.track.codec ?? null;
+	}
+	getNumberOfChannels() {
+		return this.internalTrack.info.numberOfChannels ?? this.delegate((track) => track.getNumberOfChannels());
+	}
+	getSampleRate() {
+		return this.internalTrack.track.sampleRate ?? this.delegate((track) => track.getSampleRate());
+	}
+};
+var DashInputSubtitleTrackBacking = class extends DashTrackBackingBase {
+	internalTrack;
+	constructor(internalTrack) {
+		super(internalTrack);
+		this.internalTrack = internalTrack;
+	}
+	getType() {
+		return "subtitle";
+	}
+};
+const createTrackBackings = (internalTracks) => internalTracks.map((internalTrack) => {
+	const backing = internalTrack.info.type === "video" ? new DashInputVideoTrackBacking(internalTrack) : internalTrack.info.type === "audio" ? new DashInputAudioTrackBacking(internalTrack) : new DashInputSubtitleTrackBacking(internalTrack);
+	internalTrack.backingTrack = backing;
+	return backing;
+});
+var DashInputFormat = class extends InputFormat {
+	get name() {
+		return "Dynamic Adaptive Streaming over HTTP (DASH)";
+	}
+	get mimeType() {
+		return DASH_MIME_TYPE;
+	}
+	async _canReadInput(input) {
+		if (isLikelyDashPath(input.source)) return true;
+		try {
+			const { text } = await loadDashManifest(input.source);
+			return isDashManifestText(text);
+		} catch {
+			return false;
+		}
+	}
+	_createDemuxer(input) {
+		return new DashDemuxer(input);
+	}
+};
+const DASH = new DashInputFormat();
+const DASH_FORMATS = [
+	DASH,
+	MP4,
+	QTFF,
+	WEBM,
+	MATROSKA,
+	MP3,
+	ADTS
+];
+//#endregion
+//#region src/index.ts
+var Input = class extends SegmentedMediabunnyInput {
+	constructor(options) {
+		super(options);
+	}
+};
+const isInput = (value) => value instanceof Input;
+const getSegmentedInput = (track) => track.getSegmentedInput();
+const getSegments = async (track) => track.getSegments();
+//#endregion
+export { DASH, DASH_FORMATS, FilePathSource, HLS_FORMATS, Input, UrlSource, asc, desc, getSegmentedInput, getSegments, isInput, prefer, preserveSubtitleBackingsOnInput };