dasha 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/dasha.cjs

@@ -32,6 +32,65 @@ node_path = __toESM(node_path);
 let temporal_polyfill = require("temporal-polyfill");
 let __xmldom_xmldom = require("@xmldom/xmldom");
 
+//#region lib/shared/codec.ts
+/**
+* List of known video codecs, ordered by encoding preference.
+* @group Codecs
+* @public
+*/
+const VIDEO_CODECS = [
+	"avc",
+	"hevc",
+	"vp8",
+	"vp9",
+	"av1",
+	"vc1"
+];
+/**
+* List of known video dynamic ranges.
+* @group Codecs
+* @public
+*/
+const VIDEO_DYNAMIC_RANGES = [
+	"sdr",
+	"hlg",
+	"hdr10",
+	"hdr10+",
+	"dv"
+];
+/**
+* List of known audio codecs, ordered by encoding preference.
+* @group Codecs
+* @public
+*/
+const AUDIO_CODECS = [
+	"aac",
+	"opus",
+	"mp3",
+	"vorbis",
+	"flac",
+	"alac",
+	"ac3",
+	"eac3",
+	"dts"
+];
+/**
+* List of known subtitle codecs, ordered by encoding preference.
+* @group Codecs
+* @public
+*/
+const SUBTITLE_CODECS = [
+	"srt",
+	"vtt",
+	"ttml",
+	"dfxp",
+	"ssa",
+	"ass",
+	"stpp",
+	"wvtt"
+];
+
+//#endregion
 //#region lib/shared/encrypt-method.ts
 const ENCRYPT_METHODS = {
 	NONE: "none",
@@ -116,99 +175,166 @@ var MediaSegment = class MediaSegment {
 };
 
 //#endregion
-//#region lib/shared/media-type.ts
-const MEDIA_TYPES = {
-	VIDEO: "video",
-	AUDIO: "audio",
-	SUBTITLES: "subtitle",
-	CLOSED_CAPTIONS: "closed-captions"
+//#region lib/shared/playlist.ts
+var Playlist = class {
+	url = "";
+	isLive = false;
+	refreshIntervalMs = 15e3;
+	get totalDuration() {
+		let result = 0;
+		for (const part of this.mediaParts) for (const segment of part.mediaSegments) result += segment.duration;
+		return result;
+	}
+	targetDuration;
+	mediaInit;
+	mediaParts = [];
+};
+
+//#endregion
+//#region lib/shared/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 lib/shared/stream-spec.ts
-var StreamSpec = class {
-	mediaType;
-	groupId = null;
-	language;
+//#region lib/shared/stream-info.ts
+/**
+* List of all stream types.
+* @group Miscellaneous
+* @public
+*/
+const ALL_STREAM_TYPES = [
+	"video",
+	"audio",
+	"subtitle"
+];
+var StreamInfo = class {
+	codec;
+	languageCode;
+	bitrate;
 	name;
+	url = "";
+	originalUrl = "";
+	playlist;
 	default;
 	skippedDuration;
-	bandwidth;
-	codecs = null;
-	resolution;
-	frameRate;
-	channels = null;
-	extension = null;
 	role;
 	videoRange;
 	characteristics;
 	publishTime;
+	groupId = null;
 	audioId;
 	videoId;
 	subtitleId;
 	periodId = null;
-	url = "";
-	originalUrl = "";
-	playlist;
+	extension = null;
+	/**
+	* @deprecated Use `codec`
+	*/
+	codecs = null;
+	/**
+	* @deprecated Use `numberOfChannels` in `AudioStreamInfo`
+	*/
+	channels = null;
+	/**
+	* @deprecated Use `width` and `height` in `VideoStreamInfo`
+	*/
+	resolution;
+	/**
+	* @deprecated Use `bitrate`
+	*/
+	bandwidth;
 	get segmentsCount() {
 		return this.playlist?.mediaParts.reduce((sum, part) => sum + part.mediaSegments.length, 0) ?? 0;
 	}
+};
+var VideoStreamInfo = class extends StreamInfo {
+	codec;
+	width;
+	height;
+	frameRate;
+	dynamicRange;
+	dolbyVisionProfile;
+	get type() {
+		return "video";
+	}
+	constructor(info) {
+		super();
+		this.codec = info?.codec;
+	}
 	toShortString() {
-		let prefixStr = "";
-		let returnStr = "";
-		const encStr = "";
-		const bandwidth = this.bandwidth ? `${this.bandwidth / 1e3} Kbps` : "";
-		const channels = this.channels ? `${this.channels}CH` : "";
-		if (this.mediaType === MEDIA_TYPES.AUDIO) {
-			prefixStr = `Aud ${encStr}`;
-			returnStr = [
-				this.groupId,
-				bandwidth,
-				this.name,
-				this.codecs,
-				this.language,
-				channels,
-				this.role
-			].filter(Boolean).join(" | ");
-		} else if (this.mediaType === MEDIA_TYPES.SUBTITLES) {
-			prefixStr = `Sub ${encStr}`;
-			returnStr = [
-				this.groupId,
-				this.language,
-				this.name,
-				this.codecs,
-				this.role
-			].filter(Boolean).join(" | ");
-		} else {
-			prefixStr = `Vid ${encStr}`;
-			returnStr = [
-				this.resolution,
-				bandwidth,
-				this.groupId,
-				this.frameRate,
-				this.codecs,
-				this.videoRange,
-				this.role
-			].filter(Boolean).join(" | ");
-		}
-		returnStr = `${prefixStr} | ${returnStr}`;
-		return returnStr.trim();
+		const prefix = `Vid `;
+		const bitrate = this.bitrate ? `${this.bitrate / 1e3} Kbps` : "";
+		return `${prefix} | ${[
+			this.width ? `${this.width}x${this.height}` : "",
+			bitrate,
+			this.groupId,
+			this.frameRate,
+			this.codec ?? this.codecs,
+			this.videoRange,
+			this.role
+		].filter(Boolean).join(" | ")}`.trim();
 	}
 };
-
-//#endregion
-//#region lib/shared/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
+var AudioStreamInfo = class extends StreamInfo {
+	codec;
+	numberOfChannels;
+	sampleRate;
+	atmos;
+	descriptive;
+	joc;
+	get type() {
+		return "audio";
+	}
+	constructor(info) {
+		super();
+		this.codec = info?.codec;
+	}
+	toShortString() {
+		const prefix = `Aud `;
+		const bitrate = this.bitrate ? `${this.bitrate / 1e3} Kbps` : "";
+		const channels = this.numberOfChannels || this.channels ? `${this.numberOfChannels ?? this.channels}CH` : "";
+		return `${prefix} | ${[
+			this.groupId,
+			bitrate,
+			this.name,
+			this.codec ?? this.codecs,
+			this.languageCode,
+			channels,
+			this.role
+		].filter(Boolean).join(" | ")}`.trim();
+	}
+};
+var SubtitleStreamInfo = class extends StreamInfo {
+	codec;
+	cc;
+	sdh;
+	forced;
+	get type() {
+		return "subtitle";
+	}
+	constructor(info) {
+		super();
+		this.codec = info?.codec;
+	}
+	toShortString() {
+		return `Sub  | ${[
+			this.groupId,
+			this.languageCode,
+			this.name,
+			this.codecs,
+			this.role
+		].filter(Boolean).join(" | ")}`.trim();
+	}
 };
 
 //#endregion
@@ -453,22 +579,7 @@ const distinctBy = (array, callbackfn) => {
 		return true;
 	});
 };
-
-//#endregion
-//#region lib/shared/playlist.ts
-var Playlist = class {
-	url = "";
-	isLive = false;
-	refreshIntervalMs = 15e3;
-	get totalDuration() {
-		let result = 0;
-		for (const part of this.mediaParts) for (const segment of part.mediaSegments) result += segment.duration;
-		return result;
-	}
-	targetDuration;
-	mediaInit;
-	mediaParts = [];
-};
+const parseMimes = (codecs) => codecs.toLowerCase().split(",").map((codec) => codec.trim().split(".")[0]);
 
 //#endregion
 //#region lib/dash/dash-utils.ts
@@ -482,8 +593,251 @@ const parseRange = (range) => {
 	return [startRange, end - startRange + 1];
 };
 
+//#endregion
+//#region lib/dash/dash-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 (e) {
+			continue;
+		}
+	}
+	throw new Error(`No MIME types matched any supported Video Codecs in ${codecs}`);
+};
+const tryParseVideoCodec = (codecs) => {
+	try {
+		return parseVideoCodec(codecs);
+	} catch (e) {
+		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).map((prop) => 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 lib/dash/dash-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 (e) {
+		continue;
+	}
+	throw new Error(`No MIME types matched any supported Subtitle Codecs in ${codecs}`);
+};
+const tryParseSubtitleCodec = (codecs) => {
+	try {
+		return parseSubtitleCodec(codecs);
+	} catch (e) {
+		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 lib/dash/dash-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 (e) {
+		continue;
+	}
+	throw new Error(`No MIME types matched any supported Audio Codecs in ${codecs}`);
+};
+const tryParseAudioCodec = (codecs) => {
+	try {
+		return parseAudioCodec(codecs);
+	} catch (e) {
+		return;
+	}
+};
+const getDolbyDigitalPlusComplexityIndex = (supplementalProps = []) => {
+	const targetScheme = "tag:dolby.com,2018:dash:EC3_ExtensionComplexityIndex:2018";
+	for (const prop of supplementalProps) if (prop.schemeIdUri === targetScheme) 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 lib/shared/pipe.ts
+const pipe = (...fns) => (value) => fns.reduce((acc, fn) => fn(acc), value);
+
 //#endregion
 //#region lib/dash/dash-extractor.ts
+const createMediaStreamInfo = (params) => {
+	const codecs = params.contentType === "text" && !params.mimeType?.includes("mp4") ? params.mimeType?.split("/")[1] : params.codecs;
+	if (!params.codecs && codecs) params.codecs = codecs;
+	if (params.codecs) {
+		const videoCodec = tryParseVideoCodec(params.codecs);
+		if (videoCodec) return new VideoStreamInfo({ codec: videoCodec });
+		const audioCodec = tryParseAudioCodec(params.codecs);
+		if (audioCodec) return new AudioStreamInfo({ codec: audioCodec });
+		const subtitleCodec = tryParseSubtitleCodec(params.codecs);
+		if (subtitleCodec) return new SubtitleStreamInfo({ codec: subtitleCodec });
+	} else {
+		const type = params.contentType || params.mimeType?.split("/")[0];
+		if (type === "video") return new VideoStreamInfo();
+		if (type === "audio") return new AudioStreamInfo();
+		if (type === "text") return new SubtitleStreamInfo();
+	}
+	throw new Error("Unable to determine the type of a track, cannot continue...");
+};
+const selectNonEmpty = (args) => {
+	for (const element of args.elements) {
+		const results = element.getElementsByTagName(args.tag);
+		if (results.length) return results;
+	}
+};
+const toSchemeValueArray = (elements) => {
+	const results = [];
+	if (!elements) return results;
+	for (const element of elements) {
+		const schemeIdUri = element.getAttribute("schemeIdUri");
+		const value = element.getAttribute("value");
+		results.push({
+			schemeIdUri,
+			value
+		});
+	}
+	return results;
+};
+const getTagAttrs = (tag, ...elements) => {
+	return pipe(selectNonEmpty, toSchemeValueArray)({
+		tag,
+		elements
+	});
+};
 var DashExtractor = class DashExtractor {
 	static #DEFAULT_METHOD = ENCRYPT_METHODS.CENC;
 	get extractorType() {
@@ -513,11 +867,10 @@ var DashExtractor = class DashExtractor {
 		return Number(d.toFixed(3));
 	}
 	async extractStreams(rawText) {
-		const streamList = [];
+		const streamInfos = [];
 		this.#mpdContent = rawText;
 		const mpdElement = new __xmldom_xmldom.DOMParser().parseFromString(this.#mpdContent, "text/xml").getElementsByTagName("MPD")[0];
 		const isLive = mpdElement.getAttribute("type") === "dynamic";
-		mpdElement.getAttribute("maxSegmentDuration");
 		const availabilityStartTime = mpdElement.getAttribute("availabilityStartTime");
 		const timeShiftBufferDepth = mpdElement.getAttribute("timeShiftBufferDepth") || "PT1M";
 		const publishTime = mpdElement.getAttribute("publishTime");
@@ -539,55 +892,70 @@ var DashExtractor = class DashExtractor {
 			for (const adaptationSet of adaptationSets) {
 				segBaseUrl = this.#extendBaseUrl(adaptationSet, segBaseUrl);
 				const representationsBaseUrl = segBaseUrl;
-				let mimeType = adaptationSet.getAttribute("contentType") || adaptationSet.getAttribute("mimeType");
+				let contentType = adaptationSet.getAttribute("contentType");
+				let mimeType = adaptationSet.getAttribute("mimeType");
 				const frameRate = this.#getFrameRate(adaptationSet);
 				const representations = adaptationSet.getElementsByTagName("Representation");
 				for (const representation of representations) {
 					segBaseUrl = this.#extendBaseUrl(representation, segBaseUrl);
-					if (!mimeType) mimeType = representation.getAttribute("contentType") || representation.getAttribute("mimeType") || "";
-					const bandwidth = representation.getAttribute("bandwidth");
-					const streamSpec = new StreamSpec();
-					streamSpec.originalUrl = this.#parserConfig.originalUrl;
-					streamSpec.periodId = periodId;
-					streamSpec.playlist = new Playlist();
-					streamSpec.playlist.mediaParts.push(new MediaPart());
-					streamSpec.groupId = representation.getAttribute("id");
-					streamSpec.bandwidth = Number(bandwidth || 0);
-					streamSpec.codecs = representation.getAttribute("codecs") || adaptationSet.getAttribute("codecs");
-					streamSpec.language = this.#filterLanguage(representation.getAttribute("lang") || adaptationSet.getAttribute("lang"));
-					streamSpec.frameRate = frameRate || this.#getFrameRate(representation);
-					const width = representation.getAttribute("width");
-					const height = representation.getAttribute("height");
-					streamSpec.resolution = width && height ? `${width}x${height}` : void 0;
-					streamSpec.url = this.#mpdUrl;
-					const mimeTypePart = mimeType.split("/")[0];
-					if (mimeTypePart === "text") streamSpec.mediaType = MEDIA_TYPES.SUBTITLES;
-					else if (mimeTypePart === "audio") streamSpec.mediaType = MEDIA_TYPES.AUDIO;
-					else if (mimeTypePart === "video" || !!streamSpec.resolution) streamSpec.mediaType = MEDIA_TYPES.VIDEO;
+					if (!contentType) contentType = representation.getAttribute("contentType");
+					if (!mimeType) mimeType = representation.getAttribute("mimeType");
+					const codecs = representation.getAttribute("codecs") || adaptationSet.getAttribute("codecs");
+					const widthParameterString = representation.getAttribute("width");
+					const heightParameterString = representation.getAttribute("height");
+					const roles = getTagAttrs("Role", representation, adaptationSet);
+					const supplementalProps = getTagAttrs("SupplementalProperty", representation, adaptationSet);
+					const essentialProps = getTagAttrs("EssentialProperty", representation, adaptationSet);
+					const accessibilities = getTagAttrs("Accessibility", representation, adaptationSet);
+					const channelsString = getTagAttrs("AudioChannelConfiguration", adaptationSet, representation)[0]?.value;
+					const streamInfo = createMediaStreamInfo({
+						codecs,
+						contentType,
+						mimeType
+					});
+					const bitrate = Number(representation.getAttribute("bandwidth") ?? "");
+					streamInfo.languageCode = this.#filterLanguage(representation.getAttribute("lang") || adaptationSet.getAttribute("lang"));
+					if (streamInfo.type === "video") {
+						streamInfo.bitrate = bitrate;
+						streamInfo.width = Number(widthParameterString);
+						streamInfo.height = Number(heightParameterString);
+						streamInfo.frameRate = frameRate || this.#getFrameRate(representation);
+						if (supplementalProps && essentialProps) streamInfo.dynamicRange = parseDynamicRange(codecs, supplementalProps, essentialProps);
+					} else if (streamInfo.type === "audio") {
+						streamInfo.bitrate = bitrate;
+						if (accessibilities) streamInfo.descriptive = checkIsDescriptive(accessibilities);
+						if (supplementalProps) streamInfo.joc = getDolbyDigitalPlusComplexityIndex(supplementalProps);
+						if (channelsString) {
+							streamInfo.numberOfChannels = parseChannels(channelsString);
+							streamInfo.channels = channelsString;
+						}
+					} else if (streamInfo.type === "subtitle") {
+						if (roles) streamInfo.cc = checkIsClosedCaption(roles);
+						if (accessibilities) streamInfo.sdh = checkIsSdh(accessibilities);
+					}
+					streamInfo.url = this.#mpdUrl;
+					streamInfo.originalUrl = this.#parserConfig.originalUrl;
+					streamInfo.playlist = new Playlist();
+					streamInfo.playlist.mediaParts.push(new MediaPart());
+					streamInfo.periodId = periodId;
+					streamInfo.groupId = representation.getAttribute("id");
+					streamInfo.codecs = codecs;
 					const volumeAdjust = representation.getAttribute("volumeAdjust");
-					if (volumeAdjust) streamSpec.groupId = streamSpec.groupId + "-" + volumeAdjust;
+					if (volumeAdjust) streamInfo.groupId = streamInfo.groupId + "-" + volumeAdjust;
 					const mType = representation.getAttribute("mimeType") || adaptationSet.getAttribute("mimeType");
 					if (mType) {
 						const mTypeSplit = mType.split("/");
-						streamSpec.extension = mTypeSplit.length === 2 ? mTypeSplit[1] : null;
+						streamInfo.extension = mTypeSplit.length === 2 ? mTypeSplit[1] : null;
 					}
-					if (streamSpec.codecs === "stpp" || streamSpec.codecs === "wvtt") streamSpec.mediaType = MEDIA_TYPES.SUBTITLES;
-					const role = representation.getElementsByTagName("Role")[0] || adaptationSet.getElementsByTagName("Role")[0];
+					const role = roles?.[0];
 					if (role) {
-						const roleValue = role.getAttribute("value");
+						const roleValue = role.value;
 						const capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
-						const roleType = ROLE_TYPE[roleValue.split("-").map(capitalize).join("")];
-						streamSpec.role = roleType;
-						if (roleType === ROLE_TYPE.Subtitle) {
-							streamSpec.mediaType = MEDIA_TYPES.SUBTITLES;
-							if (mType?.includes("ttml")) streamSpec.extension = "ttml";
-						} else if (roleType === ROLE_TYPE.ForcedSubtitle) streamSpec.mediaType = MEDIA_TYPES.SUBTITLES;
+						streamInfo.role = ROLE_TYPE[roleValue.split("-").map(capitalize).join("")];
 					}
-					streamSpec.playlist.isLive = isLive;
-					if (timeShiftBufferDepth) streamSpec.playlist.refreshIntervalMs = temporal_polyfill.Temporal.Duration.from(timeShiftBufferDepth).total("milliseconds") / 2;
-					const audioChannelConfiguration = adaptationSet.getElementsByTagName("AudioChannelConfiguration")[0] || representation.getElementsByTagName("AudioChannelConfiguration")[0];
-					if (audioChannelConfiguration) streamSpec.channels = audioChannelConfiguration.getAttribute("value");
-					if (publishTime) streamSpec.publishTime = new Date(publishTime);
+					streamInfo.playlist.isLive = isLive;
+					if (timeShiftBufferDepth) streamInfo.playlist.refreshIntervalMs = temporal_polyfill.Temporal.Duration.from(timeShiftBufferDepth).total("milliseconds") / 2;
+					if (publishTime) streamInfo.publishTime = new Date(publishTime);
 					const segmentBaseElement = representation.getElementsByTagName("SegmentBase")[0];
 					if (segmentBaseElement) {
 						const initialization = segmentBaseElement.getElementsByTagName("Initialization")[0];
@@ -598,7 +966,7 @@ var DashExtractor = class DashExtractor {
 								mediaSegment.index = 0;
 								mediaSegment.url = segBaseUrl;
 								mediaSegment.duration = periodDurationSeconds;
-								streamSpec.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
+								streamInfo.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
 							} else {
 								const initUrl = combineUrl(segBaseUrl, sourceUrl);
 								const initRange = initialization.getAttribute("range");
@@ -610,7 +978,7 @@ var DashExtractor = class DashExtractor {
 									initSegment.startRange = start;
 									initSegment.expectLength = expect;
 								}
-								streamSpec.playlist.mediaInit = initSegment;
+								streamInfo.playlist.mediaInit = initSegment;
 							}
 						}
 					}
@@ -630,7 +998,7 @@ var DashExtractor = class DashExtractor {
 								initSegment.startRange = start;
 								initSegment.expectLength = expect;
 							}
-							streamSpec.playlist.mediaInit = initSegment;
+							streamInfo.playlist.mediaInit = initSegment;
 						}
 						const segmentUrls = segmentList.getElementsByTagName("SegmentURL");
 						const timescaleStr = segmentList.getAttribute("timescale") || "1";
@@ -649,7 +1017,7 @@ var DashExtractor = class DashExtractor {
 								segment.startRange = start;
 								segment.expectLength = expect;
 							}
-							streamSpec.playlist.mediaParts[0].mediaSegments.push(segment);
+							streamInfo.playlist.mediaParts[0].mediaSegments.push(segment);
 						}
 					}
 					const segmentTemplateElementsOuter = adaptationSet.getElementsByTagName("SegmentTemplate");
@@ -658,8 +1026,8 @@ var DashExtractor = class DashExtractor {
 						const segmentTemplate = segmentTemplateElements[0] || segmentTemplateElementsOuter[0];
 						const segmentTemplateOuter = segmentTemplateElementsOuter[0] || segmentTemplateElements[0];
 						const varDic = {};
-						varDic[DASH_TAGS.TemplateRepresentationID] = streamSpec.groupId;
-						varDic[DASH_TAGS.TemplateBandwidth] = bandwidth;
+						varDic[DASH_TAGS.TemplateRepresentationID] = streamInfo.groupId;
+						varDic[DASH_TAGS.TemplateBandwidth] = bitrate;
 						const presentationTimeOffsetStr = segmentTemplate.getAttribute("presentationTimeOffset") || segmentTemplateOuter.getAttribute("presentationTimeOffset") || "0";
 						const timescaleStr = segmentTemplate.getAttribute("timescale") || segmentTemplateOuter.getAttribute("timescale") || "1";
 						const durationStr = segmentTemplate.getAttribute("duration") || segmentTemplateOuter.getAttribute("duration");
@@ -671,7 +1039,7 @@ var DashExtractor = class DashExtractor {
 							const mediaSegment = new MediaSegment();
 							mediaSegment.index = -1;
 							mediaSegment.url = initUrl;
-							streamSpec.playlist.mediaInit = mediaSegment;
+							streamInfo.playlist.mediaInit = mediaSegment;
 						}
 						const mediaTemplate = segmentTemplate.getAttribute("media") || segmentTemplateOuter.getAttribute("media");
 						const segmentTimeline = segmentTemplate.getElementsByTagName("SegmentTimeline")[0];
@@ -698,7 +1066,7 @@ var DashExtractor = class DashExtractor {
 								if (hasTime) mediaSegment.nameFromVar = currentTime.toString();
 								mediaSegment.duration = _duration / timescale;
 								mediaSegment.index = segIndex++;
-								streamSpec.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
+								streamInfo.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
 								if (_repeatCount < 0) _repeatCount = Math.ceil(periodDurationSeconds * timescale / _duration) - 1;
 								for (let i = 0; i < _repeatCount; i++) {
 									currentTime += _duration;
@@ -711,7 +1079,7 @@ var DashExtractor = class DashExtractor {
 									_mediaSegment.index = segIndex++;
 									_mediaSegment.duration = _duration / timescale;
 									if (_hashTime) _mediaSegment.nameFromVar = currentTime.toString();
-									streamSpec.playlist.mediaParts[0].mediaSegments.push(_mediaSegment);
+									streamInfo.playlist.mediaParts[0].mediaSegments.push(_mediaSegment);
 								}
 								currentTime += _duration;
 							}
@@ -740,16 +1108,16 @@ var DashExtractor = class DashExtractor {
 								if (hasNumber) mediaSegment.nameFromVar = index.toString();
 								mediaSegment.index = isLive ? index : segIndex;
 								mediaSegment.duration = duration / timescale;
-								streamSpec.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
+								streamInfo.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
 							}
 						}
 					}
-					if (streamSpec.playlist.mediaParts[0].mediaSegments.length === 0) {
+					if (streamInfo.playlist.mediaParts[0].mediaSegments.length === 0) {
 						const mediaSegment = new MediaSegment();
 						mediaSegment.index = 0;
 						mediaSegment.url = segBaseUrl;
 						mediaSegment.duration = periodDurationSeconds;
-						streamSpec.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
+						streamInfo.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
 					}
 					const adaptationSetProtections = adaptationSet.getElementsByTagName("ContentProtection");
 					const representationProtections = representation.getElementsByTagName("ContentProtection");
@@ -769,69 +1137,69 @@ var DashExtractor = class DashExtractor {
 							else if (schemeIdUri?.includes(playreadySystemId)) encryptInfo.drm.playready = drmData;
 							else continue;
 						}
-						if (streamSpec.playlist.mediaInit) streamSpec.playlist.mediaInit.encryptInfo = encryptInfo;
-						const segments = streamSpec.playlist.mediaParts[0].mediaSegments;
+						if (streamInfo.playlist.mediaInit) streamInfo.playlist.mediaInit.encryptInfo = encryptInfo;
+						const segments = streamInfo.playlist.mediaParts[0].mediaSegments;
 						for (const segment of segments) if (!segment.encryptInfo) segment.encryptInfo = encryptInfo;
 					}
-					const _index = streamList.findIndex((item) => item.periodId !== streamSpec.periodId && item.groupId === streamSpec.groupId && item.resolution === streamSpec.resolution && item.mediaType === streamSpec.mediaType);
-					if (_index > -1) if (isLive) {} else if (streamList[_index].playlist.mediaParts.at(-1).mediaSegments.at(-1).url !== streamSpec.playlist.mediaParts[0].mediaSegments.at(-1)?.url) {
-						const startIndex = streamList[_index].playlist.mediaParts.at(-1).mediaSegments.at(-1).index + 1;
-						const segments = streamSpec.playlist.mediaParts[0].mediaSegments;
+					const _index = streamInfos.findIndex((item) => item.type === streamInfo.type && item.periodId !== streamInfo.periodId && item.groupId === streamInfo.groupId && (item.type === "video" && streamInfo.type === "video" ? item.width === streamInfo.width && item.height === streamInfo.height : true));
+					if (_index > -1) if (isLive) {} else if (streamInfos[_index].playlist.mediaParts.at(-1).mediaSegments.at(-1).url !== streamInfo.playlist.mediaParts[0].mediaSegments.at(-1)?.url) {
+						const startIndex = streamInfos[_index].playlist.mediaParts.at(-1).mediaSegments.at(-1).index + 1;
+						const segments = streamInfo.playlist.mediaParts[0].mediaSegments;
 						for (const segment of segments) segment.index += startIndex;
 						const mediaPart = new MediaPart();
-						mediaPart.mediaSegments = streamList[_index].playlist.mediaParts[0].mediaSegments;
-						streamList[_index].playlist.mediaParts.push(mediaPart);
-					} else streamList[_index].playlist.mediaParts.at(-1).mediaSegments.at(-1).duration += streamSpec.playlist.mediaParts[0].mediaSegments.reduce((sum, segment) => sum + segment.duration, 0);
+						mediaPart.mediaSegments = streamInfos[_index].playlist.mediaParts[0].mediaSegments;
+						streamInfos[_index].playlist.mediaParts.push(mediaPart);
+					} else streamInfos[_index].playlist.mediaParts.at(-1).mediaSegments.at(-1).duration += streamInfo.playlist.mediaParts[0].mediaSegments.reduce((sum, segment) => sum + segment.duration, 0);
 					else {
-						if (streamSpec.mediaType === MEDIA_TYPES.SUBTITLES && streamSpec.extension === "mp4") streamSpec.extension = "m4s";
-						if (streamSpec.mediaType !== MEDIA_TYPES.SUBTITLES && (streamSpec.extension == null || streamSpec.playlist.mediaParts.reduce((sum, part) => sum + part.mediaSegments.length, 0) > 1)) streamSpec.extension = "m4s";
-						streamList.push(streamSpec);
+						if (streamInfo.type === "subtitle" && streamInfo.extension === "mp4") streamInfo.extension = "m4s";
+						if (streamInfo.type !== "subtitle" && (streamInfo.extension == null || streamInfo.playlist.mediaParts.reduce((sum, part) => sum + part.mediaSegments.length, 0) > 1)) streamInfo.extension = "m4s";
+						streamInfos.push(streamInfo);
 					}
 					segBaseUrl = representationsBaseUrl;
 				}
 				segBaseUrl = adaptationSetsBaseUrl;
 			}
 		}
-		const audioList = streamList.filter((stream) => stream.mediaType === MEDIA_TYPES.AUDIO);
-		const subtitleList = streamList.filter((stream) => stream.mediaType === MEDIA_TYPES.SUBTITLES);
-		const videoList = streamList.filter((stream) => stream.mediaType === MEDIA_TYPES.VIDEO);
+		const audioList = streamInfos.filter((stream) => stream.type === "audio");
+		const subtitleList = streamInfos.filter((stream) => stream.type === "subtitle");
+		const videoList = streamInfos.filter((stream) => stream.type === "video");
 		for (const video of videoList) {
-			const audioGroupId = audioList.toSorted((a, b$1) => (b$1.bandwidth || 0) - (a.bandwidth || 0)).at(0)?.groupId;
-			const subtitleGroupId = subtitleList.toSorted((a, b$1) => (b$1.bandwidth || 0) - (a.bandwidth || 0)).at(0)?.groupId;
+			const audioGroupId = audioList.toSorted((a, b$1) => (b$1.bitrate || 0) - (a.bitrate || 0)).at(0)?.groupId;
+			const subtitleGroupId = subtitleList.toSorted((a, b$1) => (b$1.bitrate || 0) - (a.bitrate || 0)).at(0)?.groupId;
 			if (audioGroupId) video.audioId = audioGroupId;
 			if (subtitleGroupId) video.subtitleId = subtitleGroupId;
 		}
-		return streamList;
+		return streamInfos;
 	}
 	#filterLanguage(v) {
 		if (!v) return;
 		return v;
 	}
-	async refreshPlayList(streamSpecs) {
-		if (!streamSpecs.length) return;
+	async refreshPlayList(streamInfos) {
+		if (!streamInfos.length) return;
 		const response = await fetch(this.#parserConfig.url, this.#parserConfig.headers).catch(() => fetch(this.#parserConfig.originalUrl, this.#parserConfig.headers));
 		const rawText = await response.text();
 		const url = response.url;
 		this.#parserConfig.url = url;
 		this.#setInitUrl();
 		const newStreams = await this.extractStreams(rawText);
-		for (const streamSpec of streamSpecs) {
-			let results = newStreams.filter((n) => n.toShortString() === streamSpec.toShortString());
-			if (!results.length) results = newStreams.filter((n) => n.playlist?.mediaInit?.url === streamSpec.playlist?.mediaInit?.url);
-			if (results.length) streamSpec.playlist.mediaParts = results.at(0).playlist.mediaParts;
+		for (const streamInfo of streamInfos) {
+			let results = newStreams.filter((n) => n.toShortString() === streamInfo.toShortString());
+			if (!results.length) results = newStreams.filter((n) => n.playlist?.mediaInit?.url === streamInfo.playlist?.mediaInit?.url);
+			if (results.length) streamInfo.playlist.mediaParts = results.at(0).playlist.mediaParts;
 		}
-		await this.#processUrl(streamSpecs);
+		await this.#processUrl(streamInfos);
 	}
-	async #processUrl(streamSpecs) {
-		for (const spec of streamSpecs) {
+	async #processUrl(streamInfos) {
+		for (const spec of streamInfos) {
 			const playlist = spec.playlist;
 			if (!playlist) continue;
 			if (playlist.mediaInit) playlist.mediaInit.url = this.preProcessUrl(playlist.mediaInit.url);
 			for (const part of playlist.mediaParts) for (const segment of part.mediaSegments) segment.url = this.preProcessUrl(segment.url);
 		}
 	}
-	async fetchPlayList(streamSpecs) {
-		this.#processUrl(streamSpecs);
+	async fetchPlayList(streamInfos) {
+		this.#processUrl(streamInfos);
 	}
 	preProcessUrl(url) {
 		for (const processor of this.#parserConfig.urlProcessors) if (processor.canProcess(this.extractorType, url, this.#parserConfig)) url = processor.process(url, this.#parserConfig);
@@ -890,62 +1258,75 @@ var HlsExtractor = class {
 	}
 	async #parseMasterList() {
 		this.#masterM3u8Flag = true;
-		const streams = [];
+		const streamInfos = [];
 		let expectPlaylist = false;
-		let streamSpec = new StreamSpec();
+		let streamInfo = new VideoStreamInfo();
 		const lines = this.#m3u8Content.split("\n");
 		for (const line of lines) {
 			if (!line.trim()) continue;
 			if (line.startsWith(HLS_TAGS.extXStreamInf)) {
-				streamSpec = new StreamSpec();
-				streamSpec.originalUrl = this.parserConfig.originalUrl;
+				streamInfo = new VideoStreamInfo();
+				streamInfo.originalUrl = this.parserConfig.originalUrl;
 				const bandwidth = getAttribute(line, "AVERAGE-BANDWIDTH") || getAttribute(line, "BANDWIDTH");
-				streamSpec.bandwidth = Number(bandwidth || 0);
-				streamSpec.codecs = getAttribute(line, "CODECS");
-				streamSpec.resolution = getAttribute(line, "RESOLUTION");
+				streamInfo.bitrate = Number(bandwidth || 0);
+				streamInfo.codecs = getAttribute(line, "CODECS");
+				const resolution = getAttribute(line, "RESOLUTION");
+				const [widthString, heightString] = resolution.split("x");
+				streamInfo.width = parseInt(widthString);
+				streamInfo.height = parseInt(heightString);
+				streamInfo.resolution = resolution;
 				const frameRate = getAttribute(line, "FRAME-RATE");
-				if (frameRate) streamSpec.frameRate = Number(frameRate);
+				if (frameRate) streamInfo.frameRate = Number(frameRate);
 				const audioId = getAttribute(line, "AUDIO");
-				if (audioId) streamSpec.audioId = audioId;
+				if (audioId) streamInfo.audioId = audioId;
 				const videoId = getAttribute(line, "VIDEO");
-				if (videoId) streamSpec.videoId = videoId;
+				if (videoId) streamInfo.videoId = videoId;
 				const subtitleId = getAttribute(line, "SUBTITLES");
-				if (subtitleId) streamSpec.subtitleId = subtitleId;
+				if (subtitleId) streamInfo.subtitleId = subtitleId;
 				const videoRange = getAttribute(line, "VIDEO-RANGE");
-				if (videoRange) streamSpec.videoRange = videoRange;
-				if (streamSpec.codecs && streamSpec.audioId) streamSpec.codecs = streamSpec.codecs.split(",")[0];
+				if (videoRange) streamInfo.videoRange = videoRange;
+				if (streamInfo.codecs && streamInfo.audioId) streamInfo.codecs = streamInfo.codecs.split(",")[0];
 				expectPlaylist = true;
 			} else if (line.startsWith(HLS_TAGS.extXMedia)) {
-				streamSpec = new StreamSpec();
-				const mediaType = MEDIA_TYPES[getAttribute(line, "TYPE").replace("-", "_")];
-				if (mediaType) streamSpec.mediaType = mediaType;
-				if (mediaType === MEDIA_TYPES.CLOSED_CAPTIONS) continue;
+				streamInfo = new VideoStreamInfo();
+				const type = getAttribute(line, "TYPE");
+				if (type === "VIDEO") streamInfo = new VideoStreamInfo();
+				if (type === "AUDIO") streamInfo = new AudioStreamInfo();
+				if (type === "SUBTITLES") streamInfo = new SubtitleStreamInfo();
+				if (type === "CLOSED-CAPTIONS") {
+					streamInfo = new SubtitleStreamInfo();
+					streamInfo.cc = true;
+					continue;
+				}
 				let url = getAttribute(line, "URI");
 				if (!url) continue;
 				url = combineUrl(this.#baseUrl, url);
-				streamSpec.url = this.preProcessUrl(url);
+				streamInfo.url = this.preProcessUrl(url);
 				const groupId = getAttribute(line, "GROUP-ID");
-				if (groupId) streamSpec.groupId = groupId;
+				if (groupId) streamInfo.groupId = groupId;
 				const language = getAttribute(line, "LANGUAGE");
-				if (language) streamSpec.language = language;
+				if (language) streamInfo.languageCode = language;
 				const name = getAttribute(line, "NAME");
-				if (name) streamSpec.name = name;
+				if (name) streamInfo.name = name;
 				const defaultFlag = getAttribute(line, "DEFAULT");
-				if (defaultFlag) streamSpec.default = defaultFlag.toLowerCase() === "yes";
-				const channels = getAttribute(line, "CHANNELS");
-				if (channels) streamSpec.channels = channels;
+				if (defaultFlag) streamInfo.default = defaultFlag.toLowerCase() === "yes";
+				const channelsString = getAttribute(line, "CHANNELS");
+				if (channelsString) {
+					streamInfo.channels = channelsString;
+					if (streamInfo.type === "audio") streamInfo.numberOfChannels = parseFloat(channelsString);
+				}
 				const characteristics = getAttribute(line, "CHARACTERISTICS");
-				if (characteristics) streamSpec.characteristics = characteristics.split(",").at(-1)?.split(".").at(-1);
-				streams.push(streamSpec);
+				if (characteristics) streamInfo.characteristics = characteristics.split(",").at(-1)?.split(".").at(-1);
+				streamInfos.push(streamInfo);
 			} else if (line.startsWith("#")) continue;
 			else if (expectPlaylist) {
 				const url = combineUrl(this.#baseUrl, line);
-				streamSpec.url = this.preProcessUrl(url);
+				streamInfo.url = this.preProcessUrl(url);
 				expectPlaylist = false;
-				streams.push(streamSpec);
+				streamInfos.push(streamInfo);
 			}
 		}
-		return streams;
+		return streamInfos;
 	}
 	async #parseList() {
 		let hasAd = false;
@@ -1069,7 +1450,7 @@ var HlsExtractor = class {
 		this.preProcessContent();
 		if (this.#m3u8Content.includes(HLS_TAGS.extXStreamInf)) return this.#parseMasterList().then((lists) => distinctBy(lists, (list) => list.url));
 		const playlist = await this.#parseList();
-		const streamSpec = new StreamSpec();
+		const streamSpec = new VideoStreamInfo();
 		streamSpec.url = this.parserConfig.url;
 		streamSpec.playlist = playlist;
 		streamSpec.extension = playlist.mediaInit ? "mp4" : "ts";
@@ -1115,7 +1496,7 @@ var HlsExtractor = class {
 			const newPlaylist = await this.#parseList();
 			if (list.playlist?.mediaInit) list.playlist.mediaParts = newPlaylist.mediaParts;
 			else list.playlist = newPlaylist;
-			if (list.mediaType === MEDIA_TYPES.SUBTITLES) {
+			if (list.type === "subtitle") {
 				const a = list.playlist.mediaParts.some((part) => part.mediaSegments.some((segment) => segment.url.includes(".ttml")));
 				const b$1 = list.playlist.mediaParts.some((part) => part.mediaSegments.some((segment) => segment.url.includes(".vtt") || segment.url.includes(".webvtt")));
 				if (a) list.extension = "ttml";
@@ -1123,8 +1504,8 @@ var HlsExtractor = class {
 			} else list.extension = list.playlist.mediaInit ? "m4s" : "ts";
 		}
 	}
-	async refreshPlayList(streamSpecs) {
-		await this.fetchPlayList(streamSpecs);
+	async refreshPlayList(streamInfos) {
+		await this.fetchPlayList(streamInfos);
 	}
 };
 
@@ -1184,15 +1565,18 @@ var StreamExtractor = class {
 	async extractStreams() {
 		return this.#extractor.extractStreams(this.#rawText);
 	}
-	async fetchPlayList(streamSpecs) {
-		return this.#extractor.fetchPlayList(streamSpecs);
+	async fetchPlayList(streamInfos) {
+		return this.#extractor.fetchPlayList(streamInfos);
 	}
-	async refreshPlayList(streamSpecs) {
-		return this.#extractor.refreshPlayList(streamSpecs);
+	async refreshPlayList(streamInfos) {
+		return this.#extractor.refreshPlayList(streamInfos);
 	}
 };
 
 //#endregion
+exports.ALL_STREAM_TYPES = ALL_STREAM_TYPES;
+exports.AUDIO_CODECS = AUDIO_CODECS;
+exports.AudioStreamInfo = AudioStreamInfo;
 exports.DASH_TAGS = DASH_TAGS;
 exports.DashExtractor = DashExtractor;
 exports.DefaultDashContentProcessor = DefaultDashContentProcessor;
@@ -1204,12 +1588,17 @@ exports.EXTRACTOR_TYPES = EXTRACTOR_TYPES;
 exports.EncryptInfo = EncryptInfo;
 exports.HLS_TAGS = HLS_TAGS;
 exports.HlsExtractor = HlsExtractor;
-exports.MEDIA_TYPES = MEDIA_TYPES;
 exports.MediaPart = MediaPart;
 exports.MediaSegment = MediaSegment;
 exports.ParserConfig = ParserConfig;
+exports.Playlist = Playlist;
 exports.ROLE_TYPE = ROLE_TYPE;
+exports.SUBTITLE_CODECS = SUBTITLE_CODECS;
 exports.StreamExtractor = StreamExtractor;
-exports.StreamSpec = StreamSpec;
+exports.StreamInfo = StreamInfo;
+exports.SubtitleStreamInfo = SubtitleStreamInfo;
+exports.VIDEO_CODECS = VIDEO_CODECS;
+exports.VIDEO_DYNAMIC_RANGES = VIDEO_DYNAMIC_RANGES;
+exports.VideoStreamInfo = VideoStreamInfo;
 exports.getRange = getRange;
 exports.parseRange = parseRange;