dasha 3.1.5 → 4.0.0-alpha.1

package/dist/dasha.js

@@ -0,0 +1,1019 @@
+import { existsSync } from "node:fs";
+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";
+import crypto from "node:crypto";
+
+//#region lib/shared/media-type.ts
+const MEDIA_TYPES = {
+	VIDEO: "video",
+	AUDIO: "audio",
+	SUBTITLES: "subtitle",
+	CLOSED_CAPTIONS: "closed-captions"
+};
+
+//#endregion
+//#region lib/shared/encrypt-method.ts
+const ENCRYPT_METHODS = {
+	NONE: 0,
+	AES_128: 1,
+	AES_128_ECB: 2,
+	SAMPLE_AES: 3,
+	SAMPLE_AES_CTR: 4,
+	CENC: 5,
+	CHACHA20: 6,
+	UNKNOWN: 7
+};
+
+//#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/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/parser-config.ts
+var ParserConfig = class {
+	url = "";
+	originalUrl = "";
+	baseUrl;
+	customParserArgs = {};
+	headers = {};
+	contentProcessors = [];
+	urlProcessors = [];
+	keyProcessors = [];
+	customMethod;
+	customKey;
+	customIv;
+	urlProcessorArgs;
+	appendUrlParams = false;
+	keyRetryCount = 3;
+};
+
+//#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/shared/stream-spec.ts
+var StreamSpec = class {
+	mediaType;
+	groupId = null;
+	language;
+	name;
+	default;
+	skippedDuration;
+	bandwidth;
+	codecs = null;
+	resolution;
+	frameRate;
+	channels = null;
+	extension = null;
+	role;
+	videoRange;
+	characteristics;
+	publishTime;
+	audioId;
+	videoId;
+	subtitleId;
+	periodId = null;
+	url = "";
+	originalUrl = "";
+	playlist;
+	get segmentsCount() {
+		return this.playlist?.mediaParts.reduce((sum, part) => sum + part.mediaSegments.length, 0) ?? 0;
+	}
+	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();
+	}
+};
+
+//#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);
+	const url2 = new URL(relativeUrl, url1);
+	return url2.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 = new Set();
+	return array.filter((item) => {
+		const value = callbackfn(item);
+		if (seen.has(value)) return false;
+		seen.add(value);
+		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 = [];
+};
+
+//#endregion
+//#region lib/shared/media-part.ts
+var MediaPart = class {
+	mediaSegments = [];
+	constructor(segments) {
+		this.mediaSegments = segments || [];
+	}
+};
+
+//#endregion
+//#region lib/shared/encrypt-info.ts
+var EncryptInfo = class {
+	method = ENCRYPT_METHODS.NONE;
+	key;
+	iv;
+	constructor(method) {
+		this.method = this.parseMethod(method);
+	}
+	parseMethod(method) {
+		if (method !== void 0) return ENCRYPT_METHODS[method.replace("-", "_")];
+		else return ENCRYPT_METHODS.UNKNOWN;
+	}
+};
+
+//#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/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);
+	const expectLength = end - startRange + 1;
+	return [startRange, expectLength];
+};
+
+//#endregion
+//#region lib/dash/dash-extractor.ts
+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")[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 streamList = [];
+		this.#mpdContent = rawText;
+		const document = new DOMParser().parseFromString(this.#mpdContent, "text/xml");
+		const mpdElement = document.getElementsByTagName("MPD")[0];
+		const type = mpdElement.getAttribute("type");
+		const isLive = type === "dynamic";
+		const maxSegmentDuration = mpdElement.getAttribute("maxSegmentDuration");
+		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 mimeType = adaptationSet.getAttribute("contentType") || 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;
+					const volumeAdjust = representation.getAttribute("volumeAdjust");
+					if (volumeAdjust) streamSpec.groupId = streamSpec.groupId + "-" + volumeAdjust;
+					const mType = representation.getAttribute("mimeType") || adaptationSet.getAttribute("mimeType");
+					if (mType) {
+						const mTypeSplit = mType.split("/");
+						streamSpec.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];
+					if (role) {
+						const roleValue = role.getAttribute("value");
+						const capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
+						const roleTypeKey = roleValue.split("-").map(capitalize).join("");
+						const roleType = ROLE_TYPE[roleTypeKey];
+						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;
+					}
+					streamSpec.playlist.isLive = isLive;
+					if (timeShiftBufferDepth) streamSpec.playlist.refreshIntervalMs = 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);
+					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;
+								streamSpec.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;
+								}
+								streamSpec.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;
+							}
+							streamSpec.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;
+							}
+							streamSpec.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] = streamSpec.groupId;
+						varDic[DASH_TAGS.TemplateBandwidth] = bandwidth;
+						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;
+							streamSpec.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++;
+								streamSpec.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);
+									const _mediaUrl = combineUrl(segBaseUrl, _media);
+									_mediaSegment.url = _mediaUrl;
+									_mediaSegment.index = segIndex++;
+									_mediaSegment.duration = _duration / timescale;
+									if (_hashTime) _mediaSegment.nameFromVar = currentTime.toString();
+									streamSpec.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;
+								streamSpec.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
+							}
+						}
+					}
+					if (streamSpec.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);
+					}
+					const contentProtection = adaptationSet.getElementsByTagName("ContentProtection")[0] || representation.getElementsByTagName("ContentProtection")[0];
+					if (contentProtection) {
+						const encryptInfo = new EncryptInfo();
+						encryptInfo.method = DashExtractor.#DEFAULT_METHOD;
+						if (streamSpec.playlist.mediaInit) streamSpec.playlist.mediaInit.encryptInfo = encryptInfo;
+						const segments = streamSpec.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 {
+						const url1 = streamList[_index].playlist.mediaParts.at(-1).mediaSegments.at(-1).url;
+						const url2 = streamSpec.playlist.mediaParts[0].mediaSegments.at(-1)?.url;
+						if (url1 !== url2) {
+							const startIndex = streamList[_index].playlist.mediaParts.at(-1).mediaSegments.at(-1).index + 1;
+							const segments = streamSpec.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);
+					}
+					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);
+					}
+					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);
+		for (const video of videoList) {
+			const audioGroupId = audioList.toSorted((a, b) => (b.bandwidth || 0) - (a.bandwidth || 0)).at(0)?.groupId;
+			const subtitleGroupId = subtitleList.toSorted((a, b) => (b.bandwidth || 0) - (a.bandwidth || 0)).at(0)?.groupId;
+			if (audioGroupId) video.audioId = audioGroupId;
+			if (subtitleGroupId) video.subtitleId = subtitleGroupId;
+		}
+		return streamList;
+	}
+	#filterLanguage(v) {
+		if (!v) return;
+		return v;
+	}
+	fetchPlayList(streamSpecs) {
+		throw new Error("Method not implemented.");
+	}
+	refreshPlayList(streamSpecs) {
+		throw new Error("Method not implemented.");
+	}
+	preProcessUrl(url) {
+		throw new Error("Method not implemented.");
+	}
+	preProcessContent() {
+		throw new Error("Method not implemented.");
+	}
+};
+
+//#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 streams = [];
+		let expectPlaylist = false;
+		let streamSpec = new StreamSpec();
+		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;
+				const bandwidth = getAttribute(line, "AVERAGE-BANDWIDTH") || getAttribute(line, "BANDWIDTH");
+				streamSpec.bandwidth = Number(bandwidth || 0);
+				streamSpec.codecs = getAttribute(line, "CODECS");
+				streamSpec.resolution = getAttribute(line, "RESOLUTION");
+				const frameRate = getAttribute(line, "FRAME-RATE");
+				if (frameRate) streamSpec.frameRate = Number(frameRate);
+				const audioId = getAttribute(line, "AUDIO");
+				if (audioId) streamSpec.audioId = audioId;
+				const videoId = getAttribute(line, "VIDEO");
+				if (videoId) streamSpec.videoId = videoId;
+				const subtitleId = getAttribute(line, "SUBTITLES");
+				if (subtitleId) streamSpec.subtitleId = subtitleId;
+				const videoRange = getAttribute(line, "VIDEO-RANGE");
+				if (videoRange) streamSpec.videoRange = videoRange;
+				if (streamSpec.codecs && streamSpec.audioId) streamSpec.codecs = streamSpec.codecs.split(",")[0];
+				expectPlaylist = true;
+			} else if (line.startsWith(HLS_TAGS.extXMedia)) {
+				streamSpec = new StreamSpec();
+				const type = getAttribute(line, "TYPE").replace("-", "_");
+				const mediaType = MEDIA_TYPES[type];
+				if (mediaType) streamSpec.mediaType = mediaType;
+				if (mediaType === MEDIA_TYPES.CLOSED_CAPTIONS) continue;
+				let url = getAttribute(line, "URI");
+				if (!url) continue;
+				url = combineUrl(this.#baseUrl, url);
+				streamSpec.url = this.preProcessUrl(url);
+				const groupId = getAttribute(line, "GROUP-ID");
+				if (groupId) streamSpec.groupId = groupId;
+				const language = getAttribute(line, "LANGUAGE");
+				if (language) streamSpec.language = language;
+				const name = getAttribute(line, "NAME");
+				if (name) streamSpec.name = name;
+				const defaultFlag = getAttribute(line, "DEFAULT");
+				if (defaultFlag) streamSpec.default = defaultFlag.toLowerCase() === "yes";
+				const channels = getAttribute(line, "CHANNELS");
+				if (channels) streamSpec.channels = channels;
+				const characteristics = getAttribute(line, "CHARACTERISTICS");
+				if (characteristics) streamSpec.characteristics = characteristics.split(",").at(-1)?.split(".").at(-1);
+				streams.push(streamSpec);
+			} else if (line.startsWith("#")) continue;
+			else if (expectPlaylist) {
+				const url = combineUrl(this.#baseUrl, line);
+				streamSpec.url = this.preProcessUrl(url);
+				expectPlaylist = false;
+				streams.push(streamSpec);
+			}
+		}
+		return streams;
+	}
+	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 p = getAttribute(line);
+				const [n, o] = getRange(p);
+				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)) {
+				const uri = getAttribute(line, "URI");
+				const uriLast = getAttribute(lastKeyLine, "URI");
+				if (uri !== uriLast) {
+					const parsedInfo = 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 p = getAttribute(line, "BYTERANGE");
+					const [n, o] = getRange(p);
+					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;
+	}
+	#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)) {
+			console.log("Master m3u8 found");
+			return this.#parseMasterList().then((lists) => distinctBy(lists, (list) => list.url));
+		}
+		const playlist = await this.#parseList();
+		const streamSpec = new StreamSpec();
+		streamSpec.url = this.parserConfig.url;
+		streamSpec.playlist = playlist;
+		streamSpec.extension = playlist.mediaInit ? "mp4" : "ts";
+		return [streamSpec];
+	}
+	async #loadM3u8FromUrl(url) {
+		if (url.startsWith("file:")) {
+			const uri = new URL(url);
+			const filePath = uri.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 (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.mediaType === MEDIA_TYPES.SUBTITLES) {
+				const a = list.playlist.mediaParts.some((part) => part.mediaSegments.some((segment) => segment.url.includes(".ttml")));
+				const b = list.playlist.mediaParts.some((part) => part.mediaSegments.some((segment) => segment.url.includes(".vtt") || segment.url.includes(".webvtt")));
+				if (a) list.extension = "ttml";
+				if (b) list.extension = "vtt";
+			} else list.extension = list.playlist.mediaInit ? "m4s" : "ts";
+		}
+	}
+	async refreshPlayList(streamSpecs) {
+		await this.fetchPlayList(streamSpecs);
+	}
+};
+
+//#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 uri = new URL(url);
+			const filePath = uri.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";
+		else if (rawText === "<RE_LIVE_TS>") {} else throw new Error("Unsupported stream type");
+		this.#rawFiles[`raw.${rawType}`] = rawText;
+	}
+	async extractStreams() {
+		return this.#extractor.extractStreams(this.#rawText);
+	}
+	async fetchPlayList(streamSpecs) {
+		return this.#extractor.fetchPlayList(streamSpecs);
+	}
+	async refreshPlayList(streamSpecs) {
+		return this.#extractor.refreshPlayList(streamSpecs);
+	}
+};
+
+//#endregion
+export { ENCRYPT_METHODS, EXTRACTOR_TYPES, MEDIA_TYPES, ParserConfig, ROLE_TYPE, StreamExtractor };