dasha 4.0.3 → 4.1.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as _$mediabunny from "mediabunny";
-import { AudioCodec, DurationMetadataRequestOptions, EncodedPacket, FilePathSource, HLS_FORMATS, Input as Input$1, InputAudioTrack as InputAudioTrack$1, InputFormat, InputOptions, InputTrack as InputTrack$2, InputTrackQuery, InputTrackQuery as InputTrackQuery$1, InputVideoTrack as InputVideoTrack$1, MediaCodec, MetadataTags, PacketRetrievalOptions, Source, TrackDisposition, UrlSource, VideoCodec, asc, desc, prefer } from "mediabunny";
+import { AudioCodec, DurationMetadataRequestOptions, EncodedPacket, FilePathSource, HLS_FORMATS, Input as Input$1, InputAudioTrack as InputAudioTrack$1, InputFormat, InputOptions, InputTrack as InputTrack$2, InputTrackQuery, InputTrackQuery as InputTrackQuery$1, InputVideoTrack as InputVideoTrack$1, MediaCodec as MediaCodec$1, MetadataTags, PacketRetrievalOptions, Source, TrackDisposition, UrlSource, VideoCodec, asc, desc, prefer } from "mediabunny";
 import { Element } from "@xmldom/xmldom";
 
 //#region src/mediabunny.d.ts
@@ -69,7 +69,7 @@ declare const AUDIO_CODECS: readonly ["aac", "opus", "mp3", "vorbis", "flac", "a
  * @group Codecs
  * @public
  */
-declare const SUBTITLE_CODECS: readonly ["srt", "vtt", "ttml", "dfxp", "ssa", "ass", "stpp", "wvtt"];
+declare const SUBTITLE_CODECS: readonly ["srt", "webvtt", "ttml", "dfxp", "ssa", "ass", "stpp"];
 /**
  * Union type of known video codecs.
  * @group Codecs
@@ -99,7 +99,7 @@ type SubtitleCodec = (typeof SUBTITLE_CODECS)[number];
  * @group Codecs
  * @public
  */
-type MediaCodec$1 = VideoCodec$1 | AudioCodec$1 | SubtitleCodec;
+type MediaCodec = VideoCodec$1 | AudioCodec$1 | SubtitleCodec;
 //#endregion
 //#region src/role-type.d.ts
 declare const ROLE_TYPE: {
@@ -148,7 +148,7 @@ type DashParsedSegment = {
 };
 type DashTrackCommon = {
   type: DashTrackType;
-  codec?: MediaCodec$1;
+  codec?: MediaCodec;
   codecString: string | null;
   languageCode?: string;
   peakBitrate: number | null;
@@ -385,7 +385,7 @@ declare abstract class DashTrackBackingBase {
   delegate<T>(fn: (track: any) => T | Promise<T>): Promise<T>;
   getId(): number;
   getNumber(): number;
-  getCodec(): MediaCodec | null;
+  getCodec(): MediaCodec$1 | null;
   getInternalCodecId(): null;
   getName(): string | null;
   getLanguageCode(): string;
@@ -446,6 +446,70 @@ declare class DashInputFormat extends InputFormat {
 declare const DASH: DashInputFormat;
 declare const DASH_FORMATS: InputFormat[];
 //#endregion
+//#region src/hls/hls-subtitles.d.ts
+type SourceWithRootPath = {
+  rootPath: string;
+  _options?: {
+    requestInit?: RequestInit;
+  };
+  _url?: string | URL | Request;
+};
+type HlsSubtitleMediaTag = {
+  autoselect: boolean;
+  codec: SubtitleCodec;
+  codecString: string;
+  default: boolean;
+  forced: boolean;
+  groupId: string;
+  hearingImpaired: boolean;
+  languageCode: string;
+  name: string | null;
+  uri: string;
+};
+declare class HlsSubtitlePlaylist implements HlsSegmentedInput {
+  #private;
+  segments: HlsSegment[];
+  constructor(source: SourceWithRootPath, playlistPath: string);
+  runUpdateSegments(): Promise<void>;
+  getDurationFromMetadata(_options: DurationMetadataRequestOptions): Promise<number | null>;
+  getLiveRefreshInterval(): Promise<number | null>;
+  isRelativeToUnixEpoch(): Promise<boolean>;
+}
+declare class HlsSubtitleTrackBacking {
+  #private;
+  constructor(params: {
+    id: number;
+    number: number;
+    pairingMask: bigint;
+    source: SourceWithRootPath;
+    track: HlsSubtitleMediaTag;
+  });
+  getType(): "subtitle";
+  getId(): number;
+  getNumber(): number;
+  getCodec(): never;
+  getInternalCodecId(): null;
+  getName(): string | null;
+  getLanguageCode(): string;
+  getTimeResolution(): number;
+  isRelativeToUnixEpoch(): Promise<boolean>;
+  getDisposition(): TrackDisposition;
+  getPairingMask(): bigint;
+  getBitrate(): null;
+  getAverageBitrate(): null;
+  getDurationFromMetadata(options: DurationMetadataRequestOptions): Promise<number | null>;
+  getLiveRefreshInterval(): Promise<number | null>;
+  getHasOnlyKeyPackets(): boolean;
+  getDecoderConfig(): Promise<null>;
+  getMetadataCodecParameterString(): string;
+  getFirstPacket(_options: unknown): Promise<EncodedPacket | null>;
+  getPacket(_timestamp: number, _options: unknown): Promise<EncodedPacket | null>;
+  getNextPacket(_packet: EncodedPacket, _options: unknown): Promise<EncodedPacket | null>;
+  getKeyPacket(_timestamp: number, _options: unknown): Promise<EncodedPacket | null>;
+  getNextKeyPacket(_packet: EncodedPacket, _options: unknown): Promise<EncodedPacket | null>;
+  getSegmentedInput(): HlsSubtitlePlaylist;
+}
+//#endregion
 //#region src/mediabunny-input.d.ts
 declare module 'mediabunny' {
   interface Input<S extends Source = Source> {
@@ -460,11 +524,36 @@ type SegmentAccessMethods = {
 type MediabunnyTrackWithSegments = InputTrack$2 & SegmentAccessMethods;
 type MediabunnyVideoTrackWithSegments = InputVideoTrack$1 & SegmentAccessMethods;
 type MediabunnyAudioTrackWithSegments = InputAudioTrack$1 & SegmentAccessMethods;
-type TrackBacking = Parameters<Input$1<Source>['_wrapBackingAsTrack']>[0];
+type NativeTrackBacking = Parameters<Input$1<Source>['_wrapBackingAsTrack']>[0];
+type SegmentableBacking = {
+  getId(): number;
+  getNumber(): number;
+  getType(): string;
+  getCodec(): MediaCodec$1 | null | Promise<MediaCodec$1 | null>;
+  getInternalCodecId?(): string | number | Uint8Array | null | Promise<string | number | Uint8Array | null>;
+  getName?(): string | null | Promise<string | null>;
+  getLanguageCode?(): string | Promise<string>;
+  getTimeResolution?(): number | Promise<number>;
+  isRelativeToUnixEpoch?(): boolean | Promise<boolean>;
+  getDisposition?(): unknown | Promise<unknown>;
+  getPairingMask?(): bigint;
+  getBitrate?(): number | null | Promise<number | null>;
+  getAverageBitrate?(): number | null | Promise<number | null>;
+  getDurationFromMetadata?(options: unknown): Promise<number | null>;
+  getLiveRefreshInterval?(): Promise<number | null>;
+  getDecoderConfig?(): Promise<VideoDecoderConfig | AudioDecoderConfig | null>;
+  getMetadataCodecParameterString?(): string | null | Promise<string | null>;
+  getSegmentedInput?(): HlsSegmentedInput | DashSegmentedInput;
+};
+type TrackBacking = NativeTrackBacking | SegmentableBacking;
+declare const BACKING_TYPE_SUBTITLE = "subtitle";
+declare const BACKING_TYPE_AUDIO = "audio";
+declare const BACKING_TYPE_VIDEO = "video";
 declare const preserveSubtitleBackingsOnInput: (input: Input$1) => Input$1<Source>;
 declare class SegmentedMediabunnyInput<S extends Source = Source> extends Input$1<S> {
   #private;
   _wrapBackingAsTrack(backing: TrackBacking): MediabunnyTrackWithSegments;
+  _getSyntheticTrackBackings(type?: typeof BACKING_TYPE_VIDEO | typeof BACKING_TYPE_AUDIO | typeof BACKING_TYPE_SUBTITLE): Promise<HlsSubtitleTrackBacking[]>;
   getTracks(query?: InputTrackQuery$1<MediabunnyTrackWithSegments>): Promise<MediabunnyTrackWithSegments[]>;
   getVideoTracks(query?: InputTrackQuery$1<MediabunnyVideoTrackWithSegments>): Promise<MediabunnyVideoTrackWithSegments[]>;
   getAudioTracks(query?: InputTrackQuery$1<MediabunnyAudioTrackWithSegments>): Promise<MediabunnyAudioTrackWithSegments[]>;
@@ -488,4 +577,4 @@ declare const isInput: (value: unknown) => value is Input;
 declare const getSegmentedInput: (track: InputTrack$1) => InputSegmentedInput;
 declare const getSegments: (track: InputTrack$1) => Promise<InputSegment[]>;
 //#endregion
-export { DASH, DASH_FORMATS, type DashSegment, type DashSegmentedInput, FilePathSource, HLS_FORMATS, type HlsSegment, type HlsSegmentedInput, Input, InputAudioTrack, InputSegment, InputSegmentedInput, InputTrack$1 as InputTrack, type InputTrackQuery, type InputTrackWithBacking, InputVideoTrack, UrlSource, asc, desc, getSegmentedInput, getSegments, isInput, prefer, preserveSubtitleBackingsOnInput };
+export { DASH, DASH_FORMATS, type DashSegment, type DashSegmentedInput, FilePathSource, HLS_FORMATS, type HlsSegment, type HlsSegmentedInput, Input, InputAudioTrack, InputSegment, InputSegmentedInput, InputTrack$1 as InputTrack, type InputTrackQuery, type InputTrackWithBacking, InputVideoTrack, type MediaCodec, type SubtitleCodec, UrlSource, asc, desc, getSegmentedInput, getSegments, isInput, prefer, preserveSubtitleBackingsOnInput };

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, CustomPathedSource, FilePathSource, HLS, 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";
+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`);
 	}
 };
@@ -250,15 +252,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 +271,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,6 +416,581 @@ 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 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;
+	}
+};
+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 requireSync = (value, getterName, asyncName) => {
 	if (value instanceof Promise) throw new Error(`'${getterName}' is not available synchronously for this track. Use '${asyncName}()' instead.`);
@@ -454,9 +1031,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;
@@ -525,6 +1103,7 @@ const preserveSubtitleBackingsOnInput = (input) => {
 var SegmentedMediabunnyInput = class extends Input$1 {
 	#trackCache = /* @__PURE__ */ new WeakMap();
 	#subtitleTrackCache = /* @__PURE__ */ new WeakMap();
+	#hlsSubtitleBackingsPromise = null;
 	async #queryTracks(query, type) {
 		const backings = await getTrackBackingsByType(this, type);
 		return queryWrappedTracks(this, backings, query);
@@ -537,6 +1116,18 @@ var SegmentedMediabunnyInput = class extends Input$1 {
 		this.#trackCache.set(track, wrapped);
 		return wrapped;
 	}
+	async _getSyntheticTrackBackings(type) {
+		if (type && type !== BACKING_TYPE_SUBTITLE) return [];
+		if (await this.getFormat() !== HLS) return [];
+		if (!this.#hlsSubtitleBackingsPromise) {
+			const promise = getHlsSubtitleTrackBackings(this).catch((error) => {
+				if (this.#hlsSubtitleBackingsPromise === promise) this.#hlsSubtitleBackingsPromise = null;
+				throw error;
+			});
+			this.#hlsSubtitleBackingsPromise = promise;
+		}
+		return this.#hlsSubtitleBackingsPromise;
+	}
 	#wrapSubtitleBacking(backing) {
 		const existing = this.#subtitleTrackCache.get(backing);
 		if (existing) return existing;
@@ -650,7 +1241,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 {
@@ -1349,7 +1940,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 () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dasha",
-  "version": "4.0.3",
+  "version": "4.1.0",
   "description": "Streaming manifest parser",
   "files": [
     "dist"
@@ -52,13 +52,13 @@
     "temporal-polyfill": "^0.3.2"
   },
   "peerDependencies": {
-    "mediabunny": ">=1.43.1"
+    "mediabunny": "^1.44.2"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0",
-    "oxfmt": "^0.46.0",
-    "oxlint": "^1.61.0",
-    "tsdown": "^0.21.10",
+    "@types/node": "^25.6.2",
+    "oxfmt": "^0.48.0",
+    "oxlint": "^1.63.0",
+    "tsdown": "^0.22.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.5"
   },