dasha 4.4.3 → 4.4.5

package/dist/index.d.mts

@@ -183,6 +183,7 @@ type Segment = {
 };
 type DashSegmentLocation = {
   path: string;
+  sourcePath: string;
   offset: number;
   length: number | null;
 };
@@ -360,7 +361,10 @@ declare class DashDemuxer {
   }): void;
   findMatchingTrack(nextTracks: DashParsedTrack[], currentTrack: DashParsedTrack): DashParsedTrack | undefined;
   refreshTracks(tracks: DashParsedTrack[]): Promise<void>;
-  fetchManifest(url: string): Promise<Response>;
+  fetchManifestText(url: string): Promise<{
+    text: string;
+    url: string;
+  }>;
   resetManifestUrls(): void;
 }
 declare abstract class DashTrackBackingBase {

package/dist/index.mjs

@@ -316,6 +316,21 @@ const getDashTrackMatchKey = (track) => JSON.stringify({
 const getSourcePath = (source) => {
 	if ("rootPath" in source && typeof source.rootPath === "string") return source.rootPath;
 };
+const resolvePathedSourceRequest = async (source, request) => {
+	const pathedSource = source;
+	if (typeof pathedSource._resolveRequest !== "function") throw new Error("DASH input currently requires a pathed source such as UrlSource.");
+	return await pathedSource._resolveRequest(request);
+};
+const resolvePathedSourcePath = async (source, request) => {
+	const ref = await resolvePathedSourceRequest(source, request);
+	try {
+		const path = getSourcePath(ref.source);
+		if (!path) throw new Error("DASH segment requests must resolve to a pathed source.");
+		return path;
+	} finally {
+		ref.free();
+	}
+};
 const normalizeHeaders$1 = (headers) => {
 	if (!headers) return {};
 	if (headers instanceof Headers) return Object.fromEntries(headers.entries());
@@ -333,30 +348,45 @@ const getSourceHeaders$1 = (source) => {
 const getSourceFetch = (source) => {
 	return ("_options" in source && source._options && typeof source._options === "object" ? source._options : void 0)?.fetchFn ?? fetch;
 };
+const fetchDashManifest = async (source, url) => {
+	const response = await getSourceFetch(source)(url, { headers: getSourceHeaders$1(source) });
+	if (!response.ok) throw new Error(`Failed to fetch DASH manifest: ${response.status} ${response.statusText} (${response.url})`);
+	return response;
+};
 const parseOriginalUrlFromManifest = (text) => text.match(/<!--\s*URL:\s*([^\n]+?)\s*-->/)?.[1]?.trim();
 const loadDashManifest = async (source) => {
 	const manifestPath = getSourcePath(source);
 	if (!manifestPath) throw new Error("DASH input currently requires a pathed source such as UrlSource.");
-	if (manifestPath.startsWith("http://") || manifestPath.startsWith("https://")) {
-		const response = await getSourceFetch(source)(manifestPath, { headers: getSourceHeaders$1(source) });
-		if (!response.ok) throw new Error(`Failed to fetch DASH manifest: ${response.status} ${response.statusText} (${response.url})`);
-		return {
-			text: await response.text(),
-			url: response.url
-		};
-	}
-	if (manifestPath.startsWith("file:")) {
-		const text = await readFile(new URL(manifestPath), "utf8");
+	const manifestRef = await resolvePathedSourceRequest(source, {
+		path: manifestPath,
+		isRoot: true
+	});
+	const manifestSource = manifestRef.source;
+	const resolvedManifestPath = getSourcePath(manifestSource);
+	try {
+		if (!resolvedManifestPath) throw new Error("DASH manifest requests must resolve to a pathed source.");
+		if (resolvedManifestPath.startsWith("http://") || resolvedManifestPath.startsWith("https://")) {
+			const response = await fetchDashManifest(manifestSource, resolvedManifestPath);
+			return {
+				text: await response.text(),
+				url: response.url || resolvedManifestPath
+			};
+		}
+		if (resolvedManifestPath.startsWith("file:")) {
+			const text = await readFile(new URL(resolvedManifestPath), "utf8");
+			return {
+				text,
+				url: parseOriginalUrlFromManifest(text) ?? resolvedManifestPath
+			};
+		}
+		const text = await readFile(resolvedManifestPath, "utf8");
 		return {
 			text,
-			url: parseOriginalUrlFromManifest(text) ?? manifestPath
+			url: parseOriginalUrlFromManifest(text) ?? resolvedManifestPath
 		};
+	} finally {
+		manifestRef.free();
 	}
-	const text = await readFile(manifestPath, "utf8");
-	return {
-		text,
-		url: parseOriginalUrlFromManifest(text) ?? manifestPath
-	};
 };
 const isLikelyDashPath = (source) => {
 	const path = getSourcePath(source);
@@ -1386,6 +1416,7 @@ const BACKING_TYPE_AUDIO = "audio";
 const BACKING_TYPE_VIDEO = "video";
 const BASE_INPUT_PATCHED = Symbol.for("dasha.base-mediabunny-input-patched");
 const PRESERVE_SUBTITLE_BACKINGS = Symbol.for("dasha.preserve-subtitle-backings");
+const resolvedHlsSegmentLocations = /* @__PURE__ */ new WeakSet();
 const getDefaultAudioTrackFormats = (source) => {
 	return isLikelyDashPath(source instanceof SourceRef ? source.source : source) ? [DASH, ...ALL_FORMATS$1] : [...ALL_FORMATS$1, DASH];
 };
@@ -1549,6 +1580,22 @@ const getSegmentedInputForTrack = (track) => {
 	const internalTrack = backing.internalTrack;
 	return internalTrack.demuxer.getSegmentedInputForPath(internalTrack.fullPath);
 };
+const isHlsSegment = (segment) => !("sourcePath" in segment.location);
+const resolveHlsSegmentLocation = async (source, location) => {
+	if (resolvedHlsSegmentLocations.has(location)) return;
+	location.path = await resolvePathedSourcePath(source, {
+		path: location.path,
+		isRoot: false
+	});
+	resolvedHlsSegmentLocations.add(location);
+};
+const resolveHlsSegments = async (source, segments) => {
+	for (const segment of segments) {
+		if (!isHlsSegment(segment)) continue;
+		if (segment.initSegment) await resolveHlsSegmentLocation(source, segment.initSegment.location);
+		await resolveHlsSegmentLocation(source, segment.location);
+	}
+};
 const getTrackBacking = (track) => track._backing;
 const getTrackSource = (track) => {
 	return getTrackBacking(track).getSource?.() ?? track.input.source;
@@ -1572,11 +1619,13 @@ const addSegmentAccess = (track) => new Proxy(track, { get(target, prop) {
 	if (prop === "getSegments") return async () => {
 		const segmentedInput = getSegmentedInputForTrack(target);
 		if (segmentedInput.segments.length === 0) await segmentedInput.runUpdateSegments();
+		await resolveHlsSegments(getTrackSource(target), segmentedInput.segments);
 		return segmentedInput.segments;
 	};
 	if (prop === "refreshSegments") return async () => {
 		const segmentedInput = getSegmentedInputForTrack(target);
 		await segmentedInput.runUpdateSegments();
+		await resolveHlsSegments(getTrackSource(target), segmentedInput.segments);
 		return segmentedInput.segments;
 	};
 	const value = Reflect.get(target, prop, target);
@@ -1831,23 +1880,27 @@ const getLeastRecentlyUsedIndex = (entries) => {
 	}
 	return bestIndex;
 };
-const getSegmentLocation = (segment) => ({
-	path: segment.url,
+const getSegmentLocation = async (input, segment) => ({
+	path: await resolvePathedSourcePath(input.source, {
+		path: segment.url,
+		isRoot: false
+	}),
+	sourcePath: segment.url,
 	offset: segment.startRange ?? 0,
 	length: segment.expectLength ?? null
 });
-const createInitSegment = (segment) => ({
+const createInitSegment = async (input, segment) => ({
 	timestamp: 0,
 	duration: 0,
 	relativeToUnixEpoch: false,
 	firstSegment: null,
 	sequenceNumber: segment.sequenceNumber,
-	location: getSegmentLocation(segment),
+	location: await getSegmentLocation(input, segment),
 	encryption: segment.encryption,
 	initSegment: null,
 	lastProgramDateTimeSeconds: null
 });
-const trackToDashSegments = (internalTrack) => {
+const trackToDashSegments = async (input, internalTrack) => {
 	const mediaSegments = internalTrack.track.mediaSegments;
 	if (mediaSegments.length === 0) return [];
 	let nextTimestamp = 0;
@@ -1860,7 +1913,7 @@ const trackToDashSegments = (internalTrack) => {
 			relativeToUnixEpoch: false,
 			firstSegment: null,
 			sequenceNumber: mediaSegment.sequenceNumber,
-			location: getSegmentLocation(mediaSegment),
+			location: await getSegmentLocation(input, mediaSegment),
 			encryption: mediaSegment.encryption,
 			initSegment: null,
 			lastProgramDateTimeSeconds: null
@@ -1869,7 +1922,7 @@ const trackToDashSegments = (internalTrack) => {
 		nextTimestamp = timestamp + mediaSegment.duration;
 	}
 	const firstSegment = segments[0] ?? null;
-	const initSegment = internalTrack.track.initSegment ? createInitSegment(internalTrack.track.initSegment) : null;
+	const initSegment = internalTrack.track.initSegment ? await createInitSegment(input, internalTrack.track.initSegment) : null;
 	for (const segment of segments) {
 		segment.firstSegment = firstSegment;
 		segment.initSegment = initSegment;
@@ -1905,8 +1958,9 @@ var DashSegmentedInput = class {
 		})();
 	}
 	async updateSegments() {
+		const input = this.demuxer.input;
 		await this.demuxer.refreshTrackSegments(this.internalTrack);
-		this.segments = trackToDashSegments(this.internalTrack);
+		this.segments = await trackToDashSegments(input, this.internalTrack);
 	}
 	getRemainingWaitTimeMs() {
 		if (!this.internalTrack.track.isLive) return 0;
@@ -1970,7 +2024,7 @@ var DashSegmentedInput = class {
 		if (segment.initSegment && segment.initSegment !== segment) initInput = this.getInputForSegment(segment.initSegment);
 		const formatOptions = { ...input._formatOptions };
 		const segmentInput = preserveSubtitleBackingsOnInput(new Input$1({
-			source: new CustomPathedSource(segment.location.path, async (request) => {
+			source: new CustomPathedSource(segment.location.sourcePath, async (request) => {
 				if (!request.isRoot) throw new Error("Nested requests are not supported for DASH segments.");
 				const proxiedRequest = {
 					...request,
@@ -2764,11 +2818,10 @@ var DashDemuxer = class {
 	}
 	async refreshTracks(tracks) {
 		if (!tracks.length) return;
-		const response = await this.fetchManifest(this.manifestUrl).catch(() => this.fetchManifest(this.originalUrl));
-		const rawText = await response.text();
+		const response = await this.fetchManifestText(this.manifestUrl).catch(() => this.fetchManifestText(this.originalUrl));
 		this.manifestUrl = response.url;
 		this.resetManifestUrls();
-		const nextTracks = this.extractTracks(rawText);
+		const nextTracks = this.extractTracks(response.text);
 		for (const track of tracks) {
 			const nextTrack = this.findMatchingTrack(nextTracks, track);
 			if (!nextTrack) continue;
@@ -2781,10 +2834,23 @@ var DashDemuxer = class {
 			track.subtitleGroupId = nextTrack.subtitleGroupId;
 		}
 	}
-	async fetchManifest(url) {
-		const response = await fetch(url, { headers: this.headers });
-		if (!response.ok) throw new Error(`Failed to fetch DASH manifest: ${response.status} ${response.statusText} (${response.url})`);
-		return response;
+	async fetchManifestText(url) {
+		const manifestRef = await resolvePathedSourceRequest(this.input.source, {
+			path: url,
+			isRoot: true
+		});
+		const manifestSource = manifestRef.source;
+		try {
+			const resolvedUrl = getSourcePath(manifestSource);
+			if (!resolvedUrl) throw new Error("DASH manifest requests must resolve to a pathed source.");
+			const response = await fetchDashManifest(manifestSource, resolvedUrl);
+			return {
+				text: await response.text(),
+				url: response.url || resolvedUrl
+			};
+		} finally {
+			manifestRef.free();
+		}
 	}
 	resetManifestUrls() {
 		this.mpdUrl = this.manifestUrl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dasha",
-  "version": "4.4.3",
+  "version": "4.4.5",
   "description": "Streaming manifest parser",
   "files": [
     "dist"