dasha 4.0.0-alpha.14 → 4.0.0-alpha.15

package/dist/index.d.mts

@@ -449,6 +449,7 @@ declare const DASH_FORMATS: InputFormat[];
 //#region src/mediabunny-input.d.ts
 declare module 'mediabunny' {
   interface Input<S extends Source = Source> {
+    _getTrackBackings(): Promise<unknown[]>;
     _wrapBackingAsTrack(backing: unknown): InputTrack$2;
   }
 }
@@ -460,6 +461,7 @@ type MediabunnyTrackWithSegments = InputTrack$2 & SegmentAccessMethods;
 type MediabunnyVideoTrackWithSegments = InputVideoTrack$1 & SegmentAccessMethods;
 type MediabunnyAudioTrackWithSegments = InputAudioTrack$1 & SegmentAccessMethods;
 type TrackBacking = Parameters<Input$1<Source>['_wrapBackingAsTrack']>[0];
+declare const preserveSubtitleBackingsOnInput: (input: Input$1) => Input$1<Source>;
 declare class SegmentedMediabunnyInput<S extends Source = Source> extends Input$1<S> {
   #private;
   _wrapBackingAsTrack(backing: TrackBacking): MediabunnyTrackWithSegments;
@@ -486,4 +488,4 @@ declare const isInput: (value: unknown) => value is Input;
 declare const getSegmentedInput: (track: InputTrack$1) => InputSegmentedInput;
 declare const getSegments: (track: InputTrack$1) => Promise<InputSegment[]>;
 //#endregion
-export { DASH, DASH_FORMATS, type DashSegment, type DashSegmentedInput, FilePathSource, HLS_FORMATS, type HlsSegment, type HlsSegmentedInput, Input, InputAudioTrack, InputSegment, InputSegmentedInput, InputTrack$1 as InputTrack, type InputTrackQuery, type InputTrackWithBacking, InputVideoTrack, UrlSource, asc, desc, getSegmentedInput, getSegments, isInput, prefer };
+export { DASH, DASH_FORMATS, type DashSegment, type DashSegmentedInput, FilePathSource, HLS_FORMATS, type HlsSegment, type HlsSegmentedInput, Input, InputAudioTrack, InputSegment, InputSegmentedInput, InputTrack$1 as InputTrack, type InputTrackQuery, type InputTrackWithBacking, InputVideoTrack, UrlSource, asc, desc, getSegmentedInput, getSegments, isInput, prefer, preserveSubtitleBackingsOnInput };

package/dist/index.mjs

@@ -414,6 +414,153 @@ const parseDashRange = (range) => {
 	return [startRange, end - startRange + 1];
 };
 //#endregion
+//#region src/mediabunny-input.ts
+const requireSync = (value, getterName, asyncName) => {
+	if (value instanceof Promise) throw new Error(`'${getterName}' is not available synchronously for this track. Use '${asyncName}()' instead.`);
+	return value;
+};
+const queryTracks = async (tracks, query) => {
+	let matched = tracks;
+	if (query?.filter) {
+		const filterMatches = tracks.map((track) => query.filter(track));
+		const resolvedFilterMatches = await Promise.all(filterMatches);
+		matched = tracks.filter((_, index) => resolvedFilterMatches[index]);
+	}
+	if (!query?.sortBy) return matched;
+	const resolvedSortValues = await Promise.all(matched.map((track) => query.sortBy(track)));
+	return matched.map((track, index) => ({
+		track,
+		sortValue: resolvedSortValues[index]
+	})).sort((left, right) => {
+		const leftValues = Array.isArray(left.sortValue) ? left.sortValue : [left.sortValue];
+		const rightValues = Array.isArray(right.sortValue) ? right.sortValue : [right.sortValue];
+		const maxLength = Math.max(leftValues.length, rightValues.length);
+		for (let index = 0; index < maxLength; index++) {
+			const leftValue = leftValues[index] ?? 0;
+			const rightValue = rightValues[index] ?? 0;
+			if (leftValue === rightValue) continue;
+			return leftValue - rightValue;
+		}
+		return 0;
+	}).map(({ track }) => track);
+};
+const BACKING_TYPE_SUBTITLE = "subtitle";
+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 getBackingType = (backing) => backing.getType?.();
+const queryWrappedTracks = (input, backings, query) => {
+	return queryTracks(backings.map((backing) => input._wrapBackingAsTrack(backing)), query);
+};
+const getTrackBackingsByType = async (input, type) => {
+	const backings = await input._getTrackBackings();
+	if (!type) return backings;
+	return backings.filter((backing) => getBackingType(backing) === type);
+};
+const patchBaseMediabunnyInput = () => {
+	const prototype = Input$1.prototype;
+	if (prototype[BASE_INPUT_PATCHED]) return;
+	prototype.getTracks = function(query) {
+		return getTrackBackingsByType(this).then((backings) => queryWrappedTracks(this, this[PRESERVE_SUBTITLE_BACKINGS] ? backings : backings.filter((backing) => getBackingType(backing) !== BACKING_TYPE_SUBTITLE), query));
+	};
+	prototype.getAudioTracks = function(query) {
+		return getTrackBackingsByType(this, BACKING_TYPE_AUDIO).then((backings) => queryWrappedTracks(this, backings, query));
+	};
+	prototype[BASE_INPUT_PATCHED] = true;
+};
+const getSegmentedInputForTrack = (track) => {
+	const backing = track._backing;
+	if ("getSegmentedInput" in backing && typeof backing.getSegmentedInput === "function") return backing.getSegmentedInput();
+	const internalTrack = backing.internalTrack;
+	return internalTrack.demuxer.getSegmentedInputForPath(internalTrack.fullPath);
+};
+const addSegmentAccess = (track) => new Proxy(track, { get(target, prop) {
+	if (prop === "getSegmentedInput") return () => getSegmentedInputForTrack(target);
+	if (prop === "getSegments") return async () => {
+		const segmentedInput = getSegmentedInputForTrack(target);
+		await segmentedInput.runUpdateSegments();
+		return segmentedInput.segments;
+	};
+	const value = Reflect.get(target, prop, target);
+	return typeof value === "function" ? value.bind(target) : value;
+} });
+var MediabunnyInputSubtitleTrack = class extends InputTrack {
+	#backing;
+	constructor(input, backing) {
+		super();
+		Object.assign(this, {
+			input,
+			_backing: backing
+		});
+		this.#backing = backing;
+	}
+	get type() {
+		return "subtitle";
+	}
+	async getCodec() {
+		return this.#backing.getCodec();
+	}
+	get codec() {
+		return requireSync(this.#backing.getCodec(), "codec", "getCodec");
+	}
+	async getCodecParameterString() {
+		return await this.#backing.getMetadataCodecParameterString?.() ?? null;
+	}
+	async canDecode() {
+		return true;
+	}
+	async determinePacketType(_packet) {
+		return null;
+	}
+	async hasOnlyKeyPackets() {
+		return true;
+	}
+};
+patchBaseMediabunnyInput();
+const preserveSubtitleBackingsOnInput = (input) => {
+	Object.assign(input, { [PRESERVE_SUBTITLE_BACKINGS]: true });
+	return input;
+};
+var SegmentedMediabunnyInput = class extends Input$1 {
+	#trackCache = /* @__PURE__ */ new WeakMap();
+	#subtitleTrackCache = /* @__PURE__ */ new WeakMap();
+	async #queryTracks(query, type) {
+		const backings = await getTrackBackingsByType(this, type);
+		return queryWrappedTracks(this, backings, query);
+	}
+	_wrapBackingAsTrack(backing) {
+		const track = backing.getType?.() === "subtitle" ? this.#wrapSubtitleBacking(backing) : super._wrapBackingAsTrack(backing);
+		const existing = this.#trackCache.get(track);
+		if (existing) return existing;
+		const wrapped = addSegmentAccess(track);
+		this.#trackCache.set(track, wrapped);
+		return wrapped;
+	}
+	#wrapSubtitleBacking(backing) {
+		const existing = this.#subtitleTrackCache.get(backing);
+		if (existing) return existing;
+		const track = new MediabunnyInputSubtitleTrack(this, backing);
+		this.#subtitleTrackCache.set(backing, track);
+		return track;
+	}
+	async getTracks(query) {
+		return await this.#queryTracks(query);
+	}
+	async getVideoTracks(query) {
+		return await this.#queryTracks(query, BACKING_TYPE_VIDEO);
+	}
+	async getAudioTracks(query) {
+		return await this.#queryTracks(query, BACKING_TYPE_AUDIO);
+	}
+	async getPrimaryVideoTrack(query) {
+		return await super.getPrimaryVideoTrack(query);
+	}
+	async getPrimaryAudioTrack(query) {
+		return await super.getPrimaryAudioTrack(query);
+	}
+};
+//#endregion
 //#region src/dash/dash-segmented-input.ts
 const roundToDivisor = (value, multiple) => Math.round(value * multiple) / multiple;
 const binarySearchLessOrEqual = (array, value, getValue) => {
@@ -576,7 +723,7 @@ var DashSegmentedInput = class {
 		let initInput = null;
 		if (segment.initSegment && segment.initSegment !== segment) initInput = this.getInputForSegment(segment.initSegment);
 		const formatOptions = { ...input._formatOptions };
-		const segmentInput = new Input$1({
+		const segmentInput = preserveSubtitleBackingsOnInput(new Input$1({
 			source: new CustomPathedSource(segment.location.path, async (request) => {
 				if (!request.isRoot) throw new Error("Nested requests are not supported for DASH segments.");
 				const proxiedRequest = {
@@ -594,7 +741,7 @@ var DashSegmentedInput = class {
 			formats: input._formats.filter((format) => format.mimeType !== DASH_MIME_TYPE),
 			initInput: initInput ?? void 0,
 			formatOptions
-		});
+		}));
 		this.inputCache.push({
 			age: this.nextInputCacheAge++,
 			input: segmentInput,
@@ -1591,94 +1738,6 @@ const DASH_FORMATS = [
 	ADTS
 ];
 //#endregion
-//#region src/mediabunny-input.ts
-const requireSync = (value, getterName, asyncName) => {
-	if (value instanceof Promise) throw new Error(`'${getterName}' is not available synchronously for this track. Use '${asyncName}()' instead.`);
-	return value;
-};
-const getSegmentedInputForTrack = (track) => {
-	const backing = track._backing;
-	if ("getSegmentedInput" in backing && typeof backing.getSegmentedInput === "function") return backing.getSegmentedInput();
-	const internalTrack = backing.internalTrack;
-	return internalTrack.demuxer.getSegmentedInputForPath(internalTrack.fullPath);
-};
-const addSegmentAccess = (track) => new Proxy(track, { get(target, prop) {
-	if (prop === "getSegmentedInput") return () => getSegmentedInputForTrack(target);
-	if (prop === "getSegments") return async () => {
-		const segmentedInput = getSegmentedInputForTrack(target);
-		await segmentedInput.runUpdateSegments();
-		return segmentedInput.segments;
-	};
-	const value = Reflect.get(target, prop, target);
-	return typeof value === "function" ? value.bind(target) : value;
-} });
-var MediabunnyInputSubtitleTrack = class extends InputTrack {
-	#backing;
-	constructor(input, backing) {
-		super();
-		Object.assign(this, {
-			input,
-			_backing: backing
-		});
-		this.#backing = backing;
-	}
-	get type() {
-		return "subtitle";
-	}
-	async getCodec() {
-		return this.#backing.getCodec();
-	}
-	get codec() {
-		return requireSync(this.#backing.getCodec(), "codec", "getCodec");
-	}
-	async getCodecParameterString() {
-		return await this.#backing.getMetadataCodecParameterString?.() ?? null;
-	}
-	async canDecode() {
-		return true;
-	}
-	async determinePacketType(_packet) {
-		return null;
-	}
-	async hasOnlyKeyPackets() {
-		return true;
-	}
-};
-var SegmentedMediabunnyInput = class extends Input$1 {
-	#trackCache = /* @__PURE__ */ new WeakMap();
-	#subtitleTrackCache = /* @__PURE__ */ new WeakMap();
-	_wrapBackingAsTrack(backing) {
-		const track = backing.getType?.() === "subtitle" ? this.#wrapSubtitleBacking(backing) : super._wrapBackingAsTrack(backing);
-		const existing = this.#trackCache.get(track);
-		if (existing) return existing;
-		const wrapped = addSegmentAccess(track);
-		this.#trackCache.set(track, wrapped);
-		return wrapped;
-	}
-	#wrapSubtitleBacking(backing) {
-		const existing = this.#subtitleTrackCache.get(backing);
-		if (existing) return existing;
-		const track = new MediabunnyInputSubtitleTrack(this, backing);
-		this.#subtitleTrackCache.set(backing, track);
-		return track;
-	}
-	async getTracks(query) {
-		return await super.getTracks(query);
-	}
-	async getVideoTracks(query) {
-		return await super.getVideoTracks(query);
-	}
-	async getAudioTracks(query) {
-		return await super.getAudioTracks(query);
-	}
-	async getPrimaryVideoTrack(query) {
-		return await super.getPrimaryVideoTrack(query);
-	}
-	async getPrimaryAudioTrack(query) {
-		return await super.getPrimaryAudioTrack(query);
-	}
-};
-//#endregion
 //#region src/index.ts
 var Input = class extends SegmentedMediabunnyInput {
 	constructor(options) {
@@ -1689,4 +1748,4 @@ const isInput = (value) => value instanceof Input;
 const getSegmentedInput = (track) => track.getSegmentedInput();
 const getSegments = async (track) => track.getSegments();
 //#endregion
-export { DASH, DASH_FORMATS, FilePathSource, HLS_FORMATS, Input, UrlSource, asc, desc, getSegmentedInput, getSegments, isInput, prefer };
+export { DASH, DASH_FORMATS, FilePathSource, HLS_FORMATS, Input, UrlSource, asc, desc, getSegmentedInput, getSegments, isInput, prefer, preserveSubtitleBackingsOnInput };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dasha",
-  "version": "4.0.0-alpha.14",
+  "version": "4.0.0-alpha.15",
   "description": "Streaming manifest parser",
   "files": [
     "dist"