dasha 4.0.0-alpha.9 → 4.0.1

package/dist/dasha.mjs

@@ -1,1576 +0,0 @@
-import crypto from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
-import { b } from "barsic";
-import { readFile } from "node:fs/promises";
-import { pathToFileURL } from "node:url";
-import path from "node:path";
-import { Temporal } from "temporal-polyfill";
-import { DOMParser } from "@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",
-	AES_128: "aes-128",
-	AES_128_ECB: "aes-128-ecb",
-	SAMPLE_AES: "sample-aes",
-	SAMPLE_AES_CTR: "sample-aes-ctr",
-	CENC: "cenc",
-	CHACHA20: "chacha20",
-	UNKNOWN: "unknown"
-};
-
-//#endregion
-//#region lib/shared/encrypt-info.ts
-var EncryptInfo = class {
-	method = ENCRYPT_METHODS.NONE;
-	key;
-	iv;
-	drm;
-	constructor(method) {
-		this.method = this.parseMethod(method);
-		this.drm = {};
-	}
-	parseMethod(method) {
-		if (method) return ENCRYPT_METHODS[method.replace("-", "_")];
-		else return ENCRYPT_METHODS.UNKNOWN;
-	}
-};
-
-//#endregion
-//#region lib/shared/extractor-type.ts
-const EXTRACTOR_TYPES = {
-	MPEG_DASH: "MPEG_DASH",
-	HLS: "HLS",
-	HTTP_LIVE: "HTTP_LIVE",
-	MSS: "MSS"
-};
-
-//#endregion
-//#region lib/shared/media-part.ts
-var MediaPart = class {
-	mediaSegments = [];
-	constructor(segments) {
-		this.mediaSegments = segments || [];
-	}
-};
-
-//#endregion
-//#region lib/shared/media-segment.ts
-var MediaSegment = class MediaSegment {
-	index = NaN;
-	duration = NaN;
-	title;
-	dateTime;
-	startRange;
-	get stopRange() {
-		return this.startRange !== void 0 && this.expectLength !== void 0 ? this.startRange + this.expectLength - 1 : void 0;
-	}
-	expectLength;
-	encryptInfo = new EncryptInfo();
-	get isEncrypted() {
-		return this.encryptInfo.method !== ENCRYPT_METHODS.NONE;
-	}
-	url = "";
-	nameFromVar;
-	equals(segment) {
-		if (segment instanceof MediaSegment) return this.index == segment.index && Math.abs(this.duration - segment.duration) < .001 && this.title == segment.title && this.startRange == segment.startRange && this.stopRange == segment.stopRange && this.expectLength == segment.expectLength && this.url == segment.url;
-		else return false;
-	}
-	getHashCode() {
-		const payload = [
-			this.index,
-			this.duration,
-			this.title,
-			this.startRange,
-			this.stopRange,
-			this.expectLength,
-			this.url
-		].join("-");
-		return crypto.createHash("md5").update(payload).digest("hex");
-	}
-};
-
-//#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 = [];
-};
-
-//#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-info.ts
-/**
-* List of all stream types.
-* @group Miscellaneous
-* @public
-*/
-const ALL_STREAM_TYPES = [
-	"video",
-	"audio",
-	"subtitle"
-];
-const bitrateToString = (bitrate) => {
-	return bitrate ? `${Math.round(bitrate / 1e3)} Kbps` : "";
-};
-const roleToString = (role) => {
-	for (const [key, value] of Object.entries(ROLE_TYPE)) if (value === role) return key;
-	return "";
-};
-const durationToString = (seconds) => {
-	if (!Number.isFinite(seconds) || seconds < 0) return "";
-	const mins = Math.floor(seconds / 60);
-	const secs = Math.round(seconds % 60);
-	if (mins > 0) return `~${mins}m${secs.toString().padStart(2, "0")}s`;
-	return `~${secs}s`;
-};
-var StreamInfo = class {
-	codec;
-	languageCode;
-	bitrate;
-	name;
-	url = "";
-	originalUrl = "";
-	playlist;
-	default;
-	skippedDuration;
-	role;
-	videoRange;
-	characteristics;
-	publishTime;
-	groupId = null;
-	audioId;
-	videoId;
-	subtitleId;
-	periodId = null;
-	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() {
-		const parts = ["Vid"];
-		if (this.width) parts.push(`${this.width}x${this.height}`);
-		if (this.bitrate) parts.push(bitrateToString(this.bitrate));
-		if (this.groupId) parts.push(this.groupId);
-		if (this.frameRate) parts.push(this.frameRate.toString());
-		if (this.codec) parts.push(this.codec);
-		if (this.videoRange) parts.push(this.videoRange);
-		if (this.segmentsCount) parts.push(`${this.segmentsCount} segments`);
-		if (this.role) parts.push(roleToString(this.role));
-		if (this.playlist) parts.push(durationToString(this.playlist.totalDuration));
-		return parts.filter(Boolean).join(" | ").trim();
-	}
-};
-var AudioStreamInfo = class extends StreamInfo {
-	codec;
-	numberOfChannels;
-	sampleRate;
-	atmos;
-	descriptive;
-	joc;
-	get type() {
-		return "audio";
-	}
-	constructor(info) {
-		super();
-		this.codec = info?.codec;
-	}
-	toShortString() {
-		const parts = ["Aud"];
-		if (this.groupId) parts.push(this.groupId);
-		if (this.bitrate) parts.push(bitrateToString(this.bitrate));
-		if (this.name) parts.push(this.name);
-		if (this.codec) parts.push(this.codec);
-		if (this.languageCode) parts.push(this.languageCode);
-		if (this.numberOfChannels) parts.push(`${this.numberOfChannels}CH`);
-		if (this.role) parts.push(roleToString(this.role));
-		return parts.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() {
-		const parts = ["Sub"];
-		const text = parts.filter(Boolean).join(" | ");
-		if (this.groupId) parts.push(this.groupId);
-		if (this.languageCode) parts.push(this.languageCode);
-		if (this.name) parts.push(this.name);
-		if (this.codec) parts.push(this.codec);
-		if (this.role) parts.push(roleToString(this.role));
-		return text.trim();
-	}
-};
-
-//#endregion
-//#region lib/processor.ts
-var DefaultUrlProcessor = class {
-	canProcess(_extractorType, _originalUrl, parserConfig) {
-		return parserConfig.appendUrlParams;
-	}
-	process(url, parserConfig) {
-		if (!url.startsWith("http")) return url;
-		const urlFromConfigQuery = new URL(parserConfig.url).searchParams;
-		const oldUrl = new URL(url);
-		const newQuery = oldUrl.searchParams;
-		for (const [key, value] of urlFromConfigQuery) if (newQuery.has(key)) newQuery.set(key, value);
-		else newQuery.append(key, value);
-		if (!newQuery.toString()) return url;
-		console.debug(`Before: ${url}`);
-		url = `${oldUrl.pathname}?${newQuery.toString()}`;
-		console.debug(`After: ${url}`);
-		return url;
-	}
-};
-
-//#endregion
-//#region lib/dash/dash-content-processor.ts
-const namespaceMap = new Map([
-	["cenc", "urn:mpeg:cenc:2013"],
-	["mspr", "urn:microsoft:playready"],
-	["mas", "urn:marlin:mas:1-0:services:schemas:mpd"]
-]);
-const isMissingNs = (rawText, tag) => !rawText.includes(`xmlns:${tag}`) && rawText.includes(`<${tag}:`);
-function replaceFirst(source, oldValue, newValue) {
-	const index = source.indexOf(oldValue);
-	return index < 0 ? source : source.slice(0, index) + newValue + source.slice(index + oldValue.length);
-}
-var DefaultDashContentProcessor = class {
-	canProcess(extractorType, mpdContent) {
-		if (extractorType !== EXTRACTOR_TYPES.MPEG_DASH) return false;
-		return namespaceMap.keys().some((key) => isMissingNs(mpdContent, key));
-	}
-	process(mpdContent) {
-		console.debug("Namespace missing, trying to fix...");
-		const missingNamespaceKeys = Array.from(namespaceMap.keys().filter((key) => isMissingNs(mpdContent, key)));
-		if (!missingNamespaceKeys.length) return mpdContent;
-		return replaceFirst(mpdContent, "<MPD ", `<MPD ${missingNamespaceKeys.map((key) => `xmlns:${key}="${namespaceMap.get(key)}"`).join(" ")} `);
-	}
-};
-
-//#endregion
-//#region lib/hls/hls-tags.ts
-const HLS_TAGS = {
-	extM3u: "#EXTM3U",
-	extXTargetDuration: "#EXT-X-TARGETDURATION",
-	extXMediaSequence: "#EXT-X-MEDIA-SEQUENCE",
-	extXDiscontinuitySequence: "#EXT-X-DISCONTINUITY-SEQUENCE",
-	extXProgramDateTime: "#EXT-X-PROGRAM-DATE-TIME",
-	extXMedia: "#EXT-X-MEDIA",
-	extXPlaylistType: "#EXT-X-PLAYLIST-TYPE",
-	extXKey: "#EXT-X-KEY",
-	extXStreamInf: "#EXT-X-STREAM-INF",
-	extXVersion: "#EXT-X-VERSION",
-	extXAllowCache: "#EXT-X-ALLOW-CACHE",
-	extXEndlist: "#EXT-X-ENDLIST",
-	extInf: "#EXTINF",
-	extIframesOnly: "#EXT-X-I-FRAMES-ONLY",
-	extXByterange: "#EXT-X-BYTERANGE",
-	extXIframeStreamInf: "#EXT-X-I-FRAME-STREAM-INF",
-	extXDiscontinuity: "#EXT-X-DISCONTINUITY",
-	extXCueOutStart: "#EXT-X-CUE-OUT",
-	extXCueOut: "#EXT-X-CUE-OUT-CONT",
-	extIsIndependentSegments: "#EXT-X-INDEPENDENT-SEGMENTS",
-	extXScte35: "#EXT-OATCLS-SCTE35",
-	extXCueStart: "#EXT-X-CUE-OUT",
-	extXCueEnd: "#EXT-X-CUE-IN",
-	extXCueSpan: "#EXT-X-CUE-SPAN",
-	extXMap: "#EXT-X-MAP",
-	extXStart: "#EXT-X-START"
-};
-
-//#endregion
-//#region lib/hls/hls-content-processor.ts
-var DefaultHlsContentProcessor = class DefaultHlsContentProcessor {
-	static YkDVRegex = /#EXT-X-DISCONTINUITY\s+#EXT-X-MAP:URI="(.*?)",BYTERANGE="(.*?)"/g;
-	static DNSPRegex = /#EXT-X-MAP:URI=".*?BUMPER\/[\s\S]+?#EXT-X-DISCONTINUITY/;
-	static DNSPSubRegex = /#EXTINF:.*?,\s+.*BUMPER.*\s+#EXT-X-DISCONTINUITY/;
-	static OrderFixRegex = /(#EXTINF.*)(\s+)(#EXT-X-KEY.*)/g;
-	static ATVRegex = /#EXT-X-MAP.*\.apple\.com\//;
-	static ATVRegex2 = /(#EXT-X-KEY:[\s\S]*?)(#EXT-X-DISCONTINUITY|#EXT-X-ENDLIST)/;
-	canProcess(extractorType) {
-		return extractorType === EXTRACTOR_TYPES.HLS;
-	}
-	process(m3u8Content, parserConfig) {
-		if (m3u8Content.includes("\r") && !m3u8Content.includes("\n")) m3u8Content = m3u8Content.replace(/\r/g, "\n");
-		const m3u8Url = parserConfig.url;
-		if (m3u8Url.includes("tlivecloud-playback-cdn.ysp.cctv.cn") && m3u8Url.includes("endtime=")) m3u8Content += "\n" + HLS_TAGS.extXEndlist;
-		if (m3u8Content.includes("#EXT-X-DISCONTINUITY") && m3u8Content.includes("#EXT-X-MAP") && m3u8Content.includes("ott.cibntv.net") && m3u8Content.includes("ccode=")) m3u8Content = m3u8Content.replace(DefaultHlsContentProcessor.YkDVRegex, (_match, uri, byterange) => `#EXTINF:0.000000,\n#EXT-X-BYTERANGE:${byterange}\n${uri}`);
-		if (m3u8Content.includes("#EXT-X-DISCONTINUITY") && m3u8Content.includes("#EXT-X-MAP") && m3u8Url.includes("media.dssott.com/")) this.applyRegexReplacement(m3u8Content, DefaultHlsContentProcessor.DNSPRegex);
-		if (m3u8Content.includes("#EXT-X-DISCONTINUITY") && m3u8Content.includes("seg_00000.vtt") && m3u8Url.includes("media.dssott.com/")) this.applyRegexReplacement(m3u8Content, DefaultHlsContentProcessor.DNSPSubRegex);
-		if (m3u8Content.includes("#EXT-X-DISCONTINUITY") && m3u8Content.includes("#EXT-X-MAP") && (m3u8Url.includes(".apple.com/") || DefaultHlsContentProcessor.ATVRegex.test(m3u8Content))) {
-			const match = DefaultHlsContentProcessor.ATVRegex2.exec(m3u8Content);
-			if (match) m3u8Content = `#EXTM3U\n${match[1]}\n#EXT-X-ENDLIST`;
-		}
-		if (DefaultHlsContentProcessor.OrderFixRegex.test(m3u8Content)) m3u8Content = m3u8Content.replace(DefaultHlsContentProcessor.OrderFixRegex, "$3$2$1");
-		return m3u8Content;
-	}
-	applyRegexReplacement(content, regex) {
-		if (regex.test(content)) {
-			const match = regex.exec(content);
-			if (match) return content.split(match[0]).join("#XXX");
-		}
-		return content;
-	}
-};
-
-//#endregion
-//#region lib/hls/hls-key-processor.ts
-var DefaultHlsKeyProcessor = class {
-	canProcess(extractorType) {
-		return extractorType === EXTRACTOR_TYPES.HLS;
-	}
-	async process(keyLine, m3u8Url, _m3u8Content, parserConfig) {
-		const iv = this.getAttribute(keyLine, "IV");
-		const method = this.getAttribute(keyLine, "METHOD");
-		const uri = this.getAttribute(keyLine, "URI");
-		const encryptInfo = new EncryptInfo(method);
-		if (iv) encryptInfo.iv = b.hex().encode(iv);
-		if (parserConfig.customIv && parserConfig.customIv.length > 0) encryptInfo.iv = parserConfig.customIv;
-		try {
-			if (parserConfig.customKey && parserConfig.customKey.length > 0) encryptInfo.key = parserConfig.customKey;
-			else if (uri) {
-				const lowerUri = uri.toLowerCase();
-				if (lowerUri.startsWith("base64:")) encryptInfo.key = b.base64().encode(uri.slice(7));
-				else if (lowerUri.startsWith("data:;base64,")) encryptInfo.key = b.base64().encode(uri.slice(13));
-				else if (lowerUri.startsWith("data:text/plain;base64,")) encryptInfo.key = b.base64().encode(uri.slice(23));
-				else if (existsSync(uri)) encryptInfo.key = readFileSync(uri);
-				else {
-					const processedUrl = this.preProcessUrl(new URL(uri, m3u8Url).toString(), parserConfig);
-					encryptInfo.key = await this.fetchKeyWithRetry(processedUrl, parserConfig);
-				}
-			}
-		} catch (error) {
-			console.error(`Failed to load key: ${error.message}`);
-			encryptInfo.method = ENCRYPT_METHODS.UNKNOWN;
-		}
-		if (parserConfig.customMethod) {
-			console.warn(`METHOD changed from ${encryptInfo.method} to ${parserConfig.customMethod}`);
-			encryptInfo.method = parserConfig.customMethod;
-		}
-		return encryptInfo;
-	}
-	getAttribute(line, attrName) {
-		const regex = new RegExp(`${attrName}=(?:"([^"]+)"|([^,]+))`, "i");
-		const match = line.match(regex);
-		return match?.[1] ?? match?.[2] ?? null;
-	}
-	async fetchKeyWithRetry(url, parserConfig) {
-		let retryCount = parserConfig.keyRetryCount ?? 3;
-		while (retryCount >= 0) try {
-			const response = await fetch(url, { headers: parserConfig.headers });
-			return new Uint8Array(await response.arrayBuffer());
-		} catch (error) {
-			if (error.message.includes("scheme is not supported")) throw error;
-			console.warn(`Error fetching key: ${error.message}. Retries left: ${retryCount}`);
-			await new Promise((resolve) => setTimeout(resolve, 1e3));
-			retryCount--;
-		}
-		throw new Error("Maximum retry attempts reached");
-	}
-	preProcessUrl(url, parserConfig) {
-		let processedUrl = url;
-		for (const processor of parserConfig.urlProcessors ?? []) if (processor.canProcess(EXTRACTOR_TYPES.HLS, processedUrl, parserConfig)) processedUrl = processor.process(processedUrl, parserConfig);
-		return processedUrl;
-	}
-};
-
-//#endregion
-//#region lib/parser-config.ts
-var ParserConfig = class {
-	url = "";
-	originalUrl = "";
-	baseUrl;
-	customParserArgs = {};
-	headers = {};
-	contentProcessors = [new DefaultDashContentProcessor(), new DefaultHlsContentProcessor()];
-	urlProcessors = [new DefaultUrlProcessor()];
-	keyProcessors = [new DefaultHlsKeyProcessor()];
-	customMethod;
-	customKey;
-	customIv;
-	urlProcessorArgs;
-	appendUrlParams = false;
-	keyRetryCount = 3;
-};
-
-//#endregion
-//#region lib/dash/dash-tags.ts
-const DASH_TAGS = {
-	TemplateRepresentationID: "$RepresentationID$",
-	TemplateBandwidth: "$Bandwidth$",
-	TemplateNumber: "$Number$",
-	TemplateTime: "$Time$"
-};
-
-//#endregion
-//#region lib/shared/util.ts
-const combineUrl = (baseUrl, relativeUrl) => {
-	if (!baseUrl.trim()) return relativeUrl;
-	const url1 = new URL(baseUrl);
-	return new URL(relativeUrl, url1).toString();
-};
-const replaceVars = (text, dict) => {
-	let result = text;
-	for (const [key, value] of Object.entries(dict)) result = result.replaceAll(key, String(value));
-	const regex = /\$Number%([0-9]+)d\$/g;
-	if (regex.test(result)) {
-		const template = dict[DASH_TAGS.TemplateNumber];
-		result = result.replace(regex, (_match, p1) => {
-			if (!template) return "";
-			return template.toString().padStart(parseInt(p1), "0");
-		});
-	}
-	return result;
-};
-/**
-* Extracts parameters from text like:
-* #EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=2149280,CODECS="mp4a.40.2,avc1.64001f",RESOLUTION=1280x720,NAME="720"
-* @param line - The line of text to be parsed
-* @param key - If empty, returns all characters after the first colon
-* @returns The extracted attribute value
-*/
-const getAttribute = (line, key = "") => {
-	line = line.trim();
-	if (key === "") return line.slice(line.indexOf(":") + 1);
-	let index = -1;
-	let result = "";
-	if ((index = line.indexOf(key + "=\"")) > -1) {
-		const startIndex = index + (key + "=\"").length;
-		const endIndex = line.indexOf("\"", startIndex);
-		result = line.slice(startIndex, endIndex);
-	} else if ((index = line.indexOf(key + "=")) > -1) {
-		const startIndex = index + (key + "=").length;
-		const endIndex = line.indexOf(",", startIndex);
-		result = endIndex >= startIndex ? line.slice(startIndex, endIndex) : line.slice(startIndex);
-	}
-	return result;
-};
-const distinctBy = (array, callbackfn) => {
-	const seen = /* @__PURE__ */ new Set();
-	return array.filter((item) => {
-		const value = callbackfn(item);
-		if (seen.has(value)) return false;
-		seen.add(value);
-		return true;
-	});
-};
-const parseMimes = (codecs) => codecs.toLowerCase().split(",").map((codec) => codec.trim().split(".")[0]);
-
-//#endregion
-//#region lib/dash/dash-utils.ts
-/**
-* Extracts StartRange and ExpectLength information from a string like "100-300"
-* @param range - The range string in the format "start-end"
-* @returns A tuple containing [StartRange, ExpectLength]
-*/
-const parseRange = (range) => {
-	const [startRange, end] = range.split("-").map(Number);
-	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() {
-		return EXTRACTOR_TYPES.MPEG_DASH;
-	}
-	#mpdUrl = "";
-	#baseUrl = "";
-	#mpdContent = "";
-	#parserConfig;
-	constructor(parserConfig) {
-		this.#parserConfig = parserConfig;
-		this.#setInitUrl();
-	}
-	#setInitUrl() {
-		this.#mpdUrl = this.#parserConfig.url ?? "";
-		this.#baseUrl = this.#parserConfig.baseUrl ?? this.#mpdUrl;
-	}
-	#extendBaseUrl(node, baseUrl) {
-		const target = node.getElementsByTagName("BaseURL").filter((n) => !!n.parentNode?.isSameNode(node))[0];
-		if (target?.textContent) return combineUrl(baseUrl, target.textContent);
-		return baseUrl;
-	}
-	#getFrameRate(node) {
-		const frameRate = node.getAttribute("frameRate");
-		if (!frameRate || !frameRate.includes("/")) return;
-		const d = Number(frameRate.split("/")[0]) / Number(frameRate.split("/")[1]);
-		return Number(d.toFixed(3));
-	}
-	async extractStreams(rawText) {
-		const streamInfos = [];
-		this.#mpdContent = rawText;
-		const mpdElement = new DOMParser().parseFromString(this.#mpdContent, "text/xml").getElementsByTagName("MPD")[0];
-		const isLive = mpdElement.getAttribute("type") === "dynamic";
-		const availabilityStartTime = mpdElement.getAttribute("availabilityStartTime");
-		const timeShiftBufferDepth = mpdElement.getAttribute("timeShiftBufferDepth") || "PT1M";
-		const publishTime = mpdElement.getAttribute("publishTime");
-		const mediaPresentationDuration = mpdElement.getAttribute("mediaPresentationDuration");
-		const baseUrlElement = mpdElement.getElementsByTagName("BaseURL")[0];
-		if (baseUrlElement?.textContent) {
-			let baseUrl = baseUrlElement.textContent;
-			if (baseUrl.includes("kkbox.com.tw/")) baseUrl = baseUrl.replace("//https:%2F%2F", "//");
-			this.#baseUrl = combineUrl(this.#mpdUrl, baseUrl);
-		}
-		const periods = mpdElement.getElementsByTagName("Period");
-		for (const period of periods) {
-			const periodDuration = period.getAttribute("duration");
-			const periodId = period.getAttribute("id");
-			const periodDurationSeconds = Temporal.Duration.from(periodDuration || mediaPresentationDuration || "PT0S").total("seconds");
-			let segBaseUrl = this.#extendBaseUrl(period, this.#baseUrl);
-			const adaptationSetsBaseUrl = segBaseUrl;
-			const adaptationSets = period.getElementsByTagName("AdaptationSet");
-			for (const adaptationSet of adaptationSets) {
-				segBaseUrl = this.#extendBaseUrl(adaptationSet, segBaseUrl);
-				const representationsBaseUrl = segBaseUrl;
-				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 (!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") {
-						streamInfo.bitrate = bitrate;
-						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) streamInfo.groupId = streamInfo.groupId + "-" + volumeAdjust;
-					const mType = representation.getAttribute("mimeType") || adaptationSet.getAttribute("mimeType");
-					if (mType) {
-						const mTypeSplit = mType.split("/");
-						streamInfo.extension = mTypeSplit.length === 2 ? mTypeSplit[1] : null;
-					}
-					const role = roles?.[0];
-					if (role) {
-						const roleValue = role.value;
-						const capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
-						streamInfo.role = ROLE_TYPE[roleValue.split("-").map(capitalize).join("")];
-					}
-					streamInfo.playlist.isLive = isLive;
-					if (timeShiftBufferDepth) streamInfo.playlist.refreshIntervalMs = 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];
-						if (initialization) {
-							const sourceUrl = initialization.getAttribute("sourceURL");
-							if (!sourceUrl) {
-								const mediaSegment = new MediaSegment();
-								mediaSegment.index = 0;
-								mediaSegment.url = segBaseUrl;
-								mediaSegment.duration = periodDurationSeconds;
-								streamInfo.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
-							} else {
-								const initUrl = combineUrl(segBaseUrl, sourceUrl);
-								const initRange = initialization.getAttribute("range");
-								const initSegment = new MediaSegment();
-								initSegment.index = -1;
-								initSegment.url = initUrl;
-								if (initRange) {
-									const [start, expect] = parseRange(initRange);
-									initSegment.startRange = start;
-									initSegment.expectLength = expect;
-								}
-								streamInfo.playlist.mediaInit = initSegment;
-							}
-						}
-					}
-					const segmentList = representation.getElementsByTagName("SegmentList")[0];
-					if (segmentList) {
-						const durationStr = segmentList.getAttribute("duration");
-						const initialization = segmentList.getElementsByTagName("Initialization")[0];
-						if (initialization) {
-							const sourceUrl = initialization.getAttribute("sourceURL");
-							const initUrl = combineUrl(segBaseUrl, sourceUrl);
-							const initRange = initialization.getAttribute("range");
-							const initSegment = new MediaSegment();
-							initSegment.index = -1;
-							initSegment.url = initUrl;
-							if (initRange) {
-								const [start, expect] = parseRange(initRange);
-								initSegment.startRange = start;
-								initSegment.expectLength = expect;
-							}
-							streamInfo.playlist.mediaInit = initSegment;
-						}
-						const segmentUrls = segmentList.getElementsByTagName("SegmentURL");
-						const timescaleStr = segmentList.getAttribute("timescale") || "1";
-						for (let segmentIndex = 0; segmentIndex < segmentUrls.length; segmentIndex++) {
-							const segmentUrl = segmentUrls[segmentIndex];
-							const mediaUrl = combineUrl(segBaseUrl, segmentUrl.getAttribute("media"));
-							const mediaRange = segmentUrl.getAttribute("mediaRange");
-							const timescale = Number(timescaleStr);
-							const duration = Number(durationStr);
-							const segment = new MediaSegment();
-							segment.index = segmentIndex;
-							segment.url = mediaUrl;
-							segment.duration = duration / timescale;
-							if (mediaRange) {
-								const [start, expect] = parseRange(mediaRange);
-								segment.startRange = start;
-								segment.expectLength = expect;
-							}
-							streamInfo.playlist.mediaParts[0].mediaSegments.push(segment);
-						}
-					}
-					const segmentTemplateElementsOuter = adaptationSet.getElementsByTagName("SegmentTemplate");
-					const segmentTemplateElements = representation.getElementsByTagName("SegmentTemplate");
-					if (segmentTemplateElementsOuter.length || segmentTemplateElements.length) {
-						const segmentTemplate = segmentTemplateElements[0] || segmentTemplateElementsOuter[0];
-						const segmentTemplateOuter = segmentTemplateElementsOuter[0] || segmentTemplateElements[0];
-						const varDic = {};
-						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");
-						const startNumberStr = segmentTemplate.getAttribute("startNumber") || segmentTemplateOuter.getAttribute("startNumber") || "1";
-						const initialization = segmentTemplate.getAttribute("initialization") || segmentTemplateOuter.getAttribute("initialization");
-						if (initialization) {
-							const _init = replaceVars(initialization, varDic);
-							const initUrl = combineUrl(segBaseUrl, _init);
-							const mediaSegment = new MediaSegment();
-							mediaSegment.index = -1;
-							mediaSegment.url = initUrl;
-							streamInfo.playlist.mediaInit = mediaSegment;
-						}
-						const mediaTemplate = segmentTemplate.getAttribute("media") || segmentTemplateOuter.getAttribute("media");
-						const segmentTimeline = segmentTemplate.getElementsByTagName("SegmentTimeline")[0];
-						if (segmentTimeline) {
-							const Ss = segmentTimeline.getElementsByTagName("S");
-							let segNumber = Number(startNumberStr);
-							let currentTime = 0;
-							let segIndex = 0;
-							for (const s of Ss) {
-								const _startTimeStr = s.getAttribute("t");
-								const _durationStr = s.getAttribute("d");
-								const _repeatCountStr = s.getAttribute("r");
-								if (_startTimeStr) currentTime = Number(_startTimeStr);
-								const _duration = Number(_durationStr);
-								const timescale = Number(timescaleStr);
-								let _repeatCount = Number(_repeatCountStr);
-								varDic[DASH_TAGS.TemplateTime] = currentTime;
-								varDic[DASH_TAGS.TemplateNumber] = segNumber++;
-								const hasTime = mediaTemplate?.includes(DASH_TAGS.TemplateTime);
-								const media = replaceVars(mediaTemplate, varDic);
-								const mediaUrl = combineUrl(segBaseUrl, media);
-								const mediaSegment = new MediaSegment();
-								mediaSegment.url = mediaUrl;
-								if (hasTime) mediaSegment.nameFromVar = currentTime.toString();
-								mediaSegment.duration = _duration / timescale;
-								mediaSegment.index = segIndex++;
-								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;
-									const _mediaSegment = new MediaSegment();
-									varDic[DASH_TAGS.TemplateTime] = currentTime;
-									varDic[DASH_TAGS.TemplateNumber] = segNumber++;
-									const _hashTime = mediaTemplate?.includes(DASH_TAGS.TemplateTime);
-									const _media = replaceVars(mediaTemplate, varDic);
-									_mediaSegment.url = combineUrl(segBaseUrl, _media);
-									_mediaSegment.index = segIndex++;
-									_mediaSegment.duration = _duration / timescale;
-									if (_hashTime) _mediaSegment.nameFromVar = currentTime.toString();
-									streamInfo.playlist.mediaParts[0].mediaSegments.push(_mediaSegment);
-								}
-								currentTime += _duration;
-							}
-						} else {
-							const timescale = Number(timescaleStr);
-							let startNumber = Number(startNumberStr);
-							const duration = Number(durationStr);
-							let totalNumber = Math.ceil(periodDurationSeconds * timescale / duration);
-							if (totalNumber === 0 && isLive) {
-								const now = Date.now();
-								const availableTime = new Date(availabilityStartTime);
-								const offsetMs = Number(presentationTimeOffsetStr) / 1e3;
-								availableTime.setUTCMilliseconds(availableTime.getUTCMilliseconds() + offsetMs);
-								const ts = (now - availableTime.getTime()) / 1e3;
-								const updateTs = Temporal.Duration.from(timeShiftBufferDepth).total("seconds");
-								startNumber += (ts - updateTs) * timescale / duration;
-								totalNumber = updateTs * timescale / duration;
-							}
-							for (let index = startNumber, segIndex = 0; index < startNumber + totalNumber; index++, segIndex++) {
-								varDic[DASH_TAGS.TemplateNumber] = index;
-								const hasNumber = mediaTemplate.includes(DASH_TAGS.TemplateNumber);
-								const media = replaceVars(mediaTemplate, varDic);
-								const mediaUrl = combineUrl(segBaseUrl, media);
-								const mediaSegment = new MediaSegment();
-								mediaSegment.url = mediaUrl;
-								if (hasNumber) mediaSegment.nameFromVar = index.toString();
-								mediaSegment.index = isLive ? index : segIndex;
-								mediaSegment.duration = duration / timescale;
-								streamInfo.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
-							}
-						}
-					}
-					if (streamInfo.playlist.mediaParts[0].mediaSegments.length === 0) {
-						const mediaSegment = new MediaSegment();
-						mediaSegment.index = 0;
-						mediaSegment.url = segBaseUrl;
-						mediaSegment.duration = periodDurationSeconds;
-						streamInfo.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
-					}
-					const adaptationSetProtections = adaptationSet.getElementsByTagName("ContentProtection");
-					const representationProtections = representation.getElementsByTagName("ContentProtection");
-					const contentProtections = representationProtections[0] ? representationProtections : adaptationSetProtections;
-					if (contentProtections.length) {
-						const encryptInfo = new EncryptInfo();
-						encryptInfo.method = DashExtractor.#DEFAULT_METHOD;
-						const widevineSystemId = "edef8ba9-79d6-4ace-a3c8-27dcd51d21ed";
-						const playreadySystemId = "9a04f079-9840-4286-ab92-e65be0885f95";
-						for (const contentProtection of contentProtections) {
-							const schemeIdUri = contentProtection.getAttribute("schemeIdUri");
-							const drmData = {
-								keyId: contentProtection.getAttribute("cenc:default_KID") || void 0,
-								pssh: contentProtection.getElementsByTagName("cenc:pssh")[0]?.textContent || void 0
-							};
-							if (schemeIdUri?.includes(widevineSystemId)) encryptInfo.drm.widevine = drmData;
-							else if (schemeIdUri?.includes(playreadySystemId)) encryptInfo.drm.playready = drmData;
-							else continue;
-						}
-						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 = 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 = 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 (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 = 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.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 streamInfos;
-	}
-	#filterLanguage(v) {
-		if (!v) return;
-		return v;
-	}
-	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 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(streamInfos);
-	}
-	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(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);
-		return url;
-	}
-	preProcessContent() {
-		for (const processor of this.#parserConfig.contentProcessors) if (processor.canProcess(this.extractorType, this.#mpdContent, this.#parserConfig)) this.#mpdContent = processor.process(this.#mpdContent, this.#parserConfig);
-	}
-};
-
-//#endregion
-//#region lib/hls/hls-utils.ts
-/**
-* Extracts length and optional start values from a string formatted as "n[@o]".
-* @param input - The input string.
-* @returns A tuple containing [n (length), o (start)].
-*/
-function getRange(input) {
-	const parts = input.split("@");
-	switch (parts.length) {
-		case 0: return [0, null];
-		case 1: return [parseInt(parts[0], 10), null];
-		case 2: return [parseInt(parts[0], 10), parseInt(parts[1], 10)];
-		default: return [0, null];
-	}
-}
-
-//#endregion
-//#region lib/hls/hls-extractor.ts
-var HlsExtractor = class {
-	get extractorType() {
-		return EXTRACTOR_TYPES.HLS;
-	}
-	#m3u8Url = "";
-	#baseUrl = "";
-	#m3u8Content = "";
-	#masterM3u8Flag = false;
-	parserConfig;
-	constructor(parserConfig) {
-		this.parserConfig = parserConfig;
-		this.#m3u8Url = parserConfig.url || "";
-		this.#setBaseUrl();
-	}
-	#setBaseUrl() {
-		this.#baseUrl = this.parserConfig.baseUrl || this.#m3u8Url;
-	}
-	preProcessContent() {
-		this.#m3u8Content = this.#m3u8Content.trim();
-		if (!this.#m3u8Content.startsWith(HLS_TAGS.extM3u)) throw new Error("Invalid m3u8");
-		for (const processor of this.parserConfig.contentProcessors) if (processor.canProcess(this.extractorType, this.#m3u8Content, this.parserConfig)) this.#m3u8Content = processor.process(this.#m3u8Content, this.parserConfig);
-	}
-	preProcessUrl(url) {
-		let result = url;
-		for (const processor of this.parserConfig.urlProcessors) if (processor.canProcess(this.extractorType, url, this.parserConfig)) result = processor.process(url, this.parserConfig);
-		return result;
-	}
-	async #parseMasterList() {
-		this.#masterM3u8Flag = true;
-		const streamInfos = [];
-		let expectPlaylist = false;
-		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)) {
-				streamInfo = new VideoStreamInfo();
-				streamInfo.originalUrl = this.parserConfig.originalUrl;
-				const bandwidth = getAttribute(line, "AVERAGE-BANDWIDTH") || getAttribute(line, "BANDWIDTH");
-				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) streamInfo.frameRate = Number(frameRate);
-				const audioId = getAttribute(line, "AUDIO");
-				if (audioId) streamInfo.audioId = audioId;
-				const videoId = getAttribute(line, "VIDEO");
-				if (videoId) streamInfo.videoId = videoId;
-				const subtitleId = getAttribute(line, "SUBTITLES");
-				if (subtitleId) streamInfo.subtitleId = subtitleId;
-				const videoRange = getAttribute(line, "VIDEO-RANGE");
-				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)) {
-				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);
-				streamInfo.url = this.preProcessUrl(url);
-				const groupId = getAttribute(line, "GROUP-ID");
-				if (groupId) streamInfo.groupId = groupId;
-				const language = getAttribute(line, "LANGUAGE");
-				if (language) streamInfo.languageCode = language;
-				const name = getAttribute(line, "NAME");
-				if (name) streamInfo.name = name;
-				const defaultFlag = getAttribute(line, "DEFAULT");
-				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) 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);
-				streamInfo.url = this.preProcessUrl(url);
-				expectPlaylist = false;
-				streamInfos.push(streamInfo);
-			}
-		}
-		return streamInfos;
-	}
-	async #parseList() {
-		let hasAd = false;
-		const allowHlsMultiExtMap = this.parserConfig.customParserArgs["allowHlsMultiExtMap"] === "true";
-		if (allowHlsMultiExtMap) console.log(`allowHlsMultiExtMap is set to true`);
-		let expectSegment = false;
-		let isEndList = false;
-		let segIndex = 0;
-		let isAd = false;
-		const playlist = new Playlist();
-		const mediaParts = [];
-		const currentEncryptInfo = new EncryptInfo();
-		if (this.parserConfig.customMethod) currentEncryptInfo.method = this.parserConfig.customMethod;
-		if (this.parserConfig.customKey) currentEncryptInfo.key = this.parserConfig.customKey;
-		if (this.parserConfig.customIv) currentEncryptInfo.iv = this.parserConfig.customIv;
-		let lastKeyLine = "";
-		let segment = new MediaSegment();
-		let segments = [];
-		const lines = this.#m3u8Content.split("\n");
-		for (const line of lines) {
-			if (!line.trim()) continue;
-			if (line.startsWith(HLS_TAGS.extXByterange)) {
-				const [n, o] = getRange(getAttribute(line));
-				segment.expectLength = n;
-				segment.startRange = o || (segments.at(-1)?.startRange || 0) + (segments.at(-1)?.expectLength || 0);
-				expectSegment = true;
-			} else if (line.startsWith("#UPLYNK-SEGMENT")) {
-				if (line.includes(",ad")) isAd = true;
-				else if (line.includes(",segment")) isAd = false;
-			} else if (isAd) continue;
-			else if (line.startsWith(HLS_TAGS.extXTargetDuration)) playlist.targetDuration = Number(getAttribute(line));
-			else if (line.startsWith(HLS_TAGS.extXMediaSequence)) segIndex = Number(getAttribute(line));
-			else if (line.startsWith(HLS_TAGS.extXProgramDateTime)) segment.dateTime = new Date(getAttribute(line));
-			else if (line.startsWith(HLS_TAGS.extXDiscontinuity)) {
-				if (hasAd && mediaParts.length) {
-					segments = mediaParts.at(-1)?.mediaSegments || [];
-					mediaParts.pop();
-					hasAd = false;
-					continue;
-				}
-				if (hasAd && !segments.length) continue;
-				mediaParts.push(new MediaPart(segments));
-				segments = [];
-			} else if (line.startsWith(HLS_TAGS.extXKey)) {
-				if (getAttribute(line, "URI") !== getAttribute(lastKeyLine, "URI")) {
-					const parsedInfo = await this.#parseKey(line);
-					currentEncryptInfo.method = parsedInfo.method;
-					currentEncryptInfo.key = parsedInfo.key;
-					currentEncryptInfo.iv = parsedInfo.iv;
-				}
-				lastKeyLine = line;
-			} else if (line.startsWith(HLS_TAGS.extInf)) {
-				const tmp = getAttribute(line).split(",");
-				segment.duration = Number(tmp[0]);
-				segment.index = segIndex;
-				if (currentEncryptInfo.method != ENCRYPT_METHODS.NONE) {
-					segment.encryptInfo.method = currentEncryptInfo.method;
-					segment.encryptInfo.key = currentEncryptInfo.key;
-					segment.encryptInfo.iv = currentEncryptInfo.iv;
-				}
-				expectSegment = true;
-				segIndex++;
-			} else if (line.startsWith(HLS_TAGS.extXEndlist)) {
-				if (segments.length > 0) mediaParts.push(new MediaPart(segments));
-				segments = [];
-				isEndList = true;
-			} else if (line.startsWith(HLS_TAGS.extXMap)) if (!playlist.mediaInit || hasAd) {
-				const mediaSegment = new MediaSegment();
-				mediaSegment.url = this.preProcessUrl(combineUrl(this.#baseUrl, getAttribute(line, "URI")));
-				mediaSegment.index = -1;
-				playlist.mediaInit = mediaSegment;
-				if (line.includes("BYTERANGE")) {
-					const [n, o] = getRange(getAttribute(line, "BYTERANGE"));
-					mediaSegment.expectLength = n;
-					mediaSegment.startRange = o || 0;
-				}
-				if (currentEncryptInfo.method === ENCRYPT_METHODS.NONE) continue;
-				playlist.mediaInit.encryptInfo.method = currentEncryptInfo.method;
-				playlist.mediaInit.encryptInfo.key = currentEncryptInfo.key;
-				playlist.mediaInit.encryptInfo.iv = currentEncryptInfo.iv;
-			} else {
-				if (segments.length) mediaParts.push(new MediaPart(segments));
-				segments = [];
-				if (!allowHlsMultiExtMap) {
-					isEndList = true;
-					break;
-				}
-			}
-			else if (line.startsWith("#")) continue;
-			else if (line.startsWith("\r\n")) continue;
-			else if (expectSegment) {
-				const segUrl = this.preProcessUrl(combineUrl(this.#baseUrl, line));
-				segment.url = segUrl;
-				segments.push(segment);
-				segment = new MediaSegment();
-				if (segUrl.includes("ccode=") && segUrl.includes("/ad/") && segUrl.includes("duratio=")) {
-					segments.pop();
-					segIndex--;
-					hasAd = true;
-				}
-				if (segUrl.includes("ccode=0902") && segUrl.includes("duration=")) {
-					segments.pop();
-					segIndex--;
-					hasAd = false;
-				}
-				expectSegment = false;
-			}
-		}
-		if (!isEndList) mediaParts.push(new MediaPart(segments));
-		playlist.mediaParts = mediaParts;
-		playlist.isLive = !isEndList;
-		if (playlist.isLive) playlist.refreshIntervalMs = (playlist.targetDuration || 5) * 2 * 1e3;
-		return playlist;
-	}
-	async #parseKey(keyLine) {
-		for (const p of this.parserConfig.keyProcessors) if (p.canProcess(this.extractorType, keyLine, this.#m3u8Url, this.#m3u8Content, this.parserConfig)) return p.process(keyLine, this.#m3u8Url, this.#m3u8Content, this.parserConfig);
-		throw new Error("No key processor found");
-	}
-	async extractStreams(rawText) {
-		this.#m3u8Content = rawText;
-		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 VideoStreamInfo();
-		streamSpec.url = this.parserConfig.url;
-		streamSpec.playlist = playlist;
-		streamSpec.extension = playlist.mediaInit ? "mp4" : "ts";
-		return [streamSpec];
-	}
-	async #loadM3u8FromUrl(url) {
-		if (url.startsWith("file:")) {
-			const filePath = new URL(url).pathname;
-			this.#m3u8Content = await readFile(filePath, "utf8");
-		} else if (url.startsWith("http")) try {
-			const response = await fetch(url, { headers: this.parserConfig.headers });
-			url = response.url;
-			this.#m3u8Content = await response.text();
-		} catch (e) {
-			if (this.parserConfig.originalUrl.startsWith("http") && url !== this.parserConfig.originalUrl) {
-				const response = await fetch(this.parserConfig.originalUrl, { headers: this.parserConfig.headers });
-				url = response.url;
-				this.#m3u8Content = await response.text();
-			}
-		}
-		this.#m3u8Url = url;
-		this.#setBaseUrl();
-		this.preProcessContent();
-	}
-	async #refreshUrlFromMaster(lists) {
-		await this.#loadM3u8FromUrl(this.parserConfig.url);
-		const newStreams = await this.#parseMasterList().then((lists$1) => distinctBy(lists$1, (list) => list.url));
-		for (const list of lists) {
-			const match = newStreams.filter((stream) => stream.toShortString() === list.toShortString());
-			if (!match.length) continue;
-			list.url = match.at(0).url;
-		}
-	}
-	async fetchPlayList(lists) {
-		for (const list of lists) {
-			try {
-				await this.#loadM3u8FromUrl(list.url);
-			} catch (e) {
-				if (this.#masterM3u8Flag) console.warn("Can not load m3u8. Try refreshing url from master url...");
-				await this.#refreshUrlFromMaster(lists);
-				await this.#loadM3u8FromUrl(list.url);
-			}
-			const newPlaylist = await this.#parseList();
-			if (list.playlist?.mediaInit) list.playlist.mediaParts = newPlaylist.mediaParts;
-			else list.playlist = newPlaylist;
-			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";
-				if (b$1) list.extension = "vtt";
-			} else list.extension = list.playlist.mediaInit ? "m4s" : "ts";
-		}
-	}
-	async refreshPlayList(streamInfos) {
-		await this.fetchPlayList(streamInfos);
-	}
-};
-
-//#endregion
-//#region lib/stream-extractor.ts
-var StreamExtractor = class {
-	#extractor;
-	#rawText;
-	#parserConfig;
-	#rawFiles = {};
-	constructor(parserConfig) {
-		this.#parserConfig = parserConfig ?? new ParserConfig();
-	}
-	get extractorType() {
-		return this.#extractor.extractorType;
-	}
-	#setUrl(url) {
-		this.#parserConfig.originalUrl = url;
-		this.#parserConfig.url = url;
-	}
-	async loadSourceFromUrl(url) {
-		if (url.startsWith("file:")) {
-			const filePath = new URL(url).pathname;
-			this.#rawText = await readFile(filePath, "utf8");
-			this.#setUrl(url);
-		} else if (url.startsWith("http")) {
-			this.#parserConfig.originalUrl = url;
-			const response = await fetch(url, { headers: this.#parserConfig.headers });
-			this.#rawText = await response.text();
-			this.#parserConfig.url = response.url;
-		} else if (existsSync(url)) {
-			const filePath = path.resolve(url);
-			this.#rawText = await readFile(filePath, "utf8");
-			const absoluteUri = pathToFileURL(filePath).toString();
-			this.#setUrl(absoluteUri);
-		}
-		this.#rawText = this.#rawText.trim();
-		this.loadSourceFromText(this.#rawText);
-	}
-	loadSourceFromText(rawText, url) {
-		if (url) this.#setUrl(url);
-		let rawType = "txt";
-		this.#rawText = rawText.trim();
-		if (this.#rawText.startsWith(HLS_TAGS.extM3u)) {
-			this.#extractor = new HlsExtractor(this.#parserConfig);
-			rawType = "m3u8";
-		} else if (this.#rawText.includes("</MPD>") && this.#rawText.includes("<MPD")) {
-			this.#extractor = new DashExtractor(this.#parserConfig);
-			rawType = "mpd";
-		} else if (this.#rawText.includes("</SmoothStreamingMedia>") && this.#rawText.includes("<SmoothStreamingMedia")) {
-			rawType = "ism";
-			throw new Error("Smooth Streaming is not supported yet");
-		} else if (rawText === "<RE_LIVE_TS>") throw new Error("Live TS is not supported yet");
-		else throw new Error("Unsupported stream type");
-		this.#rawFiles[`raw.${rawType}`] = rawText;
-	}
-	async extractStreams() {
-		return this.#extractor.extractStreams(this.#rawText);
-	}
-	async fetchPlayList(streamInfos) {
-		return this.#extractor.fetchPlayList(streamInfos);
-	}
-	async refreshPlayList(streamInfos) {
-		return this.#extractor.refreshPlayList(streamInfos);
-	}
-};
-
-//#endregion
-export { ALL_STREAM_TYPES, AUDIO_CODECS, AudioStreamInfo, DASH_TAGS, DashExtractor, DefaultDashContentProcessor, DefaultHlsContentProcessor, DefaultHlsKeyProcessor, DefaultUrlProcessor, ENCRYPT_METHODS, EXTRACTOR_TYPES, EncryptInfo, HLS_TAGS, HlsExtractor, MediaPart, MediaSegment, ParserConfig, Playlist, ROLE_TYPE, SUBTITLE_CODECS, StreamExtractor, StreamInfo, SubtitleStreamInfo, VIDEO_CODECS, VIDEO_DYNAMIC_RANGES, VideoStreamInfo, getRange, parseRange };