dasha 4.0.0-alpha.1 → 4.0.0-alpha.3

package/README.md

@@ -6,10 +6,14 @@
 
 Library for parsing MPEG-DASH (.mpd) and HLS (.m3u8) manifests. Made with the purpose of obtaining a simplified representation convenient for further downloading of segments.
 
+> [!WARNING]  
+> This README is for the alpha version. Info about latest stable version is available on [NPM](https://www.npmjs.com/package/dasha/v/3.1.5) or [another GitHub branch](https://github.com/azot-labs/dasha/tree/v3).
+
+
 ## Install
 
 ```shell
-npm i dasha
+npm i dasha@alpha
 ```
 
 ## Usage
@@ -19,13 +23,16 @@ import fs from 'node:fs/promises';
 import { parse } from 'dasha';
 
 const url = 'https://dash.akamaized.net/dash264/TestCases/1a/sony/SNE_DASH_SD_CASE1A_REVISED.mpd';
-const body = await fetch(url).then((res) => res.text());
-const manifest = await parse(body, url);
-
-for (const track of manifest.tracks.all) {
-  for (const segment of track.segments) {
-    const content = await fetch(url).then((res) => res.arrayBuffer());
-    await fs.appendFile(`${track.id}.mp4`, content);
+const streamExtractor = new StreamExtractor();
+await streamExtractor.loadSourceFromUrl(url);
+const streams = await streamExtractor.extractStreams();
+
+for (const stream of streams) {
+  const segments = stream.playlist?.mediaParts[0].mediaSegments || [];
+  const filename = `${stream.name}_${stream.groupId}`;
+  for (const segment of segments) {
+    const content = await fetch(segment.url).then((res) => res.arrayBuffer());
+    await fs.appendFile(`${filename}.${stream.extension}`, content);
   }
 }
 ```

package/dist/dasha.cjs

@@ -1,4 +1,3 @@
-"use strict";
 //#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -22,13 +21,22 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-const node_fs = __toESM(require("node:fs"));
-const node_fs_promises = __toESM(require("node:fs/promises"));
-const node_url = __toESM(require("node:url"));
-const node_path = __toESM(require("node:path"));
-const temporal_polyfill = __toESM(require("temporal-polyfill"));
-const __xmldom_xmldom = __toESM(require("@xmldom/xmldom"));
-const node_crypto = __toESM(require("node:crypto"));
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let barsic = require("barsic");
+barsic = __toESM(barsic);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let node_url = require("node:url");
+node_url = __toESM(node_url);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let temporal_polyfill = require("temporal-polyfill");
+temporal_polyfill = __toESM(temporal_polyfill);
+let __xmldom_xmldom = require("@xmldom/xmldom");
+__xmldom_xmldom = __toESM(__xmldom_xmldom);
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto);
 
 //#region lib/shared/media-type.ts
 const MEDIA_TYPES = {
@@ -41,14 +49,14 @@ const MEDIA_TYPES = {
 //#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
+	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
@@ -76,22 +84,38 @@ const ROLE_TYPE = {
 };
 
 //#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;
+//#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
+var DefaultDashContentProcessor = class {
+	canProcess(extractorType, mpdContent) {
+		if (extractorType !== EXTRACTOR_TYPES.MPEG_DASH) return false;
+		return mpdContent.includes("<mas:") && !mpdContent.includes("xmlns:mas");
+	}
+	process(mpdContent) {
+		console.debug("Fix xigua mpd...");
+		mpdContent = mpdContent.replace("<MPD ", "<MPD xmlns:mas=\"urn:marlin:mas:1-0:services:schemas:mpd\" ");
+		return mpdContent;
+	}
 };
 
 //#endregion
@@ -125,6 +149,138 @@ const HLS_TAGS = {
 	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/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/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 = barsic.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 = barsic.b.base64().encode(uri.slice(7));
+				else if (lowerUri.startsWith("data:;base64,")) encryptInfo.key = barsic.b.base64().encode(uri.slice(13));
+				else if (lowerUri.startsWith("data:text/plain;base64,")) encryptInfo.key = barsic.b.base64().encode(uri.slice(23));
+				else if ((0, node_fs.existsSync)(uri)) encryptInfo.key = (0, node_fs.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/shared/stream-spec.ts
 var StreamSpec = class {
@@ -211,8 +367,7 @@ const DASH_TAGS = {
 const combineUrl = (baseUrl, relativeUrl) => {
 	if (!baseUrl.trim()) return relativeUrl;
 	const url1 = new URL(baseUrl);
-	const url2 = new URL(relativeUrl, url1);
-	return url2.toString();
+	return new URL(relativeUrl, url1).toString();
 };
 const replaceVars = (text, dict) => {
 	let result = text;
@@ -251,7 +406,7 @@ const getAttribute = (line, key = "") => {
 	return result;
 };
 const distinctBy = (array, callbackfn) => {
-	const seen = new Set();
+	const seen = /* @__PURE__ */ new Set();
 	return array.filter((item) => {
 		const value = callbackfn(item);
 		if (seen.has(value)) return false;
@@ -285,21 +440,6 @@ var MediaPart = class {
 	}
 };
 
-//#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 {
@@ -345,8 +485,7 @@ var MediaSegment = class MediaSegment {
 */
 const parseRange = (range) => {
 	const [startRange, end] = range.split("-").map(Number);
-	const expectLength = end - startRange + 1;
-	return [startRange, expectLength];
+	return [startRange, end - startRange + 1];
 };
 
 //#endregion
@@ -382,11 +521,9 @@ var DashExtractor = class DashExtractor {
 	async extractStreams(rawText) {
 		const streamList = [];
 		this.#mpdContent = rawText;
-		const document = new __xmldom_xmldom.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 mpdElement = new __xmldom_xmldom.DOMParser().parseFromString(this.#mpdContent, "text/xml").getElementsByTagName("MPD")[0];
+		const isLive = mpdElement.getAttribute("type") === "dynamic";
+		mpdElement.getAttribute("maxSegmentDuration");
 		const availabilityStartTime = mpdElement.getAttribute("availabilityStartTime");
 		const timeShiftBufferDepth = mpdElement.getAttribute("timeShiftBufferDepth") || "PT1M";
 		const publishTime = mpdElement.getAttribute("publishTime");
@@ -445,8 +582,7 @@ var DashExtractor = class DashExtractor {
 					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];
+						const roleType = ROLE_TYPE[roleValue.split("-").map(capitalize).join("")];
 						streamSpec.role = roleType;
 						if (roleType === ROLE_TYPE.Subtitle) {
 							streamSpec.mediaType = MEDIA_TYPES.SUBTITLES;
@@ -577,8 +713,7 @@ var DashExtractor = class DashExtractor {
 									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.url = combineUrl(segBaseUrl, _media);
 									_mediaSegment.index = segIndex++;
 									_mediaSegment.duration = _duration / timescale;
 									if (_hashTime) _mediaSegment.nameFromVar = currentTime.toString();
@@ -622,27 +757,37 @@ var DashExtractor = class DashExtractor {
 						mediaSegment.duration = periodDurationSeconds;
 						streamSpec.playlist.mediaParts[0].mediaSegments.push(mediaSegment);
 					}
-					const contentProtection = adaptationSet.getElementsByTagName("ContentProtection")[0] || representation.getElementsByTagName("ContentProtection")[0];
-					if (contentProtection) {
+					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 (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);
-					}
+					if (_index > -1) if (isLive) {} else if (streamList[_index].playlist.mediaParts.at(-1).mediaSegments.at(-1).url !== streamSpec.playlist.mediaParts[0].mediaSegments.at(-1)?.url) {
+						const startIndex = streamList[_index].playlist.mediaParts.at(-1).mediaSegments.at(-1).index + 1;
+						const segments = streamSpec.playlist.mediaParts[0].mediaSegments;
+						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";
@@ -657,8 +802,8 @@ var DashExtractor = class DashExtractor {
 		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;
+			const audioGroupId = audioList.toSorted((a, b$1) => (b$1.bandwidth || 0) - (a.bandwidth || 0)).at(0)?.groupId;
+			const subtitleGroupId = subtitleList.toSorted((a, b$1) => (b$1.bandwidth || 0) - (a.bandwidth || 0)).at(0)?.groupId;
 			if (audioGroupId) video.audioId = audioGroupId;
 			if (subtitleGroupId) video.subtitleId = subtitleGroupId;
 		}
@@ -668,17 +813,38 @@ var DashExtractor = class DashExtractor {
 		if (!v) return;
 		return v;
 	}
-	fetchPlayList(streamSpecs) {
-		throw new Error("Method not implemented.");
+	async refreshPlayList(streamSpecs) {
+		if (!streamSpecs.length) return;
+		const response = await fetch(this.#parserConfig.url, this.#parserConfig.headers).catch(() => fetch(this.#parserConfig.originalUrl, this.#parserConfig.headers));
+		const rawText = await response.text();
+		const url = response.url;
+		this.#parserConfig.url = url;
+		this.#setInitUrl();
+		const newStreams = await this.extractStreams(rawText);
+		for (const streamSpec of streamSpecs) {
+			let results = newStreams.filter((n) => n.toShortString() === streamSpec.toShortString());
+			if (!results.length) results = newStreams.filter((n) => n.playlist?.mediaInit?.url === streamSpec.playlist?.mediaInit?.url);
+			if (results.length) streamSpec.playlist.mediaParts = results.at(0).playlist.mediaParts;
+		}
+		await this.#processUrl(streamSpecs);
+	}
+	async #processUrl(streamSpecs) {
+		for (const spec of streamSpecs) {
+			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);
+		}
 	}
-	refreshPlayList(streamSpecs) {
-		throw new Error("Method not implemented.");
+	async fetchPlayList(streamSpecs) {
+		this.#processUrl(streamSpecs);
 	}
 	preProcessUrl(url) {
-		throw new Error("Method not implemented.");
+		for (const processor of this.#parserConfig.urlProcessors) if (processor.canProcess(this.extractorType, url, this.#parserConfig)) url = processor.process(url, this.#parserConfig);
+		return url;
 	}
 	preProcessContent() {
-		throw new Error("Method not implemented.");
+		for (const processor of this.#parserConfig.contentProcessors) if (processor.canProcess(this.extractorType, this.#mpdContent, this.#parserConfig)) this.#mpdContent = processor.process(this.#mpdContent, this.#parserConfig);
 	}
 };
 
@@ -757,8 +923,7 @@ var HlsExtractor = class {
 				expectPlaylist = true;
 			} else if (line.startsWith(HLS_TAGS.extXMedia)) {
 				streamSpec = new StreamSpec();
-				const type = getAttribute(line, "TYPE").replace("-", "_");
-				const mediaType = MEDIA_TYPES[type];
+				const mediaType = MEDIA_TYPES[getAttribute(line, "TYPE").replace("-", "_")];
 				if (mediaType) streamSpec.mediaType = mediaType;
 				if (mediaType === MEDIA_TYPES.CLOSED_CAPTIONS) continue;
 				let url = getAttribute(line, "URI");
@@ -809,8 +974,7 @@ var HlsExtractor = class {
 		for (const line of lines) {
 			if (!line.trim()) continue;
 			if (line.startsWith(HLS_TAGS.extXByterange)) {
-				const p = getAttribute(line);
-				const [n, o] = getRange(p);
+				const [n, o] = getRange(getAttribute(line));
 				segment.expectLength = n;
 				segment.startRange = o || (segments.at(-1)?.startRange || 0) + (segments.at(-1)?.expectLength || 0);
 				expectSegment = true;
@@ -832,10 +996,8 @@ var HlsExtractor = class {
 				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);
+				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;
@@ -862,8 +1024,7 @@ var HlsExtractor = class {
 				mediaSegment.index = -1;
 				playlist.mediaInit = mediaSegment;
 				if (line.includes("BYTERANGE")) {
-					const p = getAttribute(line, "BYTERANGE");
-					const [n, o] = getRange(p);
+					const [n, o] = getRange(getAttribute(line, "BYTERANGE"));
 					mediaSegment.expectLength = n;
 					mediaSegment.startRange = o || 0;
 				}
@@ -905,17 +1066,14 @@ var HlsExtractor = class {
 		if (playlist.isLive) playlist.refreshIntervalMs = (playlist.targetDuration || 5) * 2 * 1e3;
 		return playlist;
 	}
-	#parseKey(keyLine) {
+	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)) {
-			console.log("Master m3u8 found");
-			return this.#parseMasterList().then((lists) => distinctBy(lists, (list) => list.url));
-		}
+		if (this.#m3u8Content.includes(HLS_TAGS.extXStreamInf)) return this.#parseMasterList().then((lists) => distinctBy(lists, (list) => list.url));
 		const playlist = await this.#parseList();
 		const streamSpec = new StreamSpec();
 		streamSpec.url = this.parserConfig.url;
@@ -925,8 +1083,7 @@ var HlsExtractor = class {
 	}
 	async #loadM3u8FromUrl(url) {
 		if (url.startsWith("file:")) {
-			const uri = new URL(url);
-			const filePath = uri.pathname;
+			const filePath = new URL(url).pathname;
 			this.#m3u8Content = await (0, node_fs_promises.readFile)(filePath, "utf8");
 		} else if (url.startsWith("http")) try {
 			const response = await fetch(url, { headers: this.parserConfig.headers });
@@ -966,9 +1123,9 @@ var HlsExtractor = class {
 			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")));
+				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) list.extension = "vtt";
+				if (b$1) list.extension = "vtt";
 			} else list.extension = list.playlist.mediaInit ? "m4s" : "ts";
 		}
 	}
@@ -996,8 +1153,7 @@ var StreamExtractor = class {
 	}
 	async loadSourceFromUrl(url) {
 		if (url.startsWith("file:")) {
-			const uri = new URL(url);
-			const filePath = uri.pathname;
+			const filePath = new URL(url).pathname;
 			this.#rawText = await (0, node_fs_promises.readFile)(filePath, "utf8");
 			this.#setUrl(url);
 		} else if (url.startsWith("http")) {
@@ -1024,8 +1180,11 @@ var StreamExtractor = class {
 		} 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");
+		} 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() {
@@ -1040,9 +1199,10 @@ var StreamExtractor = class {
 };
 
 //#endregion
-exports.ENCRYPT_METHODS = ENCRYPT_METHODS
-exports.EXTRACTOR_TYPES = EXTRACTOR_TYPES
-exports.MEDIA_TYPES = MEDIA_TYPES
-exports.ParserConfig = ParserConfig
-exports.ROLE_TYPE = ROLE_TYPE
-exports.StreamExtractor = StreamExtractor
+exports.DefaultUrlProcessor = DefaultUrlProcessor;
+exports.ENCRYPT_METHODS = ENCRYPT_METHODS;
+exports.EXTRACTOR_TYPES = EXTRACTOR_TYPES;
+exports.MEDIA_TYPES = MEDIA_TYPES;
+exports.ParserConfig = ParserConfig;
+exports.ROLE_TYPE = ROLE_TYPE;
+exports.StreamExtractor = StreamExtractor;