dasha 4.0.0-alpha.2 → 4.0.0-alpha.4

package/dist/{dasha.js → dasha.mjs}

@@ -1,30 +1,39 @@
+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";
-import crypto from "node:crypto";
 
-//#region lib/shared/media-type.ts
-const MEDIA_TYPES = {
-	VIDEO: "video",
-	AUDIO: "audio",
-	SUBTITLES: "subtitle",
-	CLOSED_CAPTIONS: "closed-captions"
+//#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-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
+//#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
@@ -36,6 +45,132 @@ const EXTRACTOR_TYPES = {
 	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/media-type.ts
+const MEDIA_TYPES = {
+	VIDEO: "video",
+	AUDIO: "audio",
+	SUBTITLES: "subtitle",
+	CLOSED_CAPTIONS: "closed-captions"
+};
+
+//#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/shared/role-type.ts
 const ROLE_TYPE = {
@@ -53,17 +188,13 @@ const ROLE_TYPE = {
 
 //#endregion
 //#region lib/processor.ts
-var ContentProcessor = class {};
-var KeyProcessor = class {};
-var UrlProcessor = class {};
-var DefaultUrlProcessor = class extends UrlProcessor {
+var DefaultUrlProcessor = class {
 	canProcess(_extractorType, _originalUrl, parserConfig) {
 		return parserConfig.appendUrlParams;
 	}
 	process(url, parserConfig) {
 		if (!url.startsWith("http")) return url;
-		const urlFromConfig = new URL(parserConfig.url);
-		const urlFromConfigQuery = urlFromConfig.searchParams;
+		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);
@@ -78,7 +209,7 @@ var DefaultUrlProcessor = class extends UrlProcessor {
 
 //#endregion
 //#region lib/dash/dash-content-processor.ts
-var DefaultDashContentProcessor = class extends ContentProcessor {
+var DefaultDashContentProcessor = class {
 	canProcess(extractorType, mpdContent) {
 		if (extractorType !== EXTRACTOR_TYPES.MPEG_DASH) return false;
 		return mpdContent.includes("<mas:") && !mpdContent.includes("xmlns:mas");
@@ -123,7 +254,7 @@ const HLS_TAGS = {
 
 //#endregion
 //#region lib/hls/hls-content-processor.ts
-var DefaultHlsContentProcessor = class DefaultHlsContentProcessor extends ContentProcessor {
+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/;
@@ -156,24 +287,9 @@ var DefaultHlsContentProcessor = class DefaultHlsContentProcessor extends Conten
 	}
 };
 
-//#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) return ENCRYPT_METHODS[method.replace("-", "_")];
-		else return ENCRYPT_METHODS.UNKNOWN;
-	}
-};
-
 //#endregion
 //#region lib/hls/hls-key-processor.ts
-var DefaultHlsKeyProcessor = class extends KeyProcessor {
+var DefaultHlsKeyProcessor = class {
 	canProcess(extractorType) {
 		return extractorType === EXTRACTOR_TYPES.HLS;
 	}
@@ -181,17 +297,16 @@ var DefaultHlsKeyProcessor = class extends KeyProcessor {
 		const iv = this.getAttribute(keyLine, "IV");
 		const method = this.getAttribute(keyLine, "METHOD");
 		const uri = this.getAttribute(keyLine, "URI");
-		console.debug(`METHOD:${method}, URI:${uri}, IV:${iv}`);
 		const encryptInfo = new EncryptInfo(method);
-		if (iv) encryptInfo.iv = Buffer.from(iv, "hex");
+		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 = Buffer.from(uri.slice(7), "base64");
-				else if (lowerUri.startsWith("data:;base64,")) encryptInfo.key = Buffer.from(uri.slice(13), "base64");
-				else if (lowerUri.startsWith("data:text/plain;base64,")) encryptInfo.key = Buffer.from(uri.slice(23), "base64");
+				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);
@@ -209,15 +324,15 @@ var DefaultHlsKeyProcessor = class extends KeyProcessor {
 		return encryptInfo;
 	}
 	getAttribute(line, attrName) {
-		const regex = new RegExp(`${attrName}="([^"]+)"`, "i");
+		const regex = new RegExp(`${attrName}=(?:"([^"]+)"|([^,]+))`, "i");
 		const match = line.match(regex);
-		return match?.[1] ?? null;
+		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 Buffer.from(await response.arrayBuffer());
+			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}`);
@@ -252,78 +367,6 @@ var ParserConfig = class {
 	keyRetryCount = 3;
 };
 
-//#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 = {
@@ -338,8 +381,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;
@@ -378,7 +420,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;
@@ -403,51 +445,6 @@ var Playlist = class {
 	mediaParts = [];
 };
 
-//#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/dash/dash-utils.ts
 /**
@@ -457,8 +454,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
@@ -494,11 +490,9 @@ var DashExtractor = class DashExtractor {
 	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 mpdElement = new 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");
@@ -557,8 +551,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;
@@ -689,8 +682,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();
@@ -734,27 +726,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";
@@ -769,8 +771,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;
 		}
@@ -780,17 +782,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);
 	}
-	refreshPlayList(streamSpecs) {
-		throw new Error("Method not implemented.");
+	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);
+		}
+	}
+	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);
 	}
 };
 
@@ -869,8 +892,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");
@@ -921,8 +943,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;
@@ -944,9 +965,7 @@ 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) {
+				if (getAttribute(line, "URI") !== getAttribute(lastKeyLine, "URI")) {
 					const parsedInfo = await this.#parseKey(line);
 					currentEncryptInfo.method = parsedInfo.method;
 					currentEncryptInfo.key = parsedInfo.key;
@@ -974,8 +993,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;
 				}
@@ -1024,10 +1042,7 @@ var HlsExtractor = class {
 	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;
@@ -1037,8 +1052,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 readFile(filePath, "utf8");
 		} else if (url.startsWith("http")) try {
 			const response = await fetch(url, { headers: this.parserConfig.headers });
@@ -1078,9 +1092,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";
 		}
 	}
@@ -1108,8 +1122,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 readFile(filePath, "utf8");
 			this.#setUrl(url);
 		} else if (url.startsWith("http")) {
@@ -1136,8 +1149,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() {
@@ -1152,4 +1168,4 @@ var StreamExtractor = class {
 };
 
 //#endregion
-export { ContentProcessor, DefaultUrlProcessor, ENCRYPT_METHODS, EXTRACTOR_TYPES, KeyProcessor, MEDIA_TYPES, ParserConfig, ROLE_TYPE, StreamExtractor, UrlProcessor };
+export { DASH_TAGS, DashExtractor, DefaultDashContentProcessor, DefaultHlsContentProcessor, DefaultHlsKeyProcessor, DefaultUrlProcessor, ENCRYPT_METHODS, EXTRACTOR_TYPES, EncryptInfo, HLS_TAGS, HlsExtractor, MEDIA_TYPES, MediaPart, MediaSegment, ParserConfig, ROLE_TYPE, StreamExtractor, StreamSpec, getRange, parseRange };