dasha 4.3.0 → 4.4.0

package/dist/index.d.mts

@@ -1,6 +1,4 @@
-import * as _$mediabunny from "mediabunny";
 import { AudioCodec as AudioCodec$1, DurationMetadataRequestOptions, EncodedPacket, FilePathSource, HLS, HLS_FORMATS, Input as Input$1, InputAudioTrack as InputAudioTrack$1, InputFormat, InputOptions, InputTrack as InputTrack$2, InputTrackQuery, InputTrackQuery as InputTrackQuery$1, InputVideoTrack as InputVideoTrack$1, MP3, MP4, MaybePromise, MediaCodec as MediaCodec$1, MetadataTags, PacketRetrievalOptions, PathedSource, Source, SourceRef, SubtitleCodec as SubtitleCodec$1, TrackDisposition, UrlSource, VideoCodec as VideoCodec$1, asc, desc, prefer } from "mediabunny";
-import * as _$_xmldom_xmldom0 from "@xmldom/xmldom";
 
 //#region src/mediabunny.d.ts
 type Segment$1 = {
@@ -104,7 +102,7 @@ declare const ROLE_TYPE: {
 type RoleType = (typeof ROLE_TYPE)[keyof typeof ROLE_TYPE];
 //#endregion
 //#region src/dash/dash-misc.d.ts
-type Element = _$_xmldom_xmldom0.Element;
+type Element = import('@xmldom/xmldom').Element;
 type DashTrackType = 'video' | 'audio' | 'subtitle';
 type DashEncryptionData = {
   method: string;
@@ -231,7 +229,7 @@ declare class DashSegmentedInput {
   firstTrackPromise: Promise<TrackWithBacking> | null;
   packetInfos: WeakMap<EncodedPacket, PacketInfo>;
   firstSegmentFirstTimestamps: WeakMap<DashSegment, number>;
-  firstTimestampCache: WeakMap<Input$1<_$mediabunny.Source>, number>;
+  firstTimestampCache: WeakMap<Input$1<import("mediabunny").Source>, number>;
   constructor(internalTrack: DashInternalTrack);
   runUpdateSegments(): Promise<void>;
   updateSegments(): Promise<void>;
@@ -396,6 +394,7 @@ declare abstract class DashTrackBackingBase {
   getNextKeyPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
   getSegmentedInput(): DashSegmentedInput;
   getSegments(): Promise<DashSegment[]>;
+  refreshSegments(): Promise<DashSegment[]>;
 }
 declare class DashInputVideoTrackBacking extends DashTrackBackingBase {
   internalTrack: InternalVideoTrack;
@@ -557,6 +556,7 @@ declare module 'mediabunny' {
 type SegmentAccessMethods = {
   getSegmentedInput(): HlsSegmentedInput | DashSegmentedInput;
   getSegments(): Promise<(HlsSegment | DashSegment)[]>;
+  refreshSegments(): Promise<(HlsSegment | DashSegment)[]>;
 };
 type TrackMetadataOverrideMethods = {
   setLanguageCode(value: string): void;
@@ -580,6 +580,14 @@ type InputSubtitleTrackMetadata = {
   name?: string | null;
   pairWith?: InputVideoTrack | Iterable<InputVideoTrack>;
 };
+type InputAudioSource = Source | SourceRef<Source>;
+type InputAudioTrackPairing = InputVideoTrack | Iterable<InputVideoTrack> | 'all' | 'primary' | false;
+type InputAudioTracksOptions = {
+  filter?: InputTrackQuery$1<InputAudioTrack>['filter'];
+  formats?: readonly InputFormat[];
+  pairWith?: InputAudioTrackPairing;
+  sortBy?: InputTrackQuery$1<InputAudioTrack>['sortBy'];
+};
 type SegmentableBacking = {
   getId(): number;
   getNumber(): number;
@@ -605,11 +613,46 @@ type TrackBacking = NativeTrackBacking | SegmentableBacking;
 declare const BACKING_TYPE_SUBTITLE = "subtitle";
 declare const BACKING_TYPE_AUDIO = "audio";
 declare const BACKING_TYPE_VIDEO = "video";
+declare class ImportedAudioTrackBacking {
+  #private;
+  constructor(params: {
+    backing: SegmentableBacking;
+    id: number;
+    number: number;
+    source: Source;
+  });
+  getType(): string;
+  getId(): number;
+  getNumber(): number;
+  getCodec(): MediaCodec$1 | Promise<MediaCodec$1 | null> | null;
+  getInternalCodecId(): string | number | Uint8Array<ArrayBufferLike> | Promise<string | number | Uint8Array<ArrayBufferLike> | null> | null;
+  getName(): string | Promise<string | null> | null;
+  getLanguageCode(): string | Promise<string>;
+  getTimeResolution(): number | Promise<number>;
+  isRelativeToUnixEpoch(): boolean | Promise<boolean>;
+  getDisposition(): {};
+  getPairingMask(): bigint;
+  getBitrate(): number | Promise<number | null> | null;
+  getAverageBitrate(): number | Promise<number | null> | null;
+  getDurationFromMetadata(options: unknown): Promise<number | null>;
+  getLiveRefreshInterval(): Promise<number | null>;
+  getHasOnlyKeyPackets(): boolean;
+  getDecoderConfig(): Promise<VideoDecoderConfig | AudioDecoderConfig | null>;
+  getMetadataCodecParameterString(): string | Promise<string | null> | null;
+  getNumberOfChannels(): number | Promise<number>;
+  getSampleRate(): number | Promise<number>;
+  getFirstPacket(options: unknown): Promise<EncodedPacket | null>;
+  getPacket(timestamp: number, options: unknown): Promise<EncodedPacket | null>;
+  getNextPacket(packet: EncodedPacket, options: unknown): Promise<EncodedPacket | null>;
+  getKeyPacket(timestamp: number, options: unknown): Promise<EncodedPacket | null>;
+  getNextKeyPacket(packet: EncodedPacket, options: unknown): Promise<EncodedPacket | null>;
+  getSegmentedInput(): any;
+}
 declare const preserveSubtitleBackingsOnInput: (input: Input$1) => Input$1<Source>;
 declare class SegmentedMediabunnyInput<S extends Source = Source> extends Input$1<S> {
   #private;
   _wrapBackingAsTrack(backing: TrackBacking): InputTrack$1;
-  _getSyntheticTrackBackings(type?: typeof BACKING_TYPE_VIDEO | typeof BACKING_TYPE_AUDIO | typeof BACKING_TYPE_SUBTITLE): Promise<(ExternalSubtitleTrackBacking | HlsSubtitleTrackBacking)[]>;
+  _getSyntheticTrackBackings(type?: typeof BACKING_TYPE_VIDEO | typeof BACKING_TYPE_AUDIO | typeof BACKING_TYPE_SUBTITLE): Promise<(ImportedAudioTrackBacking | ExternalSubtitleTrackBacking | HlsSubtitleTrackBacking)[]>;
   getTracks(query?: InputTrackQuery$1<InputTrack$1>): Promise<InputTrack$1[]>;
   getVideoTracks(query?: InputTrackQuery$1<InputVideoTrack>): Promise<InputVideoTrack[]>;
   getAudioTracks(query?: InputTrackQuery$1<InputAudioTrack>): Promise<InputAudioTrack[]>;
@@ -617,6 +660,8 @@ declare class SegmentedMediabunnyInput<S extends Source = Source> extends Input$
   getPrimaryVideoTrack(query?: InputTrackQuery$1<InputVideoTrack>): Promise<InputVideoTrack | null>;
   getPrimaryAudioTrack(query?: InputTrackQuery$1<InputAudioTrack>): Promise<InputAudioTrack | null>;
   addSubtitleTrack(source: InputSubtitleSource, metadata?: InputSubtitleTrackMetadata): InputSubtitleTrack;
+  addAudioTracks(source: InputAudioSource, options?: InputAudioTracksOptions): Promise<InputAudioTrack[]>;
+  dispose(): void;
 }
 //#endregion
 //#region src/index.d.ts
@@ -629,8 +674,6 @@ declare class Input<S extends Source = Source> extends SegmentedMediabunnyInput<
   constructor(options: DashaInputOptions<S>);
 }
 declare const isInput: (value: unknown) => value is Input;
-declare const getSegmentedInput: (track: InputTrack$1) => InputSegmentedInput;
-declare const getSegments: (track: InputTrack$1) => Promise<InputSegment[]>;
 declare const ALL_FORMATS: InputFormat[];
 //#endregion
-export { ALL_FORMATS, type AudioCodec, DASH, DASH_FORMATS, type DashSegment, type DashSegmentedInput, FilePathSource, HLS, HLS_FORMATS, type HlsSegment, type HlsSegmentedInput, Input, type InputAudioTrack, InputSegment, InputSegmentedInput, type InputSubtitleSource, type InputSubtitleTrack, type InputSubtitleTrackMetadata, type InputTrack$1 as InputTrack, type InputTrackQuery, type InputTrackWithBacking, type InputVideoTrack, MP3, MP4, type MaybePromise, type MediaCodec, type SubtitleCodec, UrlSource, type VideoCodec, type VideoDynamicRange, asc, desc, getSegmentedInput, getSegments, isInput, prefer, preserveSubtitleBackingsOnInput };
+export { ALL_FORMATS, type AudioCodec, DASH, DASH_FORMATS, type DashSegment, type DashSegmentedInput, FilePathSource, HLS, HLS_FORMATS, type HlsSegment, type HlsSegmentedInput, Input, type InputAudioSource, type InputAudioTrack, type InputAudioTrackPairing, type InputAudioTracksOptions, InputSegment, InputSegmentedInput, type InputSubtitleSource, type InputSubtitleTrack, type InputSubtitleTrackMetadata, type InputTrack$1 as InputTrack, type InputTrackQuery, type InputTrackWithBacking, type InputVideoTrack, MP3, MP4, type MaybePromise, type MediaCodec, type SubtitleCodec, UrlSource, type VideoCodec, type VideoDynamicRange, asc, desc, isInput, prefer, preserveSubtitleBackingsOnInput };

package/dist/index.mjs

@@ -1237,6 +1237,7 @@ const getHlsSubtitleTrackBackings = (input) => {
 //#endregion
 //#region src/mediabunny-input.ts
 const CUSTOM_SUBTITLE_TRACK_ID_OFFSET = 1e9;
+const CUSTOM_AUDIO_TRACK_ID_OFFSET = 2e9;
 const CUSTOM_PAIRING_BIT_START = 1024n;
 const EXTRA_PAIRING_MASK = Symbol.for("dasha.extra-pairing-mask");
 const ORIGINAL_GET_PAIRING_MASK = Symbol.for("dasha.original-get-pairing-mask");
@@ -1382,6 +1383,131 @@ 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 getDefaultAudioTrackFormats = (source) => {
+	return isLikelyDashPath(source instanceof SourceRef ? source.source : source) ? [DASH, ...ALL_FORMATS$1] : [...ALL_FORMATS$1, DASH];
+};
+var WholeResourceAudioSegmentedInput = class {
+	segments = [];
+	#source;
+	constructor(source) {
+		this.#source = source;
+	}
+	async runUpdateSegments() {
+		if (this.segments.length > 0) return;
+		const sourceWithRootPath = this.#source;
+		if (typeof sourceWithRootPath.rootPath !== "string") return;
+		const segment = {
+			timestamp: 0,
+			duration: 0,
+			relativeToUnixEpoch: false,
+			firstSegment: null,
+			sequenceNumber: 0,
+			location: {
+				path: sourceWithRootPath.rootPath,
+				offset: 0,
+				length: null
+			},
+			encryption: null,
+			initSegment: null,
+			lastProgramDateTimeSeconds: null
+		};
+		segment.firstSegment = segment;
+		this.segments = [segment];
+	}
+};
+var ImportedAudioTrackBacking = class {
+	#backing;
+	#id;
+	#number;
+	#wholeResourceSegmentedInput;
+	constructor(params) {
+		this.#backing = params.backing;
+		this.#id = params.id;
+		this.#number = params.number;
+		this.#wholeResourceSegmentedInput = new WholeResourceAudioSegmentedInput(params.source);
+	}
+	getType() {
+		return BACKING_TYPE_AUDIO;
+	}
+	getId() {
+		return this.#id;
+	}
+	getNumber() {
+		return this.#number;
+	}
+	getCodec() {
+		return this.#backing.getCodec();
+	}
+	getInternalCodecId() {
+		return this.#backing.getInternalCodecId?.() ?? null;
+	}
+	getName() {
+		return this.#backing.getName?.() ?? null;
+	}
+	getLanguageCode() {
+		return this.#backing.getLanguageCode?.() ?? "und";
+	}
+	getTimeResolution() {
+		return this.#backing.getTimeResolution?.() ?? 1e3;
+	}
+	isRelativeToUnixEpoch() {
+		return this.#backing.isRelativeToUnixEpoch?.() ?? false;
+	}
+	getDisposition() {
+		return this.#backing.getDisposition?.() ?? {};
+	}
+	getPairingMask() {
+		return 0n;
+	}
+	getBitrate() {
+		return this.#backing.getBitrate?.() ?? null;
+	}
+	getAverageBitrate() {
+		return this.#backing.getAverageBitrate?.() ?? null;
+	}
+	getDurationFromMetadata(options) {
+		return this.#backing.getDurationFromMetadata?.(options) ?? Promise.resolve(null);
+	}
+	getLiveRefreshInterval() {
+		return this.#backing.getLiveRefreshInterval?.() ?? Promise.resolve(null);
+	}
+	getHasOnlyKeyPackets() {
+		return true;
+	}
+	getDecoderConfig() {
+		return this.#backing.getDecoderConfig?.() ?? Promise.resolve(null);
+	}
+	getMetadataCodecParameterString() {
+		return this.#backing.getMetadataCodecParameterString?.() ?? null;
+	}
+	getNumberOfChannels() {
+		return this.#backing.getNumberOfChannels?.() ?? 0;
+	}
+	getSampleRate() {
+		return this.#backing.getSampleRate?.() ?? 0;
+	}
+	getFirstPacket(options) {
+		return this.#backing.getFirstPacket?.(options) ?? Promise.resolve(null);
+	}
+	getPacket(timestamp, options) {
+		return this.#backing.getPacket?.(timestamp, options) ?? Promise.resolve(null);
+	}
+	getNextPacket(packet, options) {
+		return this.#backing.getNextPacket?.(packet, options) ?? Promise.resolve(null);
+	}
+	getKeyPacket(timestamp, options) {
+		return this.#backing.getKeyPacket?.(timestamp, options) ?? Promise.resolve(null);
+	}
+	getNextKeyPacket(packet, options) {
+		return this.#backing.getNextKeyPacket?.(packet, options) ?? Promise.resolve(null);
+	}
+	getSegmentedInput() {
+		if (this.#backing.getSegmentedInput) return this.#backing.getSegmentedInput();
+		const hlsBacking = this.#backing;
+		if (hlsBacking.internalTrack?.demuxer?.getSegmentedInputForPath) return hlsBacking.internalTrack.demuxer.getSegmentedInputForPath(hlsBacking.internalTrack.fullPath);
+		return this.#wholeResourceSegmentedInput;
+	}
+};
 const getBackingType = (backing) => backing.getType?.();
 const queryWrappedTracks = (input, backings, query) => {
 	return queryTracks(backings.map((backing) => input._wrapBackingAsTrack(backing)), query);
@@ -1430,6 +1556,11 @@ const addSegmentAccess = (track) => new Proxy(track, { get(target, prop) {
 	if (prop === "setLanguageCode") return (value) => setTrackLanguageCode(target, value);
 	if (prop === "getSegmentedInput") return () => getSegmentedInputForTrack(target);
 	if (prop === "getSegments") return async () => {
+		const segmentedInput = getSegmentedInputForTrack(target);
+		if (segmentedInput.segments.length === 0) await segmentedInput.runUpdateSegments();
+		return segmentedInput.segments;
+	};
+	if (prop === "refreshSegments") return async () => {
 		const segmentedInput = getSegmentedInputForTrack(target);
 		await segmentedInput.runUpdateSegments();
 		return segmentedInput.segments;
@@ -1474,13 +1605,17 @@ const preserveSubtitleBackingsOnInput = (input) => {
 	Object.assign(input, { [PRESERVE_SUBTITLE_BACKINGS]: true });
 	return input;
 };
-var SegmentedMediabunnyInput = class extends Input$1 {
+var SegmentedMediabunnyInput = class SegmentedMediabunnyInput extends Input$1 {
 	#trackCache = /* @__PURE__ */ new WeakMap();
 	#subtitleTrackCache = /* @__PURE__ */ new WeakMap();
 	#hlsSubtitleBackingsPromise = null;
 	#customSubtitleBackings = [];
+	#customAudioBackings = [];
+	#audioInputs = [];
 	#nextCustomSubtitleTrackId = CUSTOM_SUBTITLE_TRACK_ID_OFFSET;
 	#nextCustomSubtitleTrackNumber = CUSTOM_SUBTITLE_TRACK_ID_OFFSET;
+	#nextCustomAudioTrackId = CUSTOM_AUDIO_TRACK_ID_OFFSET;
+	#nextCustomAudioTrackNumber = CUSTOM_AUDIO_TRACK_ID_OFFSET;
 	#nextPairingBitIndex = null;
 	async #queryTracks(query, type) {
 		const internalInput = this;
@@ -1495,9 +1630,11 @@ var SegmentedMediabunnyInput = class extends Input$1 {
 		return wrapped;
 	}
 	async _getSyntheticTrackBackings(type) {
-		if (type && type !== BACKING_TYPE_SUBTITLE) return [];
-		const backings = [...this.#customSubtitleBackings];
-		if (await this.getFormat() !== HLS$1) return backings;
+		if (type === BACKING_TYPE_VIDEO) return [];
+		const audioBackings = type !== BACKING_TYPE_SUBTITLE ? [...this.#customAudioBackings] : [];
+		const backings = type !== BACKING_TYPE_AUDIO ? [...this.#customSubtitleBackings] : [];
+		if (type === BACKING_TYPE_AUDIO) return audioBackings;
+		if (await this.getFormat() !== HLS$1) return [...audioBackings, ...backings];
 		if (!this.#hlsSubtitleBackingsPromise) {
 			const promise = getHlsSubtitleTrackBackings(this).catch((error) => {
 				if (this.#hlsSubtitleBackingsPromise === promise) this.#hlsSubtitleBackingsPromise = null;
@@ -1505,7 +1642,11 @@ var SegmentedMediabunnyInput = class extends Input$1 {
 			});
 			this.#hlsSubtitleBackingsPromise = promise;
 		}
-		return [...backings, ...await this.#hlsSubtitleBackingsPromise];
+		return [
+			...audioBackings,
+			...backings,
+			...await this.#hlsSubtitleBackingsPromise
+		];
 	}
 	#wrapSubtitleBacking(backing) {
 		const existing = this.#subtitleTrackCache.get(backing);
@@ -1551,6 +1692,31 @@ var SegmentedMediabunnyInput = class extends Input$1 {
 		this.#customSubtitleBackings.push(backing);
 		return this._wrapBackingAsTrack(backing);
 	}
+	async addAudioTracks(source, options = {}) {
+		const audioInput = new SegmentedMediabunnyInput({
+			source,
+			formats: [...options.formats ?? getDefaultAudioTrackFormats(source)]
+		});
+		this.#audioInputs.push(audioInput);
+		const audioTracks = await audioInput.getAudioTracks({
+			filter: options.filter,
+			sortBy: options.sortBy
+		});
+		const pairWith = await this.#getAudioPairingVideoTracks(options.pairWith);
+		const importedTracks = [];
+		for (const audioTrack of audioTracks) {
+			const backing = new ImportedAudioTrackBacking({
+				id: this.#nextCustomAudioTrackId++,
+				number: this.#nextCustomAudioTrackNumber++,
+				backing: getTrackBacking(audioTrack),
+				source: audioInput.source
+			});
+			this.#pairAudioBacking(backing, pairWith);
+			this.#customAudioBackings.push(backing);
+			importedTracks.push(this._wrapBackingAsTrack(backing));
+		}
+		return importedTracks;
+	}
 	#takeSubtitleSourceRef(source) {
 		const rawSource = source instanceof SourceRef ? source.source : source;
 		if (!(rawSource instanceof Object) || !("rootPath" in rawSource) || !("ref" in rawSource) || typeof rawSource.ref !== "function") throw new TypeError("source must be a pathed source such as UrlSource or FilePathSource.");
@@ -1567,13 +1733,28 @@ var SegmentedMediabunnyInput = class extends Input$1 {
 		}
 		return tracks;
 	}
+	async #getAudioPairingVideoTracks(pairWith) {
+		if (pairWith === false) return [];
+		if (!pairWith || pairWith === "all") return this.getVideoTracks();
+		if (pairWith === "primary") {
+			const primaryVideoTrack = await this.getPrimaryVideoTrack();
+			return primaryVideoTrack ? [primaryVideoTrack] : [];
+		}
+		return this.#toPairableVideoTracks(pairWith);
+	}
 	#isIterable(value) {
 		return typeof value === "object" && value !== null && Symbol.iterator in value;
 	}
 	#pairSubtitleBacking(subtitleBacking, videoTracks) {
+		this.#pairBackingWithVideoTracks(subtitleBacking, videoTracks);
+	}
+	#pairAudioBacking(audioBacking, videoTracks) {
+		this.#pairBackingWithVideoTracks(audioBacking, videoTracks);
+	}
+	#pairBackingWithVideoTracks(backing, videoTracks) {
 		for (const track of videoTracks) {
 			const bit = this.#allocatePairingBit();
-			this.#appendPairingMask(subtitleBacking, bit);
+			this.#appendPairingMask(backing, bit);
 			this.#appendPairingMask(track._backing, bit);
 		}
 	}
@@ -1585,7 +1766,11 @@ var SegmentedMediabunnyInput = class extends Input$1 {
 	#getInitialPairingBitIndex() {
 		const loadedBackings = [...this._trackBackingsCache ?? []];
 		let maxBitIndex = -1n;
-		for (const backing of [...loadedBackings, ...this.#customSubtitleBackings]) {
+		for (const backing of [
+			...loadedBackings,
+			...this.#customSubtitleBackings,
+			...this.#customAudioBackings
+		]) {
 			const mask = backing.getPairingMask?.() ?? 0n;
 			if (mask === 0n) continue;
 			const bitIndex = BigInt(mask.toString(2).length - 1);
@@ -1600,6 +1785,12 @@ var SegmentedMediabunnyInput = class extends Input$1 {
 		patchedBacking[ORIGINAL_GET_PAIRING_MASK] = backing.getPairingMask?.bind(backing) ?? (() => 0n);
 		Object.assign(backing, { getPairingMask: () => (patchedBacking[ORIGINAL_GET_PAIRING_MASK]?.() ?? 0n) | (patchedBacking[EXTRA_PAIRING_MASK] ?? 0n) });
 	}
+	dispose() {
+		if (this.disposed) return;
+		super.dispose();
+		for (const input of this.#audioInputs) input.dispose();
+		this.#audioInputs.length = 0;
+	}
 };
 //#endregion
 //#region src/dash/dash-segmented-input.ts
@@ -2670,6 +2861,11 @@ var DashTrackBackingBase = class {
 		return this.internalTrack.demuxer.getSegmentedInputForTrack(this.internalTrack);
 	}
 	async getSegments() {
+		const segmentedInput = this.getSegmentedInput();
+		if (segmentedInput.segments.length === 0) await segmentedInput.runUpdateSegments();
+		return segmentedInput.segments;
+	}
+	async refreshSegments() {
 		const segmentedInput = this.getSegmentedInput();
 		await segmentedInput.runUpdateSegments();
 		return segmentedInput.segments;
@@ -2787,8 +2983,6 @@ var Input = class extends SegmentedMediabunnyInput {
 	}
 };
 const isInput = (value) => value instanceof Input;
-const getSegmentedInput = (track) => track.getSegmentedInput();
-const getSegments = async (track) => track.getSegments();
 const ALL_FORMATS = [...ALL_FORMATS$1, DASH];
 //#endregion
-export { ALL_FORMATS, DASH, DASH_FORMATS, FilePathSource, HLS, HLS_FORMATS, Input, MP3, MP4, UrlSource, asc, desc, getSegmentedInput, getSegments, isInput, prefer, preserveSubtitleBackingsOnInput };
+export { ALL_FORMATS, DASH, DASH_FORMATS, FilePathSource, HLS, HLS_FORMATS, Input, MP3, MP4, UrlSource, asc, desc, isInput, prefer, preserveSubtitleBackingsOnInput };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dasha",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "Streaming manifest parser",
   "files": [
     "dist"
@@ -45,7 +45,7 @@
     }
   ],
   "engines": {
-    "node": ">=22.18"
+    "node": ">=22.19"
   },
   "dependencies": {
     "@xmldom/xmldom": "^0.9.10",
@@ -55,12 +55,12 @@
     "mediabunny": "^1.45.2"
   },
   "devDependencies": {
-    "@types/node": "^25.8.0",
-    "oxfmt": "^0.50.0",
-    "oxlint": "^1.65.0",
-    "tsdown": "^0.22.0",
+    "@types/node": "^25.9.1",
+    "oxfmt": "^0.52.0",
+    "oxlint": "^1.67.0",
+    "tsdown": "^0.22.1",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.6"
+    "vitest": "^4.1.7"
   },
   "scripts": {
     "test": "vitest",