dasha 4.0.3 → 4.2.0

package/dist/index.mjs

@@ -1,8 +1,9 @@
-import { ADTS, CustomPathedSource, FilePathSource, HLS_FORMATS, Input as Input$1, InputFormat, InputTrack, MATROSKA, MP3, MP4, QTFF, UrlSource, WEBM, asc, desc, prefer } from "mediabunny";
+import { ADTS, ALL_FORMATS as ALL_FORMATS$1, CustomPathedSource, FilePathSource, HLS, HLS as HLS$1, HLS_FORMATS, Input as Input$1, InputFormat, InputTrack, InputVideoTrack, MATROSKA, MP3, MP3 as MP3$1, MP4, MP4 as MP4$1, QTFF, SourceRef, 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";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { pathToFileURL } from "node:url";
 //#region src/util.ts
 const combineUrl = (baseUrl, relativeUrl) => {
 	if (!baseUrl.trim()) return relativeUrl;
@@ -90,15 +91,16 @@ const ROLE_TYPE = {
 //#endregion
 //#region src/subtitle.ts
 const parseSubtitleCodecFromMime = (mime) => {
-	switch (mime.toLowerCase().trim().split(".")[0]) {
+	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 "webvtt":
+		case "vtt":
+		case "wvtt": return "webvtt";
 		case "stpp": return "stpp";
-		case "wvtt": return "wvtt";
 		default: throw new Error(`The MIME ${mime} is not supported as subtitle codec`);
 	}
 };
@@ -156,6 +158,32 @@ const MATRIX = {
 	YCbCr_BT_2020_and_2100: 9,
 	ICtCp_BT_2100: 14
 };
+const DOLBY_VISION_CODECS = [
+	"dva1",
+	"dvav",
+	"dvhe",
+	"dvh1"
+];
+const COLOR_PRIMARIES_MAP = new Map([
+	[PRIMARIES.BT_709, "bt709"],
+	[PRIMARIES.BT_601_625, "bt470bg"],
+	[PRIMARIES.BT_601_525, "smpte170m"],
+	[PRIMARIES.BT_2020_and_2100, "bt2020"],
+	[PRIMARIES.SMPTE_ST_2113_and_EG_4321, "smpte432"]
+]);
+const TRANSFER_CHARACTERISTICS_MAP = new Map([
+	[TRANSFER.BT_709, "bt709"],
+	[TRANSFER.BT_601, "smpte170m"],
+	[TRANSFER.BT_2100_PQ, "pq"],
+	[TRANSFER.BT_2100_HLG, "hlg"]
+]);
+const MATRIX_COEFFICIENTS_MAP = new Map([
+	[MATRIX.RGB, "rgb"],
+	[MATRIX.YCbCr_BT_709, "bt709"],
+	[MATRIX.YCbCr_BT_601_625, "bt470bg"],
+	[MATRIX.YCbCr_BT_601_525, "smpte170m"],
+	[MATRIX.YCbCr_BT_2020_and_2100, "bt2020-ncl"]
+]);
 const parseVideoCodecFromMime = (mime) => {
 	const target = mime.toLowerCase().trim().split(".")[0];
 	const avc = [
@@ -197,6 +225,52 @@ const parseDynamicRangeFromCicp = (primaries, transfer, matrix) => {
 	else if (TRANSFER.BT_2100_HLG === transfer) return "hlg";
 	else return "sdr";
 };
+const parseColorSpaceFromCicp = (primaries, transfer, matrix) => {
+	const normalizedTransfer = transfer == 5 ? TRANSFER.BT_601 : transfer;
+	return {
+		primaries: COLOR_PRIMARIES_MAP.get(primaries),
+		transfer: TRANSFER_CHARACTERISTICS_MAP.get(normalizedTransfer),
+		matrix: MATRIX_COEFFICIENTS_MAP.get(matrix)
+	};
+};
+const parseDynamicRangeFromCodecString = (codecs) => {
+	const normalized = codecs?.trim().toLowerCase();
+	if (!normalized) return;
+	return DOLBY_VISION_CODECS.some((value) => normalized.startsWith(value)) ? "dv" : void 0;
+};
+const getCicpValues = (supplementalProps = [], essentialProps = []) => {
+	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 ? [Number.parseInt(prop.value, 10)] : []);
+	return {
+		primaries: getValues(primariesScheme)[0] ?? 0,
+		transfer: getValues(transferScheme)[0] ?? 0,
+		matrix: getValues(matrixScheme)[0] ?? 0
+	};
+};
+const parseColorSpace = (supplementalProps = [], essentialProps = []) => {
+	const { primaries, transfer, matrix } = getCicpValues(supplementalProps, essentialProps);
+	return parseColorSpaceFromCicp(primaries, transfer, matrix);
+};
+const parseDynamicRangeFromHlsVideoRange = (videoRange, codecs) => {
+	const normalized = videoRange?.replaceAll("\"", "").trim().toUpperCase();
+	if (!normalized) return;
+	const codecDynamicRange = parseDynamicRangeFromCodecString(codecs);
+	if (normalized === "PQ") return codecDynamicRange ?? "hdr10";
+	if (normalized === "HLG") return "hlg";
+	if (normalized === "SDR") return "sdr";
+};
+const parseDynamicRangeFromColorSpace = (colorSpace) => {
+	if (!colorSpace) return;
+	if (colorSpace.transfer === "pq") return "hdr10";
+	if (colorSpace.transfer === "hlg") return "hlg";
+	if (colorSpace.primaries != null || colorSpace.transfer != null || colorSpace.matrix != null || colorSpace.fullRange != null) return "sdr";
+};
+const inferDynamicRange = (params) => {
+	return parseDynamicRangeFromCodecString(params.codecs) ?? parseDynamicRangeFromHlsVideoRange(params.videoRange, params.codecs) ?? parseDynamicRangeFromColorSpace(params.colorSpace) ?? "sdr";
+};
 const parseVideoCodec = (codecs) => {
 	for (const codec of codecs.toLowerCase().split(",")) {
 		const mime = codec.trim().split(".")[0];
@@ -216,18 +290,10 @@ const tryParseVideoCodec = (codecs) => {
 	}
 };
 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));
+	const codecDynamicRange = parseDynamicRangeFromCodecString(codecs);
+	if (codecDynamicRange) return codecDynamicRange;
+	const { primaries, transfer, matrix } = getCicpValues(supplementalProps, essentialProps);
+	return parseDynamicRangeFromCicp(primaries, transfer, matrix);
 };
 //#endregion
 //#region src/dash/dash-misc.ts
@@ -250,15 +316,15 @@ const getDashTrackMatchKey = (track) => JSON.stringify({
 const getSourcePath = (source) => {
 	if ("rootPath" in source && typeof source.rootPath === "string") return source.rootPath;
 };
-const normalizeHeaders = (headers) => {
+const normalizeHeaders$1 = (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);
+const getSourceHeaders$1 = (source) => {
+	const requestHeaders = "_url" in source && source._url instanceof Request ? normalizeHeaders$1(source._url.headers) : {};
+	const optionHeaders = normalizeHeaders$1(("_options" in source && source._options && typeof source._options === "object" ? source._options : void 0)?.requestInit?.headers);
 	return {
 		...requestHeaders,
 		...optionHeaders
@@ -269,7 +335,7 @@ 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) });
+		const response = await fetch(manifestPath, { headers: getSourceHeaders$1(source) });
 		if (!response.ok) throw new Error(`Failed to fetch DASH manifest: ${response.status} ${response.statusText} (${response.url})`);
 		return {
 			text: await response.text(),
@@ -414,7 +480,872 @@ const parseDashRange = (range) => {
 	return [startRange, end - startRange + 1];
 };
 //#endregion
+//#region src/hls/hls-subtitles.ts
+const TAG_STREAM_INF = "#EXT-X-STREAM-INF:";
+const TAG_MEDIA = "#EXT-X-MEDIA:";
+const TAG_EXTINF = "#EXTINF:";
+const TAG_MAP = "#EXT-X-MAP:";
+const TAG_KEY = "#EXT-X-KEY:";
+const TAG_MEDIA_SEQUENCE = "#EXT-X-MEDIA-SEQUENCE:";
+const TAG_BYTERANGE = "#EXT-X-BYTERANGE:";
+const TAG_PROGRAM_DATE_TIME = "#EXT-X-PROGRAM-DATE-TIME:";
+const TAG_DISCONTINUITY = "#EXT-X-DISCONTINUITY";
+const TAG_TARGETDURATION = "#EXT-X-TARGETDURATION:";
+const TAG_ENDLIST = "#EXT-X-ENDLIST";
+const TAG_PLAYLIST_TYPE = "#EXT-X-PLAYLIST-TYPE:";
+const AES_128_BLOCK_SIZE = 16;
+const IV_STRING_REGEX = /^0[xX][0-9a-fA-F]+$/;
+const DEFAULT_TRACK_DISPOSITION$1 = {
+	commentary: false,
+	default: true,
+	forced: false,
+	hearingImpaired: false,
+	original: false,
+	primary: true,
+	visuallyImpaired: false
+};
+const subtitleBackingsCache = /* @__PURE__ */ new WeakMap();
+const SRT_HEADER_REGEX = /(?:^|\n)\d+\s*\n(?:\d{2}:)?\d{2}:\d{2}[,.]\d{3}\s+-->\s+(?:\d{2}:)?\d{2}:\d{2}[,.]\d{3}/;
+const TTML_MARKER_REGEX = /<tt(?:\s|>)/i;
+const splitPlaylistLines = (text) => text.split(/\r?\n/g).map((line) => line.trim()).filter((line) => line.length > 0 && (!line.startsWith("#") || line.startsWith("#EXT")));
+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 = source._url instanceof Request ? normalizeHeaders(source._url.headers) : {};
+	const optionHeaders = normalizeHeaders(source._options?.requestInit?.headers);
+	return {
+		...requestHeaders,
+		...optionHeaders
+	};
+};
+const joinHlsPath = (basePath, relativePath) => {
+	if (relativePath.includes("://")) return relativePath;
+	if (basePath.includes("://")) {
+		const queryIndex = basePath.indexOf("?");
+		if (queryIndex !== -1) basePath = basePath.slice(0, queryIndex);
+	}
+	let result;
+	if (relativePath.startsWith("/")) {
+		const protocolIndex = basePath.indexOf("://");
+		if (protocolIndex === -1) result = relativePath;
+		else {
+			const pathStart = basePath.indexOf("/", protocolIndex + 3);
+			result = pathStart === -1 ? basePath + relativePath : basePath.slice(0, pathStart) + relativePath;
+		}
+	} else {
+		const lastSlash = basePath.lastIndexOf("/");
+		result = lastSlash === -1 ? relativePath : basePath.slice(0, lastSlash + 1) + relativePath;
+	}
+	let prefix = "";
+	const protocolIndex = result.indexOf("://");
+	if (protocolIndex !== -1) {
+		const pathStart = result.indexOf("/", protocolIndex + 3);
+		if (pathStart !== -1) {
+			prefix = result.slice(0, pathStart);
+			result = result.slice(pathStart);
+		}
+	}
+	const normalized = [];
+	for (const segment of result.split("/")) if (segment === "..") {
+		if (normalized.length === 0 || normalized.length === 1 && normalized[0] === "") throw new RangeError(`Invalid HLS path '${relativePath}': parent traversal exceeds root for base '${basePath}'.`);
+		normalized.pop();
+	} else if (segment !== ".") normalized.push(segment);
+	return prefix + normalized.join("/");
+};
+const toSegmentPath = (path) => path.includes("://") ? path : pathToFileURL(path).toString();
+const parseAttributeBoolean = (value) => value?.toUpperCase() === "YES";
+const stripQueryAndHash = (value) => value.split("#", 1)[0]?.split("?", 1)[0] ?? "";
+const inferSubtitleCodecStringFromPath = (path) => {
+	const normalized = stripQueryAndHash(path).toLowerCase();
+	if (normalized.endsWith(".webvtt")) return "webvtt";
+	if (normalized.endsWith(".vtt")) return "vtt";
+	if (normalized.endsWith(".srt")) return "srt";
+	if (normalized.endsWith(".ttml")) return "ttml";
+	if (normalized.endsWith(".dfxp")) return "dfxp";
+	return null;
+};
+const parseDetectedSubtitleCodec = (codecString) => {
+	if (!codecString) return null;
+	const codec = tryParseSubtitleCodec(codecString);
+	if (!codec) return null;
+	return {
+		codec,
+		codecString
+	};
+};
+const sniffSubtitleCodecFromText = (text) => {
+	const normalized = text.replaceAll("\r\n", "\n").replaceAll("\r", "\n").trimStart();
+	if (normalized.startsWith("WEBVTT")) return "webvtt";
+	if (TTML_MARKER_REGEX.test(normalized)) return "ttml";
+	if (SRT_HEADER_REGEX.test(normalized)) return "srt";
+	return null;
+};
+var AttributeList = class {
+	#attributes = {};
+	constructor(text) {
+		let key = "";
+		let value = "";
+		let inValue = false;
+		let inQuotes = false;
+		for (const char of text) {
+			if (char === "\"") {
+				inQuotes = !inQuotes;
+				continue;
+			}
+			if (char === "=" && !inValue && !inQuotes) {
+				inValue = true;
+				continue;
+			}
+			if (char === "," && !inQuotes) {
+				if (key) this.#attributes[key.trim().toLowerCase()] = value;
+				key = "";
+				value = "";
+				inValue = false;
+				continue;
+			}
+			if (inValue) value += char;
+			else key += char;
+		}
+		if (key) this.#attributes[key.trim().toLowerCase()] = value;
+	}
+	get(name) {
+		return this.#attributes[name.toLowerCase()] ?? null;
+	}
+};
+const loadPlaylistText = async (source, path) => {
+	if (path.startsWith("http://") || path.startsWith("https://")) {
+		const response = await fetch(path, { headers: getSourceHeaders(source) });
+		if (!response.ok) throw new Error(`Failed to fetch HLS playlist: ${response.status} ${response.statusText} (${response.url})`);
+		return {
+			path: response.url,
+			text: await response.text()
+		};
+	}
+	if (path.startsWith("file:")) return {
+		path,
+		text: await readFile(new URL(path), "utf8")
+	};
+	return {
+		path,
+		text: await readFile(path, "utf8")
+	};
+};
+const detectSubtitleCodecFromUri = async (source, uri) => {
+	const fromPath = parseDetectedSubtitleCodec(inferSubtitleCodecStringFromPath(uri));
+	if (fromPath) return fromPath;
+	const loaded = await loadPlaylistText(source, uri);
+	const fromText = parseDetectedSubtitleCodec(sniffSubtitleCodecFromText(loaded.text));
+	if (fromText) return fromText;
+	const lines = splitPlaylistLines(loaded.text);
+	if (lines[0] === "#EXTM3U") for (const line of lines.slice(1)) {
+		if (!line.startsWith("#")) {
+			const segmentUri = joinHlsPath(loaded.path, line);
+			const fromSegmentPath = parseDetectedSubtitleCodec(inferSubtitleCodecStringFromPath(segmentUri));
+			if (fromSegmentPath) return fromSegmentPath;
+			const fromSegmentText = parseDetectedSubtitleCodec(sniffSubtitleCodecFromText((await loadPlaylistText(source, segmentUri)).text));
+			if (fromSegmentText) return fromSegmentText;
+			continue;
+		}
+		if (!line.startsWith(TAG_MAP)) continue;
+		const mapUri = new AttributeList(line.slice(11)).get("uri");
+		if (!mapUri) continue;
+		const fromMapPath = parseDetectedSubtitleCodec(inferSubtitleCodecStringFromPath(joinHlsPath(loaded.path, mapUri)));
+		if (fromMapPath) return fromMapPath;
+	}
+	return {
+		codec: "webvtt",
+		codecString: "webvtt"
+	};
+};
+const parseMediaRange = (value) => {
+	const separatorIndex = value.indexOf("@");
+	const length = Number(separatorIndex === -1 ? value : value.slice(0, separatorIndex));
+	if (!Number.isInteger(length) || length < 0) throw new Error(`Invalid #EXT-X-BYTERANGE length '${value}'.`);
+	const offsetValue = separatorIndex === -1 ? null : Number(value.slice(separatorIndex + 1));
+	if (offsetValue !== null && (!Number.isInteger(offsetValue) || offsetValue < 0)) throw new Error(`Invalid #EXT-X-BYTERANGE offset '${value}'.`);
+	return {
+		length,
+		offset: offsetValue
+	};
+};
+const parseHexIv = (value) => {
+	if (!IV_STRING_REGEX.test(value)) throw new Error(`Unsupported IV format '${value}'.`);
+	let hex = value.slice(2);
+	hex = hex.padStart(AES_128_BLOCK_SIZE * 2, "0");
+	const iv = new Uint8Array(AES_128_BLOCK_SIZE);
+	for (let index = 0; index < AES_128_BLOCK_SIZE; index++) {
+		const startIndex = index * 2;
+		iv[index] = Number.parseInt(hex.slice(startIndex, startIndex + 2), 16);
+	}
+	return iv;
+};
+const createSequenceIv = (sequenceNumber) => {
+	const iv = new Uint8Array(AES_128_BLOCK_SIZE);
+	const view = new DataView(iv.buffer, iv.byteOffset, iv.byteLength);
+	view.setUint32(8, Math.floor(sequenceNumber / 2 ** 32));
+	view.setUint32(12, sequenceNumber);
+	return iv;
+};
+var HlsSubtitlePlaylist = class {
+	segments = [];
+	#source;
+	#playlistPath;
+	#refreshIntervalSeconds = 5;
+	#streamHasEnded = false;
+	#currentUpdatePromise = null;
+	#lastUpdateTime = -Infinity;
+	constructor(source, playlistPath) {
+		this.#source = source;
+		this.#playlistPath = playlistPath;
+	}
+	runUpdateSegments() {
+		return this.#currentUpdatePromise ??= (async () => {
+			try {
+				await this.#maybeWaitForRefresh();
+				await this.#reloadSegments();
+			} finally {
+				this.#currentUpdatePromise = null;
+			}
+		})();
+	}
+	async getDurationFromMetadata(_options) {
+		await this.runUpdateSegments();
+		const lastSegment = this.segments.at(-1);
+		return lastSegment ? lastSegment.timestamp + lastSegment.duration : null;
+	}
+	async getLiveRefreshInterval() {
+		await this.runUpdateSegments();
+		return this.#streamHasEnded ? null : this.#refreshIntervalSeconds;
+	}
+	async isRelativeToUnixEpoch() {
+		await this.runUpdateSegments();
+		return this.segments.some((segment) => segment.relativeToUnixEpoch);
+	}
+	async #maybeWaitForRefresh() {
+		if (this.#streamHasEnded || this.#lastUpdateTime === -Infinity) return;
+		const elapsed = performance.now() - this.#lastUpdateTime;
+		const remaining = Math.max(0, this.#refreshIntervalSeconds * 1e3 - elapsed);
+		if (remaining > 50) await new Promise((resolve) => setTimeout(resolve, remaining));
+	}
+	async #reloadSegments() {
+		this.#lastUpdateTime = performance.now();
+		const loaded = await loadPlaylistText(this.#source, this.#playlistPath);
+		this.#playlistPath = loaded.path;
+		const lines = splitPlaylistLines(loaded.text);
+		if (lines[0] !== "#EXTM3U") throw new Error("Invalid M3U8 file; expected first line to be #EXTM3U.");
+		let accumulatedTime = 0;
+		let nextDuration = null;
+		let currentKey = null;
+		let nextSequenceNumber = 0;
+		let currentFirstSegment = null;
+		let currentInitSegment = null;
+		let nextByteRange = null;
+		let lastByteRangeEnd = null;
+		let lastProgramDateTimeSeconds = null;
+		let targetDuration = null;
+		let segmentSeen = false;
+		const segments = [];
+		let streamHasEnded = false;
+		for (const line of lines.slice(1)) {
+			if (!line.startsWith("#")) {
+				if (nextDuration === null) throw new Error("Invalid M3U8 file; a segment must be preceded by an #EXTINF tag.");
+				const location = {
+					path: toSegmentPath(joinHlsPath(this.#playlistPath, line)),
+					offset: nextByteRange?.offset ?? 0,
+					length: nextByteRange?.length ?? null
+				};
+				const encryption = currentKey?.method === "AES-128" && !currentKey.iv ? {
+					...currentKey,
+					iv: createSequenceIv(nextSequenceNumber)
+				} : currentKey;
+				const segment = {
+					timestamp: accumulatedTime,
+					duration: nextDuration,
+					relativeToUnixEpoch: lastProgramDateTimeSeconds !== null,
+					firstSegment: currentFirstSegment,
+					sequenceNumber: nextSequenceNumber,
+					location,
+					encryption,
+					initSegment: currentInitSegment,
+					lastProgramDateTimeSeconds
+				};
+				currentFirstSegment ??= segment;
+				accumulatedTime += nextDuration;
+				segments.push(segment);
+				nextDuration = null;
+				nextSequenceNumber += 1;
+				if (nextByteRange === null) lastByteRangeEnd = null;
+				else nextByteRange = null;
+				continue;
+			}
+			if (line.startsWith(TAG_EXTINF)) {
+				if (!segmentSeen) {
+					if (lastProgramDateTimeSeconds === null && nextSequenceNumber > 0 && targetDuration !== null) accumulatedTime = nextSequenceNumber * targetDuration;
+					segmentSeen = true;
+				}
+				const content = line.slice(8);
+				const commaIndex = content.indexOf(",");
+				const durationString = commaIndex === -1 ? content : content.slice(0, commaIndex);
+				const duration = Number(durationString);
+				if (!Number.isFinite(duration) || duration < 0) throw new Error(`Invalid #EXTINF tag duration '${durationString}'.`);
+				nextDuration = duration;
+				continue;
+			}
+			if (line.startsWith(TAG_MEDIA_SEQUENCE)) {
+				const value = Number(line.slice(22));
+				if (!Number.isInteger(value) || value < 0) throw new Error(`Invalid EXT-X-MEDIA-SEQUENCE value '${line.slice(22)}'.`);
+				nextSequenceNumber = value;
+				continue;
+			}
+			if (line.startsWith(TAG_KEY)) {
+				const attributes = new AttributeList(line.slice(11));
+				const method = attributes.get("method");
+				if (method === "NONE") {
+					currentKey = null;
+					continue;
+				}
+				if (method === "AES-128") {
+					const uri = attributes.get("uri");
+					if (!uri) throw new Error("Invalid #EXT-X-KEY: AES-128 requires a URI attribute.");
+					const iv = attributes.get("iv");
+					const keyFormat = attributes.get("keyformat") ?? "identity";
+					if (keyFormat !== "identity") throw new Error("For AES-128 encryption, only the 'identity' KEYFORMAT is currently supported.");
+					currentKey = {
+						method,
+						keyUri: joinHlsPath(this.#playlistPath, uri),
+						iv: iv ? parseHexIv(iv) : null,
+						keyFormat
+					};
+					continue;
+				}
+				if (method === "SAMPLE-AES" || method === "SAMPLE-AES-CTR") {
+					currentKey = { method };
+					continue;
+				}
+				throw new Error(`Unsupported encryption method '${method}'.`);
+			}
+			if (line.startsWith(TAG_BYTERANGE)) {
+				const range = parseMediaRange(line.slice(17));
+				const nextOffset = range.offset ?? lastByteRangeEnd ?? 0;
+				nextByteRange = {
+					offset: nextOffset,
+					length: range.length
+				};
+				lastByteRangeEnd = nextOffset + range.length;
+				continue;
+			}
+			if (line.startsWith(TAG_MAP)) {
+				const attributes = new AttributeList(line.slice(11));
+				const uri = attributes.get("uri");
+				if (uri === null) throw new Error("Invalid M3U8 file; #EXT-X-MAP tag requires a URI attribute.");
+				const byterange = attributes.get("byterange");
+				const range = byterange ? parseMediaRange(byterange) : null;
+				currentInitSegment = {
+					timestamp: 0,
+					duration: 0,
+					relativeToUnixEpoch: false,
+					firstSegment: null,
+					sequenceNumber: -1,
+					location: {
+						path: toSegmentPath(joinHlsPath(this.#playlistPath, uri)),
+						offset: range?.offset ?? 0,
+						length: range?.length ?? null
+					},
+					encryption: null,
+					initSegment: null,
+					lastProgramDateTimeSeconds: null
+				};
+				continue;
+			}
+			if (line.startsWith(TAG_PROGRAM_DATE_TIME)) {
+				const dateTimeString = line.slice(25);
+				const dateTimeSeconds = new Date(dateTimeString).getTime() / 1e3;
+				if (!Number.isFinite(dateTimeSeconds)) throw new Error(`Invalid EXT-X-PROGRAM-DATE-TIME value '${dateTimeString}'.`);
+				if (segments.length > 0 && lastProgramDateTimeSeconds === null) {
+					const lastSegment = segments.at(-1);
+					if (!lastSegment) throw new Error("Expected at least one prior HLS segment.");
+					const offset = dateTimeSeconds - (lastSegment.timestamp + lastSegment.duration);
+					for (const segment of segments) {
+						segment.timestamp += offset;
+						segment.relativeToUnixEpoch = true;
+					}
+					accumulatedTime += offset;
+				}
+				lastProgramDateTimeSeconds = dateTimeSeconds;
+				accumulatedTime = dateTimeSeconds;
+				continue;
+			}
+			if (line === TAG_DISCONTINUITY) {
+				currentFirstSegment = null;
+				continue;
+			}
+			if (line.startsWith(TAG_TARGETDURATION)) {
+				const duration = Number(line.slice(22));
+				if (!Number.isFinite(duration) || duration < 0) throw new Error(`Invalid EXT-X-TARGETDURATION value '${line.slice(22)}'.`);
+				this.#refreshIntervalSeconds = duration;
+				targetDuration = duration;
+				continue;
+			}
+			if (line === TAG_ENDLIST) {
+				streamHasEnded = true;
+				break;
+			}
+			if (line.startsWith(TAG_PLAYLIST_TYPE)) {
+				if (line.slice(21).toLowerCase() === "vod") streamHasEnded = true;
+			}
+		}
+		this.segments = segments;
+		this.#streamHasEnded = streamHasEnded;
+	}
+};
+var ExternalSubtitleSegmentedInput = class {
+	segments = [];
+	#source;
+	#rootPath;
+	#delegate = null;
+	#loadPromise = null;
+	constructor(source, rootPath) {
+		this.#source = source;
+		this.#rootPath = rootPath;
+	}
+	runUpdateSegments() {
+		return this.#loadPromise ??= (async () => {
+			if (this.#delegate) {
+				await this.#delegate.runUpdateSegments();
+				this.segments = this.#delegate.segments;
+				return;
+			}
+			const loaded = await loadPlaylistText(this.#source, this.#rootPath);
+			if (splitPlaylistLines(loaded.text)[0] === "#EXTM3U") {
+				this.#delegate = new HlsSubtitlePlaylist(this.#source, loaded.path);
+				await this.#delegate.runUpdateSegments();
+				this.segments = this.#delegate.segments;
+				return;
+			}
+			const segment = {
+				timestamp: 0,
+				duration: 0,
+				relativeToUnixEpoch: false,
+				firstSegment: null,
+				sequenceNumber: 0,
+				location: {
+					path: toSegmentPath(loaded.path),
+					offset: 0,
+					length: null
+				},
+				encryption: null,
+				initSegment: null,
+				lastProgramDateTimeSeconds: null
+			};
+			segment.firstSegment = segment;
+			this.segments = [segment];
+			this.#delegate = {
+				segments: this.segments,
+				runUpdateSegments: async () => {},
+				getDurationFromMetadata: async (_options) => null,
+				getLiveRefreshInterval: async () => null,
+				isRelativeToUnixEpoch: async () => false
+			};
+		})().finally(() => {
+			this.#loadPromise = null;
+		});
+	}
+	async getDurationFromMetadata(options) {
+		await this.runUpdateSegments();
+		if (this.#delegate) return this.#delegate.getDurationFromMetadata(options);
+		return null;
+	}
+	async getLiveRefreshInterval() {
+		await this.runUpdateSegments();
+		if (this.#delegate) return this.#delegate.getLiveRefreshInterval();
+		return null;
+	}
+	async isRelativeToUnixEpoch() {
+		await this.runUpdateSegments();
+		if (this.#delegate) return this.#delegate.isRelativeToUnixEpoch();
+		return false;
+	}
+};
+var HlsSubtitleTrackBacking = class {
+	#id;
+	#number;
+	#pairingMask;
+	#track;
+	#segmentedInput;
+	constructor(params) {
+		this.#id = params.id;
+		this.#number = params.number;
+		this.#pairingMask = params.pairingMask;
+		this.#track = params.track;
+		this.#segmentedInput = new HlsSubtitlePlaylist(params.source, params.track.uri);
+	}
+	getType() {
+		return "subtitle";
+	}
+	getId() {
+		return this.#id;
+	}
+	getNumber() {
+		return this.#number;
+	}
+	getCodec() {
+		return this.#track.codec;
+	}
+	getInternalCodecId() {
+		return null;
+	}
+	getName() {
+		return this.#track.name;
+	}
+	getLanguageCode() {
+		return this.#track.languageCode || "und";
+	}
+	getTimeResolution() {
+		return 1e3;
+	}
+	isRelativeToUnixEpoch() {
+		return this.#segmentedInput.isRelativeToUnixEpoch();
+	}
+	getDisposition() {
+		return {
+			...DEFAULT_TRACK_DISPOSITION$1,
+			default: this.#track.autoselect,
+			primary: this.#track.default,
+			forced: this.#track.forced,
+			hearingImpaired: this.#track.hearingImpaired
+		};
+	}
+	getPairingMask() {
+		return this.#pairingMask;
+	}
+	getBitrate() {
+		return null;
+	}
+	getAverageBitrate() {
+		return null;
+	}
+	getDurationFromMetadata(options) {
+		return this.#segmentedInput.getDurationFromMetadata(options);
+	}
+	getLiveRefreshInterval() {
+		return this.#segmentedInput.getLiveRefreshInterval();
+	}
+	getHasOnlyKeyPackets() {
+		return true;
+	}
+	async getDecoderConfig() {
+		return null;
+	}
+	getMetadataCodecParameterString() {
+		return this.#track.codecString;
+	}
+	async getFirstPacket(_options) {
+		return null;
+	}
+	async getPacket(_timestamp, _options) {
+		return null;
+	}
+	async getNextPacket(_packet, _options) {
+		return null;
+	}
+	async getKeyPacket(_timestamp, _options) {
+		return null;
+	}
+	async getNextKeyPacket(_packet, _options) {
+		return null;
+	}
+	getSegmentedInput() {
+		return this.#segmentedInput;
+	}
+};
+var ExternalSubtitleTrackBacking = class {
+	#id;
+	#number;
+	#pairingMask;
+	#source;
+	#segmentedInput;
+	#languageCode;
+	#name;
+	#disposition;
+	#codec;
+	#codecString;
+	#codecInfoPromise = null;
+	constructor(params) {
+		this.#id = params.id;
+		this.#number = params.number;
+		this.#pairingMask = params.pairingMask;
+		this.#source = params.source;
+		this.#segmentedInput = new ExternalSubtitleSegmentedInput(params.source, params.source.rootPath);
+		this.#languageCode = params.languageCode ?? "und";
+		this.#name = params.name ?? null;
+		this.#codec = params.codec ?? tryParseSubtitleCodec(params.codecString ?? "") ?? void 0;
+		this.#codecString = params.codecString ?? params.codec ?? void 0;
+		this.#disposition = {
+			...DEFAULT_TRACK_DISPOSITION$1,
+			...params.disposition
+		};
+	}
+	getType() {
+		return "subtitle";
+	}
+	getId() {
+		return this.#id;
+	}
+	getNumber() {
+		return this.#number;
+	}
+	async #getCodecInfo() {
+		if (this.#codec !== void 0 && this.#codecString !== void 0) return {
+			codec: this.#codec,
+			codecString: this.#codecString
+		};
+		const info = await (this.#codecInfoPromise ??= detectSubtitleCodecFromUri(this.#source, this.#source.rootPath));
+		this.#codec = info.codec;
+		this.#codecString = info.codecString;
+		return info;
+	}
+	getCodec() {
+		if (this.#codec !== void 0) return this.#codec;
+		return this.#getCodecInfo().then((info) => info.codec);
+	}
+	getInternalCodecId() {
+		return null;
+	}
+	getName() {
+		return this.#name;
+	}
+	getLanguageCode() {
+		return this.#languageCode;
+	}
+	getTimeResolution() {
+		return 1e3;
+	}
+	isRelativeToUnixEpoch() {
+		return this.#segmentedInput.isRelativeToUnixEpoch();
+	}
+	getDisposition() {
+		return this.#disposition;
+	}
+	getPairingMask() {
+		return this.#pairingMask;
+	}
+	getBitrate() {
+		return null;
+	}
+	getAverageBitrate() {
+		return null;
+	}
+	getDurationFromMetadata(options) {
+		return this.#segmentedInput.getDurationFromMetadata(options);
+	}
+	getLiveRefreshInterval() {
+		return this.#segmentedInput.getLiveRefreshInterval();
+	}
+	getHasOnlyKeyPackets() {
+		return true;
+	}
+	async getDecoderConfig() {
+		return null;
+	}
+	async getMetadataCodecParameterString() {
+		if (this.#codecString !== void 0) return this.#codecString;
+		return this.#getCodecInfo().then((info) => info.codecString);
+	}
+	async getFirstPacket(_options) {
+		return null;
+	}
+	async getPacket(_timestamp, _options) {
+		return null;
+	}
+	async getNextPacket(_packet, _options) {
+		return null;
+	}
+	async getKeyPacket(_timestamp, _options) {
+		return null;
+	}
+	async getNextKeyPacket(_packet, _options) {
+		return null;
+	}
+	getSegmentedInput() {
+		return this.#segmentedInput;
+	}
+};
+const parseMasterPlaylistSubtitles = async (input) => {
+	const source = input.source;
+	if (!("rootPath" in source) || typeof source.rootPath !== "string") return [];
+	const loaded = await loadPlaylistText(source, source.rootPath);
+	const lines = splitPlaylistLines(loaded.text);
+	if (lines[0] !== "#EXTM3U") return [];
+	const subtitleMediaTags = [];
+	const pairingMasks = /* @__PURE__ */ new Map();
+	let nextPairIndex = 0n;
+	for (let index = 1; index < lines.length; index++) {
+		const line = lines[index];
+		if (!line) continue;
+		if (line.startsWith(TAG_EXTINF)) return [];
+		if (line.startsWith(TAG_STREAM_INF)) {
+			const groupId = new AttributeList(line.slice(18)).get("subtitles");
+			if (groupId !== null) pairingMasks.set(groupId, (pairingMasks.get(groupId) ?? 0n) | 1n << nextPairIndex);
+			nextPairIndex += 1n;
+			index += 1;
+			continue;
+		}
+		if (!line.startsWith(TAG_MEDIA)) continue;
+		const attributes = new AttributeList(line.slice(13));
+		if (attributes.get("type")?.toLowerCase() !== "subtitles") continue;
+		const groupId = attributes.get("group-id");
+		const uri = attributes.get("uri");
+		if (!groupId || !uri) continue;
+		const characteristics = (attributes.get("characteristics") ?? "").split(",").map((value) => value.trim().toLowerCase()).filter(Boolean);
+		const name = attributes.get("name")?.trim() ?? null;
+		const hearingImpaired = characteristics.includes("public.accessibility.transcribes-spoken-dialog") || characteristics.includes("public.accessibility.describes-music-and-sound") || name?.toLowerCase().includes("sdh") === true;
+		subtitleMediaTags.push({
+			autoselect: parseAttributeBoolean(attributes.get("default")) || parseAttributeBoolean(attributes.get("autoselect")),
+			default: parseAttributeBoolean(attributes.get("default")),
+			forced: parseAttributeBoolean(attributes.get("forced")),
+			groupId,
+			hearingImpaired,
+			languageCode: attributes.get("language") ?? "und",
+			name,
+			uri: joinHlsPath(loaded.path, uri)
+		});
+	}
+	const detectedSubtitleMediaTags = await Promise.all(subtitleMediaTags.map(async (track) => ({
+		...track,
+		...await detectSubtitleCodecFromUri(source, track.uri)
+	})));
+	const nativeTrackCount = await input._getTrackBackings().then((backings) => backings.length);
+	return detectedSubtitleMediaTags.map((track, index) => new HlsSubtitleTrackBacking({
+		id: nativeTrackCount + index + 1,
+		number: index + 1,
+		pairingMask: pairingMasks.get(track.groupId) ?? 0n,
+		source,
+		track
+	}));
+};
+const getHlsSubtitleTrackBackings = (input) => {
+	const existing = subtitleBackingsCache.get(input);
+	if (existing) return existing;
+	const promise = parseMasterPlaylistSubtitles(input);
+	subtitleBackingsCache.set(input, promise);
+	return promise;
+};
+//#endregion
 //#region src/mediabunny-input.ts
+const CUSTOM_SUBTITLE_TRACK_ID_OFFSET = 1e9;
+const CUSTOM_PAIRING_BIT_START = 1024n;
+const EXTRA_PAIRING_MASK = Symbol.for("dasha.extra-pairing-mask");
+const ORIGINAL_GET_PAIRING_MASK = Symbol.for("dasha.original-get-pairing-mask");
+const HLS_VARIANT_INF_LINE = "#EXT-X-STREAM-INF:";
+const HLS_DEMUXER_PATCHED = Symbol.for("dasha.hls-demuxer-patched");
+const HLS_DEMUXER_METADATA_PATCH = Symbol.for("dasha.hls-demuxer-metadata-patch");
+const HLS_VIDEO_RANGE_APPLIED = Symbol.for("dasha.hls-video-range-applied");
+var HlsAttributeList = class {
+	#attributes = {};
+	constructor(str) {
+		let key = "";
+		let value = "";
+		let inValue = false;
+		let inQuotes = false;
+		for (const char of str) if (char === "\"") inQuotes = !inQuotes;
+		else if (char === "=" && !inValue && !inQuotes) inValue = true;
+		else if (char === "," && !inQuotes) {
+			if (key) this.#attributes[key.trim().toLowerCase()] = value;
+			key = "";
+			value = "";
+			inValue = false;
+		} else if (inValue) value += char;
+		else key += char;
+		if (key) this.#attributes[key.trim().toLowerCase()] = value;
+	}
+	get(name) {
+		return this.#attributes[name.toLowerCase()] ?? null;
+	}
+};
+const extractHlsVideoRanges = (text) => {
+	const lines = text.split(/\r?\n/);
+	const videoRanges = [];
+	for (const rawLine of lines) {
+		const line = rawLine.trim();
+		if (!line.startsWith(HLS_VARIANT_INF_LINE)) continue;
+		const attributes = new HlsAttributeList(line.slice(18));
+		videoRanges.push(attributes.get("video-range"));
+	}
+	return videoRanges;
+};
+const getPairingMaskIndexes = (pairingMask) => {
+	const indexes = [];
+	let value = pairingMask;
+	let index = 0;
+	while (value > 0n) {
+		if ((value & 1n) === 1n) indexes.push(index);
+		value >>= 1n;
+		index++;
+	}
+	return indexes;
+};
+const applyHlsVideoRangeMetadata = async (demuxer) => {
+	if (demuxer[HLS_VIDEO_RANGE_APPLIED] || !demuxer.hasMasterPlaylist || !demuxer.internalTracks?.length) {
+		demuxer[HLS_VIDEO_RANGE_APPLIED] = true;
+		return;
+	}
+	const slice = await demuxer.input?._reader?.requestEntireFile();
+	if (!slice) {
+		demuxer[HLS_VIDEO_RANGE_APPLIED] = true;
+		return;
+	}
+	const bytes = slice instanceof Uint8Array ? slice : "bytes" in slice ? slice.bytes : slice.data;
+	const videoRanges = extractHlsVideoRanges(new TextDecoder().decode(bytes));
+	if (!videoRanges.length) {
+		demuxer[HLS_VIDEO_RANGE_APPLIED] = true;
+		return;
+	}
+	for (const track of demuxer.internalTracks) {
+		if (track.info.type !== "video") continue;
+		const matchedRanges = getPairingMaskIndexes(track.pairingMask).map((index) => videoRanges[index] ?? null).filter((value) => value != null);
+		const uniqueRanges = [...new Set(matchedRanges)];
+		track.videoRange = uniqueRanges.length === 1 ? uniqueRanges[0] : null;
+	}
+	demuxer[HLS_VIDEO_RANGE_APPLIED] = true;
+};
+const patchHlsDemuxer = (demuxer) => {
+	if (!(demuxer instanceof Object) || !("readMetadata" in demuxer) || typeof demuxer.readMetadata !== "function" || !("input" in demuxer) || demuxer[HLS_DEMUXER_PATCHED]) return demuxer;
+	const candidate = demuxer;
+	if (candidate.constructor?.name !== "HlsDemuxer") return demuxer;
+	const originalReadMetadata = candidate.readMetadata.bind(candidate);
+	candidate.readMetadata = () => {
+		if (candidate[HLS_DEMUXER_METADATA_PATCH]) return candidate[HLS_DEMUXER_METADATA_PATCH];
+		const promise = Promise.resolve(originalReadMetadata()).then(() => applyHlsVideoRangeMetadata(candidate));
+		candidate[HLS_DEMUXER_METADATA_PATCH] = promise.catch((error) => {
+			if (candidate[HLS_DEMUXER_METADATA_PATCH] === promise) candidate[HLS_DEMUXER_METADATA_PATCH] = void 0;
+			throw error;
+		});
+		return candidate[HLS_DEMUXER_METADATA_PATCH];
+	};
+	candidate[HLS_DEMUXER_PATCHED] = true;
+	return demuxer;
+};
+const getDynamicRangeForTrack = async (track) => {
+	const backing = track._backing;
+	const manifestDynamicRange = backing?.internalTrack?.track?.dynamicRange;
+	if (manifestDynamicRange) return manifestDynamicRange;
+	const codecString = await track.getCodecParameterString().catch(() => null);
+	const videoRange = backing?.internalTrack?.videoRange ?? null;
+	const fromMetadata = inferDynamicRange({
+		codecs: codecString,
+		videoRange
+	});
+	if (fromMetadata !== "sdr" || videoRange != null) return fromMetadata;
+	return inferDynamicRange({
+		codecs: codecString,
+		colorSpace: await track.getColorSpace().catch(() => null),
+		videoRange
+	});
+};
 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;
@@ -454,9 +1385,10 @@ 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 nativeBackings = await input._getTrackBackings();
+	const syntheticBackings = await input._getSyntheticTrackBackings?.(type) ?? [];
+	const backings = [...nativeBackings, ...syntheticBackings];
+	return type ? backings.filter((backing) => getBackingType(backing) === type) : backings;
 };
 const patchBaseMediabunnyInput = () => {
 	const prototype = Input$1.prototype;
@@ -467,6 +1399,10 @@ const patchBaseMediabunnyInput = () => {
 	prototype.getAudioTracks = function(query) {
 		return getTrackBackingsByType(this, BACKING_TYPE_AUDIO).then((backings) => queryWrappedTracks(this, backings, query));
 	};
+	const originalGetDemuxer = prototype._getDemuxer;
+	prototype._getDemuxer = function() {
+		return originalGetDemuxer.call(this).then((demuxer) => patchHlsDemuxer(demuxer));
+	};
 	prototype[BASE_INPUT_PATCHED] = true;
 };
 const getSegmentedInputForTrack = (track) => {
@@ -476,6 +1412,7 @@ const getSegmentedInputForTrack = (track) => {
 	return internalTrack.demuxer.getSegmentedInputForPath(internalTrack.fullPath);
 };
 const addSegmentAccess = (track) => new Proxy(track, { get(target, prop) {
+	if (prop === "getDynamicRange" && target instanceof InputVideoTrack) return () => getDynamicRangeForTrack(target);
 	if (prop === "getSegmentedInput") return () => getSegmentedInputForTrack(target);
 	if (prop === "getSegments") return async () => {
 		const segmentedInput = getSegmentedInputForTrack(target);
@@ -525,9 +1462,14 @@ const preserveSubtitleBackingsOnInput = (input) => {
 var SegmentedMediabunnyInput = class extends Input$1 {
 	#trackCache = /* @__PURE__ */ new WeakMap();
 	#subtitleTrackCache = /* @__PURE__ */ new WeakMap();
+	#hlsSubtitleBackingsPromise = null;
+	#customSubtitleBackings = [];
+	#nextCustomSubtitleTrackId = CUSTOM_SUBTITLE_TRACK_ID_OFFSET;
+	#nextCustomSubtitleTrackNumber = CUSTOM_SUBTITLE_TRACK_ID_OFFSET;
+	#nextPairingBitIndex = null;
 	async #queryTracks(query, type) {
-		const backings = await getTrackBackingsByType(this, type);
-		return queryWrappedTracks(this, backings, query);
+		const internalInput = this;
+		return queryWrappedTracks(internalInput, await getTrackBackingsByType(internalInput, type), query);
 	}
 	_wrapBackingAsTrack(backing) {
 		const track = backing.getType?.() === "subtitle" ? this.#wrapSubtitleBacking(backing) : super._wrapBackingAsTrack(backing);
@@ -537,6 +1479,19 @@ var SegmentedMediabunnyInput = class extends Input$1 {
 		this.#trackCache.set(track, wrapped);
 		return wrapped;
 	}
+	async _getSyntheticTrackBackings(type) {
+		if (type && type !== BACKING_TYPE_SUBTITLE) return [];
+		const backings = [...this.#customSubtitleBackings];
+		if (await this.getFormat() !== HLS$1) return backings;
+		if (!this.#hlsSubtitleBackingsPromise) {
+			const promise = getHlsSubtitleTrackBackings(this).catch((error) => {
+				if (this.#hlsSubtitleBackingsPromise === promise) this.#hlsSubtitleBackingsPromise = null;
+				throw error;
+			});
+			this.#hlsSubtitleBackingsPromise = promise;
+		}
+		return [...backings, ...await this.#hlsSubtitleBackingsPromise];
+	}
 	#wrapSubtitleBacking(backing) {
 		const existing = this.#subtitleTrackCache.get(backing);
 		if (existing) return existing;
@@ -553,12 +1508,83 @@ var SegmentedMediabunnyInput = class extends Input$1 {
 	async getAudioTracks(query) {
 		return await this.#queryTracks(query, BACKING_TYPE_AUDIO);
 	}
+	async getSubtitleTracks(query) {
+		return await this.#queryTracks(query, BACKING_TYPE_SUBTITLE);
+	}
 	async getPrimaryVideoTrack(query) {
 		return await super.getPrimaryVideoTrack(query);
 	}
 	async getPrimaryAudioTrack(query) {
 		return await super.getPrimaryAudioTrack(query);
 	}
+	addSubtitleTrack(source, metadata = {}) {
+		const sourceWithRootPath = this.#takeSubtitleSourceRef(source).source;
+		if (typeof sourceWithRootPath.rootPath !== "string") throw new TypeError("source must provide a string rootPath.");
+		const pairWith = this.#toPairableVideoTracks(metadata.pairWith);
+		const backing = new ExternalSubtitleTrackBacking({
+			id: this.#nextCustomSubtitleTrackId++,
+			number: this.#nextCustomSubtitleTrackNumber++,
+			pairingMask: 0n,
+			source: sourceWithRootPath,
+			codec: metadata.codec,
+			codecString: metadata.codecString,
+			disposition: metadata.disposition,
+			languageCode: metadata.languageCode,
+			name: metadata.name
+		});
+		this.#pairSubtitleBacking(backing, pairWith);
+		this.#customSubtitleBackings.push(backing);
+		return this._wrapBackingAsTrack(backing);
+	}
+	#takeSubtitleSourceRef(source) {
+		const rawSource = source instanceof SourceRef ? source.source : source;
+		if (!(rawSource instanceof Object) || !("rootPath" in rawSource) || !("ref" in rawSource) || typeof rawSource.ref !== "function") throw new TypeError("source must be a pathed source such as UrlSource or FilePathSource.");
+		const ref = rawSource.ref();
+		this._sourceRefs.push(ref);
+		return ref;
+	}
+	#toPairableVideoTracks(pairWith) {
+		if (!pairWith) return [];
+		const tracks = this.#isIterable(pairWith) ? [...pairWith] : [pairWith];
+		for (const track of tracks) {
+			if (track.input !== this) throw new TypeError("pairWith tracks must belong to the same input instance.");
+			if (track.type !== "video") throw new TypeError("pairWith only accepts video tracks.");
+		}
+		return tracks;
+	}
+	#isIterable(value) {
+		return typeof value === "object" && value !== null && Symbol.iterator in value;
+	}
+	#pairSubtitleBacking(subtitleBacking, videoTracks) {
+		for (const track of videoTracks) {
+			const bit = this.#allocatePairingBit();
+			this.#appendPairingMask(subtitleBacking, bit);
+			this.#appendPairingMask(track._backing, bit);
+		}
+	}
+	#allocatePairingBit() {
+		const nextIndex = this.#nextPairingBitIndex ?? this.#getInitialPairingBitIndex();
+		this.#nextPairingBitIndex = nextIndex + 1n;
+		return 1n << nextIndex;
+	}
+	#getInitialPairingBitIndex() {
+		const loadedBackings = [...this._trackBackingsCache ?? []];
+		let maxBitIndex = -1n;
+		for (const backing of [...loadedBackings, ...this.#customSubtitleBackings]) {
+			const mask = backing.getPairingMask?.() ?? 0n;
+			if (mask === 0n) continue;
+			const bitIndex = BigInt(mask.toString(2).length - 1);
+			if (bitIndex > maxBitIndex) maxBitIndex = bitIndex;
+		}
+		return maxBitIndex >= 0n ? maxBitIndex + 1n : CUSTOM_PAIRING_BIT_START;
+	}
+	#appendPairingMask(backing, mask) {
+		const patchedBacking = backing;
+		patchedBacking[EXTRA_PAIRING_MASK] = (patchedBacking[EXTRA_PAIRING_MASK] ?? 0n) | mask;
+		if (patchedBacking[ORIGINAL_GET_PAIRING_MASK]) return;
+		patchedBacking[ORIGINAL_GET_PAIRING_MASK] = backing.getPairingMask?.bind(backing) ?? (() => 0n);
+		Object.assign(backing, { getPairingMask: () => (patchedBacking[ORIGINAL_GET_PAIRING_MASK]?.() ?? 0n) | (patchedBacking[EXTRA_PAIRING_MASK] ?? 0n) });
+	}
 };
 //#endregion
 //#region src/dash/dash-segmented-input.ts
@@ -650,7 +1676,7 @@ var DashSegmentedInput = class {
 		return this.currentUpdateSegmentsPromise ??= (async () => {
 			try {
 				const remainingWaitTimeMs = this.getRemainingWaitTimeMs();
-				if (remainingWaitTimeMs > 0) await setTimeout(remainingWaitTimeMs);
+				if (remainingWaitTimeMs > 0) await setTimeout$1(remainingWaitTimeMs);
 				this.lastSegmentUpdateTime = performance.now();
 				await this.updateSegments();
 			} finally {
@@ -1069,7 +2095,8 @@ const createDashTrack = (params) => {
 		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);
+		if (supplementalProps.length > 0 || essentialProps.length > 0) track.colorSpace = parseColorSpace(supplementalProps, essentialProps);
+		if (track.codecString && (supplementalProps.length > 0 || essentialProps.length > 0)) track.dynamicRange = parseDynamicRange(track.codecString, supplementalProps, essentialProps);
 	} else if (track.type === "audio") {
 		if (accessibilities) track.descriptive = checkIsDescriptive(accessibilities);
 		if (supplementalProps) track.joc = getDolbyDigitalPlusComplexityIndex(supplementalProps);
@@ -1349,7 +2376,7 @@ var DashDemuxer = class {
 	baseUrl = "";
 	constructor(input) {
 		this.input = input;
-		this.headers = getSourceHeaders(input.source);
+		this.headers = getSourceHeaders$1(input.source);
 	}
 	readMetadata() {
 		return this.metadataPromise ??= (async () => {
@@ -1667,7 +2694,7 @@ var DashInputVideoTrackBacking = class extends DashTrackBackingBase {
 		return 0;
 	}
 	async getColorSpace() {
-		return this.delegate((track) => track.getColorSpace());
+		return this.internalTrack.track.colorSpace ?? this.delegate((track) => track.getColorSpace());
 	}
 	async canBeTransparent() {
 		return this.delegate((track) => track.canBeTransparent());
@@ -1730,11 +2757,11 @@ var DashInputFormat = class extends InputFormat {
 const DASH = new DashInputFormat();
 const DASH_FORMATS = [
 	DASH,
-	MP4,
+	MP4$1,
 	QTFF,
 	WEBM,
 	MATROSKA,
-	MP3,
+	MP3$1,
 	ADTS
 ];
 //#endregion
@@ -1747,5 +2774,6 @@ var Input = class extends SegmentedMediabunnyInput {
 const isInput = (value) => value instanceof Input;
 const getSegmentedInput = (track) => track.getSegmentedInput();
 const getSegments = async (track) => track.getSegments();
+const ALL_FORMATS = [...ALL_FORMATS$1, DASH];
 //#endregion
-export { DASH, DASH_FORMATS, FilePathSource, HLS_FORMATS, Input, UrlSource, asc, desc, getSegmentedInput, getSegments, isInput, prefer, preserveSubtitleBackingsOnInput };
+export { ALL_FORMATS, DASH, DASH_FORMATS, FilePathSource, HLS, HLS_FORMATS, Input, MP3, MP4, UrlSource, asc, desc, getSegmentedInput, getSegments, isInput, prefer, preserveSubtitleBackingsOnInput };