dasha 4.0.0-alpha.9 → 4.0.0

package/README.md

@@ -4,7 +4,7 @@
 [![npm downloads/month](https://img.shields.io/npm/dm/dasha?style=flat&color=black)](https://www.npmjs.com/package/dasha)
 [![npm downloads](https://img.shields.io/npm/dt/dasha?style=flat&color=black)](https://www.npmjs.com/package/dasha)
 
-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.
+Library for working with MPEG-DASH (`.mpd`) and HLS (`.m3u8`) manifests through a mediabunny-compatible `Input` API. Made with the purpose of obtaining a simplified representation convenient for further downloading of segments by URLs and getting basic metadata about the tracks.
 
 > [!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).
@@ -13,34 +13,86 @@ Library for parsing MPEG-DASH (.mpd) and HLS (.m3u8) manifests. Made with the pu
 ## Install
 
 ```shell
-npm i dasha@alpha
+npm install dasha@alpha
 ```
 
 ## Usage
 
-```js
+### HLS
+
+```ts
 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 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);
+import { desc, HLS_FORMATS, Input, UrlSource } from 'dasha';
+
+async function saveVideo() {
+  const input = new Input({
+    source: new UrlSource(
+      'https://storage.googleapis.com/shaka-demo-assets/angel-one-widevine-hls/hls.m3u8',
+      { requestInit: { headers: { Referer: 'https://bitmovin.com/' } } },
+    ),
+    formats: HLS_FORMATS,
+  });
+
+  const videoTracks = await input.getVideoTracks({
+    sortBy: async (track) => [
+      desc(await track.getDisplayHeight()),
+      // Tracks with matching resolution are sorted by bitrate
+      desc(await track.getBitrate()),
+    ],
+    // Filter out #EXT-X-I-FRAME-STREAM-INF tracks
+    filter: async (track) => !(await track.hasOnlyKeyPackets()),
+  });
+
+  const bestVideoTrack = videoTracks[0];
+
+  const segments = await bestVideoTrack.getSegments();
+
+  const outputPath = 'output.mp4';
+  const urls = segments.map((segment) => segment.location.path);
+  const initSegment = segments[0]?.initSegment;
+  if (initSegment) urls.unshift(initSegment.location.path);
+  for (const url of urls) {
+    const content = await fetch(url).then((res) => res.arrayBuffer());
+    await fs.appendFile(outputPath, new Uint8Array(content));
   }
-}
+};
 ```
 
-## Credits
+### DASH
 
-This project is heavily influenced by the robust implementation found in [N_m3u8DL-RE](https://github.com/nilaoda/N_m3u8DL-RE). Special thanks to the open-source community and contributors who make projects like this possible.
+```ts
+import fs from 'node:fs/promises';
+import { DASH_FORMATS, Input, UrlSource, desc } from 'dasha';
 
-## Licenses
+async function saveDashVideo() {
+  const input = new Input({
+    source: new UrlSource(
+      'https://dash.akamaized.net/dash264/TestCases/1a/netflix/exMPD_BIP_TC1.mpd',
+    ),
+    formats: DASH_FORMATS,
+  });
+
+  const videoTracks = await input.getVideoTracks({
+    sortBy: async (track) => [
+      desc(await track.getDisplayHeight()),
+      desc(await track.getBitrate()),
+    ],
+  });
+
+  const bestVideoTrack = videoTracks[0];
+  const segments = await bestVideoTrack.getSegments();
+
+  const outputPath = 'output.m4s';
+  const urls = segments.map((segment) => segment.location.path);
+  const initSegment = segments[0]?.initSegment;
+  if (initSegment) urls.unshift(initSegment.location.path);
+  for (const url of urls) {
+    const content = await fetch(url).then((res) => res.arrayBuffer());
+    await fs.appendFile(outputPath, new Uint8Array(content));
+  }
+}
+```
+
+## Credits
 
-This project is licensed under the [MIT License](LICENSE).
+[mediabunny](https://github.com/Vanilagy/mediabunny)

package/dist/index.d.mts

@@ -0,0 +1,491 @@
+import * as _$mediabunny from "mediabunny";
+import { AudioCodec, DurationMetadataRequestOptions, EncodedPacket, FilePathSource, 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, MediaCodec, MetadataTags, PacketRetrievalOptions, Source, TrackDisposition, UrlSource, VideoCodec, asc, desc, prefer } from "mediabunny";
+import { Element } from "@xmldom/xmldom";
+
+//#region src/mediabunny.d.ts
+type Segment$1 = {
+  timestamp: number;
+  duration: number;
+  relativeToUnixEpoch: boolean;
+  firstSegment: Segment$1 | null;
+};
+type HlsSegmentLocation = {
+  path: string;
+  offset: number;
+  length: number | null;
+};
+type HlsEncryptionInfo = {
+  method: 'AES-128';
+  keyUri: string;
+  iv: Uint8Array | null;
+  keyFormat: string;
+} | {
+  method: 'SAMPLE-AES' | 'SAMPLE-AES-CTR';
+};
+type HlsSegment = Segment$1 & {
+  sequenceNumber: number | null;
+  location: HlsSegmentLocation;
+  encryption: HlsEncryptionInfo | null;
+  firstSegment: HlsSegment | null;
+  initSegment: HlsSegment | null;
+  lastProgramDateTimeSeconds: number | null;
+};
+type HlsSegmentedInput = {
+  segments: HlsSegment[];
+  runUpdateSegments(): Promise<void>;
+};
+type InputTrackWithBacking = InputTrack & {
+  _backing: {
+    internalTrack: {
+      fullPath: string;
+      demuxer: {
+        getSegmentedInputForPath(path: string): HlsSegmentedInput;
+      };
+    };
+  };
+};
+//#endregion
+//#region src/codec.d.ts
+/**
+ * List of known video codecs, ordered by encoding preference.
+ * @group Codecs
+ * @public
+ */
+declare const VIDEO_CODECS: readonly ["avc", "hevc", "vp8", "vp9", "av1", "vc1"];
+/**
+ * List of known video dynamic ranges.
+ * @group Codecs
+ * @public
+ */
+declare const VIDEO_DYNAMIC_RANGES: readonly ["sdr", "hlg", "hdr10", "hdr10+", "dv"];
+/**
+ * List of known audio codecs, ordered by encoding preference.
+ * @group Codecs
+ * @public
+ */
+declare const AUDIO_CODECS: readonly ["aac", "opus", "mp3", "vorbis", "flac", "alac", "ac3", "eac3", "dts"];
+/**
+ * List of known subtitle codecs, ordered by encoding preference.
+ * @group Codecs
+ * @public
+ */
+declare const SUBTITLE_CODECS: readonly ["srt", "vtt", "ttml", "dfxp", "ssa", "ass", "stpp", "wvtt"];
+/**
+ * Union type of known video codecs.
+ * @group Codecs
+ * @public
+ */
+type VideoCodec$1 = (typeof VIDEO_CODECS)[number];
+/**
+ * Union type of known video dynamic ranges.
+ * @group Codecs
+ * @public
+ */
+type VideoDynamicRange = (typeof VIDEO_DYNAMIC_RANGES)[number];
+/**
+ * Union type of known audio codecs.
+ * @group Codecs
+ * @public
+ */
+type AudioCodec$1 = (typeof AUDIO_CODECS)[number];
+/**
+ * Union type of known subtitle codecs.
+ * @group Codecs
+ * @public
+ */
+type SubtitleCodec = (typeof SUBTITLE_CODECS)[number];
+/**
+ * Union type of known media codecs.
+ * @group Codecs
+ * @public
+ */
+type MediaCodec$1 = VideoCodec$1 | AudioCodec$1 | SubtitleCodec;
+//#endregion
+//#region src/role-type.d.ts
+declare const ROLE_TYPE: {
+  Subtitle: number;
+  Main: number;
+  Alternate: number;
+  Supplementary: number;
+  Commentary: number;
+  Dub: number;
+  Description: number;
+  Sign: number;
+  Metadata: number;
+  ForcedSubtitle: number;
+};
+type RoleType = (typeof ROLE_TYPE)[keyof typeof ROLE_TYPE];
+//#endregion
+//#region src/dash/dash-misc.d.ts
+type DashTrackType = 'video' | 'audio' | 'subtitle';
+type DashEncryptionData = {
+  method: string;
+  key?: Uint8Array;
+  iv?: Uint8Array;
+  drm: {
+    widevine?: {
+      keyId?: string;
+      pssh?: string;
+    };
+    playready?: {
+      keyId?: string;
+      pssh?: string;
+    };
+    fairplay?: {
+      keyId?: string;
+      pssh?: string;
+    };
+  };
+};
+type DashParsedSegment = {
+  sequenceNumber: number | null;
+  timestamp?: number;
+  duration: number;
+  url: string;
+  startRange?: number;
+  expectLength?: number;
+  encryption: DashEncryptionData | null;
+};
+type DashTrackCommon = {
+  type: DashTrackType;
+  codec?: MediaCodec$1;
+  codecString: string | null;
+  languageCode?: string;
+  peakBitrate: number | null;
+  averageBitrate: number | null;
+  name: string | null;
+  default: boolean;
+  role?: RoleType;
+  groupId: string | null;
+  audioGroupId?: string;
+  subtitleGroupId?: string;
+  periodId: string | null;
+  extension: string | null;
+  isLive: boolean;
+  refreshIntervalMs: number;
+  initSegment: DashParsedSegment | null;
+  mediaSegments: DashParsedSegment[];
+};
+type DashParsedVideoTrack = DashTrackCommon & {
+  type: 'video';
+  width?: number;
+  height?: number;
+  frameRate?: number;
+  dynamicRange?: VideoDynamicRange;
+};
+type DashParsedAudioTrack = DashTrackCommon & {
+  type: 'audio';
+  numberOfChannels?: number;
+  sampleRate?: number;
+  descriptive?: boolean;
+  joc?: number;
+};
+type DashParsedSubtitleTrack = DashTrackCommon & {
+  type: 'subtitle';
+  cc?: boolean;
+  sdh?: boolean;
+  forced?: boolean;
+};
+type DashParsedTrack = DashParsedVideoTrack | DashParsedAudioTrack | DashParsedSubtitleTrack;
+//#endregion
+//#region src/dash/dash-segmented-input.d.ts
+type Segment = {
+  timestamp: number;
+  duration: number;
+  relativeToUnixEpoch: boolean;
+};
+type DashSegmentLocation = {
+  path: string;
+  offset: number;
+  length: number | null;
+};
+type DashEncryptionInfo = DashEncryptionData;
+type DashSegment = Segment & {
+  sequenceNumber: number | null;
+  location: DashSegmentLocation;
+  encryption: DashEncryptionInfo | null;
+  firstSegment: DashSegment | null;
+  initSegment: DashSegment | null;
+  lastProgramDateTimeSeconds: number | null;
+};
+type SegmentRetrievalOptions = {
+  skipLiveWait?: boolean;
+};
+type TrackWithBacking = InputTrack$2 & {
+  _backing: {
+    getDecoderConfig(): Promise<VideoDecoderConfig | AudioDecoderConfig | null>;
+    getFirstPacket(options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+    getPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+    getNextPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+    getKeyPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+    getNextKeyPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+    getHasOnlyKeyPackets?(): boolean | null | Promise<boolean | null>;
+  };
+};
+type PacketInfo = {
+  segment: DashSegment;
+  track: TrackWithBacking;
+  sourcePacket: EncodedPacket;
+};
+declare class DashSegmentedInput {
+  internalTrack: DashInternalTrack;
+  demuxer: DashInternalTrack['demuxer'];
+  segments: DashSegment[];
+  currentUpdateSegmentsPromise: Promise<void> | null;
+  lastSegmentUpdateTime: number;
+  nextInputCacheAge: number;
+  inputCache: {
+    age: number;
+    input: Input$1;
+    segment: DashSegment;
+  }[];
+  firstTrackPromise: Promise<TrackWithBacking> | null;
+  packetInfos: WeakMap<EncodedPacket, PacketInfo>;
+  firstSegmentFirstTimestamps: WeakMap<DashSegment, number>;
+  firstTimestampCache: WeakMap<Input$1<_$mediabunny.Source>, number>;
+  constructor(internalTrack: DashInternalTrack);
+  runUpdateSegments(): Promise<void>;
+  updateSegments(): Promise<void>;
+  getRemainingWaitTimeMs(): number;
+  getFirstSegment(): Promise<DashSegment>;
+  getSegmentAt(timestamp: number, options: SegmentRetrievalOptions): Promise<DashSegment | null>;
+  getNextSegmentIndex(segment: DashSegment): number;
+  getNextSegment(segment: DashSegment, options: SegmentRetrievalOptions): Promise<DashSegment | null>;
+  getPreviousSegment(segment: DashSegment): Promise<DashSegment>;
+  getInputForSegment(segment: DashSegment): Input$1;
+  getTrackForSegment(segment: DashSegment): Promise<TrackWithBacking | null>;
+  getFirstTrack(): Promise<TrackWithBacking>;
+  getFirstTimestampForInput(input: Input$1): Promise<number>;
+  getMediaOffset(segment: DashSegment, input: Input$1, track: InputTrack$2): Promise<number>;
+  createAdjustedPacket(packet: EncodedPacket, segment: DashSegment, track: TrackWithBacking): Promise<EncodedPacket>;
+  getDecoderConfig(): Promise<VideoDecoderConfig | AudioDecoderConfig | null>;
+  getHasOnlyKeyPackets(): Promise<boolean | null>;
+  getFirstPacket(options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+  getNextPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+  getNextKeyPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+  getNextPacketInternal(packet: EncodedPacket, options: PacketRetrievalOptions, keyframesOnly: boolean): Promise<EncodedPacket | null>;
+  getPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+  getKeyPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+  getPacketInternal(timestamp: number, options: PacketRetrievalOptions, keyframesOnly: boolean): Promise<EncodedPacket | null>;
+  getLiveRefreshInterval(): Promise<number | null>;
+}
+//#endregion
+//#region src/dash/dash-demuxer.d.ts
+type DashManifestInfo = {
+  mpdElement: Element;
+  isLive: boolean;
+  availabilityStartTime: string | null;
+  timeShiftBufferDepth: string;
+  mediaPresentationDuration: string | null;
+};
+type DashTrackInfo = {
+  type: 'video';
+  width: number | null;
+  height: number | null;
+} | {
+  type: 'audio';
+  numberOfChannels: number | null;
+} | {
+  type: 'subtitle';
+};
+type InternalTrack = {
+  id: number;
+  demuxer: DashDemuxer;
+  backingTrack: DashInputTrackBacking | null;
+  pairingMask: bigint;
+  track: DashParsedTrack;
+  info: DashTrackInfo;
+};
+type InternalVideoTrack = InternalTrack & {
+  info: Extract<DashTrackInfo, {
+    type: 'video';
+  }>;
+  track: Extract<DashParsedTrack, {
+    type: 'video';
+  }>;
+};
+type InternalAudioTrack = InternalTrack & {
+  info: Extract<DashTrackInfo, {
+    type: 'audio';
+  }>;
+  track: Extract<DashParsedTrack, {
+    type: 'audio';
+  }>;
+};
+type InternalSubtitleTrack = InternalTrack & {
+  info: Extract<DashTrackInfo, {
+    type: 'subtitle';
+  }>;
+  track: Extract<DashParsedTrack, {
+    type: 'subtitle';
+  }>;
+};
+type DashInternalTrack = InternalTrack;
+declare class DashDemuxer {
+  input: Input$1;
+  metadataPromise: Promise<void> | null;
+  trackBackings: DashInputTrackBacking[] | null;
+  internalTracks: InternalTrack[] | null;
+  segmentedInputs: DashSegmentedInput[];
+  manifestUrl: string;
+  originalUrl: string;
+  headers: Record<string, string>;
+  mpdUrl: string;
+  baseUrl: string;
+  constructor(input: Input$1);
+  readMetadata(): Promise<void>;
+  getTrackBackings(): Promise<DashInputTrackBacking[]>;
+  getSegmentedInputForTrack(track: DashInternalTrack): DashSegmentedInput;
+  refreshTrackSegments(track: DashInternalTrack): Promise<void>;
+  getMimeType(): Promise<string>;
+  getMetadataTags(): Promise<MetadataTags>;
+  dispose(): void;
+  extractTracks(rawText: string): DashParsedTrack[];
+  parseManifest(rawText: string): DashManifestInfo;
+  appendPeriodTracks(tracks: DashParsedTrack[], manifest: DashManifestInfo, period: Element): void;
+  appendAdaptationSetTracks(params: {
+    tracks: DashParsedTrack[];
+    manifest: DashManifestInfo;
+    period: Element;
+    periodDurationSeconds: number;
+    periodBaseUrl: string;
+    adaptationSet: Element;
+  }): void;
+  createTrack(params: {
+    adaptationSet: Element;
+    representation: Element;
+    period: Element;
+    manifest: DashManifestInfo;
+    bitrate: number;
+    contentType: string | null;
+    mimeType: string | null;
+    frameRate: number | undefined;
+  }): DashParsedTrack;
+  populateTrackSegments(params: {
+    adaptationSet: Element;
+    period: Element;
+    representation: Element;
+    track: DashParsedTrack;
+    manifest: DashManifestInfo;
+    segmentBaseUrl: string;
+    periodDurationSeconds: number;
+    bitrate: number;
+  }): void;
+  findMatchingTrack(nextTracks: DashParsedTrack[], currentTrack: DashParsedTrack): DashParsedTrack | undefined;
+  refreshTracks(tracks: DashParsedTrack[]): Promise<void>;
+  fetchManifest(url: string): Promise<Response>;
+  resetManifestUrls(): void;
+}
+declare abstract class DashTrackBackingBase {
+  internalTrack: InternalTrack;
+  hydratedTrackPromise: Promise<any> | null;
+  constructor(internalTrack: InternalTrack);
+  abstract getType(): 'video' | 'audio' | 'subtitle';
+  hydrate(): Promise<any>;
+  delegate<T>(fn: (track: any) => T | Promise<T>): Promise<T>;
+  getId(): number;
+  getNumber(): number;
+  getCodec(): MediaCodec | null;
+  getInternalCodecId(): null;
+  getName(): string | null;
+  getLanguageCode(): string;
+  getTimeResolution(): Promise<any>;
+  isRelativeToUnixEpoch(): boolean;
+  getDisposition(): TrackDisposition;
+  getPairingMask(): bigint;
+  getBitrate(): number | null;
+  getAverageBitrate(): number | null;
+  getDurationFromMetadata(_options: DurationMetadataRequestOptions): Promise<number>;
+  getLiveRefreshInterval(): Promise<number | null>;
+  getHasOnlyKeyPackets(): boolean;
+  getDecoderConfig(): Promise<VideoDecoderConfig | AudioDecoderConfig | null>;
+  getMetadataCodecParameterString(): string | null;
+  getFirstPacket(options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+  getPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+  getNextPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+  getKeyPacket(timestamp: number, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+  getNextKeyPacket(packet: EncodedPacket, options: PacketRetrievalOptions): Promise<EncodedPacket | null>;
+  getSegmentedInput(): DashSegmentedInput;
+  getSegments(): Promise<DashSegment[]>;
+}
+declare class DashInputVideoTrackBacking extends DashTrackBackingBase {
+  internalTrack: InternalVideoTrack;
+  constructor(internalTrack: InternalVideoTrack);
+  getType(): "video";
+  getCodec(): VideoCodec | null;
+  getCodedWidth(): number | Promise<any>;
+  getCodedHeight(): number | Promise<any>;
+  getSquarePixelWidth(): number | Promise<any>;
+  getSquarePixelHeight(): number | Promise<any>;
+  getMetadataDisplayWidth(): number | null;
+  getMetadataDisplayHeight(): number | null;
+  getRotation(): number;
+  getColorSpace(): Promise<VideoColorSpaceInit>;
+  canBeTransparent(): Promise<any>;
+}
+declare class DashInputAudioTrackBacking extends DashTrackBackingBase {
+  internalTrack: InternalAudioTrack;
+  constructor(internalTrack: InternalAudioTrack);
+  getType(): "audio";
+  getCodec(): AudioCodec | null;
+  getNumberOfChannels(): number | Promise<any>;
+  getSampleRate(): number | Promise<any>;
+}
+declare class DashInputSubtitleTrackBacking extends DashTrackBackingBase {
+  internalTrack: InternalSubtitleTrack;
+  constructor(internalTrack: InternalSubtitleTrack);
+  getType(): "subtitle";
+}
+type DashInputTrackBacking = DashInputVideoTrackBacking | DashInputAudioTrackBacking | DashInputSubtitleTrackBacking;
+declare class DashInputFormat extends InputFormat {
+  get name(): string;
+  get mimeType(): string;
+  _canReadInput(input: Input$1): Promise<boolean>;
+  _createDemuxer(input: Input$1): DashDemuxer;
+}
+declare const DASH: DashInputFormat;
+declare const DASH_FORMATS: InputFormat[];
+//#endregion
+//#region src/mediabunny-input.d.ts
+declare module 'mediabunny' {
+  interface Input<S extends Source = Source> {
+    _getTrackBackings(): Promise<unknown[]>;
+    _wrapBackingAsTrack(backing: unknown): InputTrack$2;
+  }
+}
+type SegmentAccessMethods = {
+  getSegmentedInput(): HlsSegmentedInput | DashSegmentedInput;
+  getSegments(): Promise<(HlsSegment | DashSegment)[]>;
+};
+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;
+  getTracks(query?: InputTrackQuery$1<MediabunnyTrackWithSegments>): Promise<MediabunnyTrackWithSegments[]>;
+  getVideoTracks(query?: InputTrackQuery$1<MediabunnyVideoTrackWithSegments>): Promise<MediabunnyVideoTrackWithSegments[]>;
+  getAudioTracks(query?: InputTrackQuery$1<MediabunnyAudioTrackWithSegments>): Promise<MediabunnyAudioTrackWithSegments[]>;
+  getPrimaryVideoTrack(query?: InputTrackQuery$1<MediabunnyVideoTrackWithSegments>): Promise<MediabunnyVideoTrackWithSegments | null>;
+  getPrimaryAudioTrack(query?: InputTrackQuery$1<MediabunnyAudioTrackWithSegments>): Promise<MediabunnyAudioTrackWithSegments | null>;
+}
+//#endregion
+//#region src/index.d.ts
+type DashaInputOptions<S extends Source = Source> = Omit<InputOptions<S>, 'formats'> & {
+  formats: readonly InputFormat[];
+};
+type InputSegment = HlsSegment | DashSegment;
+type InputSegmentedInput = HlsSegmentedInput | DashSegmentedInput;
+type InputTrack$1 = MediabunnyTrackWithSegments;
+type InputVideoTrack = MediabunnyVideoTrackWithSegments;
+type InputAudioTrack = MediabunnyAudioTrackWithSegments;
+declare class Input<S extends Source = Source> extends SegmentedMediabunnyInput<S> {
+  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[]>;
+//#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, preserveSubtitleBackingsOnInput };