@remotion/media-parser 4.0.289 → 4.0.291

package/dist/containers/m3u/run-over-m3u.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runOverM3u = void 0;
 const log_1 = require("../../log");
-const register_track_1 = require("../../register-track");
-const iterate_over_segment_files_1 = require("./iterate-over-segment-files");
+const process_m3u_chunk_1 = require("./process-m3u-chunk");
 const runOverM3u = async ({ state, structure, playlistUrl, logLevel, }) => {
     const tracksDone = state.m3u.getTrackDone(playlistUrl);
     const hasAudioStreamToConsider = state.m3u.sampleSorter.hasAudioStreamToConsider(playlistUrl);
@@ -26,84 +25,12 @@ const runOverM3u = async ({ state, structure, playlistUrl, logLevel, }) => {
         return;
     }
     log_1.Log.trace(logLevel, 'Starting new M3U parsing process for', playlistUrl);
-    return new Promise((resolve, reject) => {
-        const run = (0, iterate_over_segment_files_1.iteratorOverSegmentFiles)({
-            playlistUrl,
-            structure,
-            onInitialProgress: (newRun) => {
-                state.m3u.setM3uStreamRun(playlistUrl, newRun);
-                resolve();
-            },
-            logLevel: state.logLevel,
-            onDoneWithTracks() {
-                const allDone = state.m3u.setTracksDone(playlistUrl);
-                if (allDone) {
-                    state.callbacks.tracks.setIsDone(state.logLevel);
-                }
-            },
-            onAudioTrack: audioDone
-                ? null
-                : async (track) => {
-                    const existingTracks = state.callbacks.tracks.getTracks();
-                    let { trackId } = track;
-                    while (existingTracks.find((t) => t.trackId === trackId)) {
-                        trackId++;
-                    }
-                    const onAudioSample = await (0, register_track_1.registerAudioTrack)({
-                        container: 'm3u8',
-                        track: {
-                            ...track,
-                            trackId,
-                        },
-                        registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
-                        tracks: state.callbacks.tracks,
-                        logLevel: state.logLevel,
-                        onAudioTrack: state.onAudioTrack,
-                    });
-                    state.m3u.sampleSorter.addToStreamWithTrack(playlistUrl);
-                    if (onAudioSample === null) {
-                        return null;
-                    }
-                    state.m3u.sampleSorter.addAudioStreamToConsider(playlistUrl, onAudioSample);
-                    return async (sample) => {
-                        await state.m3u.sampleSorter.addAudioSample(playlistUrl, sample);
-                    };
-                },
-            onVideoTrack: videoDone
-                ? null
-                : async (track) => {
-                    const existingTracks = state.callbacks.tracks.getTracks();
-                    let { trackId } = track;
-                    while (existingTracks.find((t) => t.trackId === trackId)) {
-                        trackId++;
-                    }
-                    const onVideoSample = await (0, register_track_1.registerVideoTrack)({
-                        container: 'm3u8',
-                        track: {
-                            ...track,
-                            trackId,
-                        },
-                        logLevel: state.logLevel,
-                        onVideoTrack: state.onVideoTrack,
-                        registerVideoSampleCallback: state.callbacks.registerVideoSampleCallback,
-                        tracks: state.callbacks.tracks,
-                    });
-                    state.m3u.sampleSorter.addToStreamWithTrack(playlistUrl);
-                    if (onVideoSample === null) {
-                        return null;
-                    }
-                    state.m3u.sampleSorter.addVideoStreamToConsider(playlistUrl, onVideoSample);
-                    return async (sample) => {
-                        await state.m3u.sampleSorter.addVideoSample(playlistUrl, sample);
-                    };
-                },
-            m3uState: state.m3u,
-            parentController: state.controller,
-            readerInterface: state.readerInterface,
-        });
-        run.catch((err) => {
-            reject(err);
-        });
+    await (0, process_m3u_chunk_1.processM3uChunk)({
+        playlistUrl,
+        state,
+        structure,
+        audioDone,
+        videoDone,
     });
 };
 exports.runOverM3u = runOverM3u;

package/dist/containers/m3u/sample-sorter.d.ts

@@ -4,6 +4,7 @@ export declare const sampleSorter: ({ logLevel, getAllChunksProcessedForPlaylist
     logLevel: LogLevel;
     getAllChunksProcessedForPlaylist: (src: string) => boolean;
 }) => {
+    clearSamples: () => void;
     addToStreamWithTrack: (src: string) => void;
     addVideoStreamToConsider: (src: string, callback: OnVideoSample) => void;
     addAudioStreamToConsider: (src: string, callback: OnAudioSample) => void;

package/dist/containers/m3u/sample-sorter.js

@@ -6,8 +6,11 @@ const sampleSorter = ({ logLevel, getAllChunksProcessedForPlaylist, }) => {
     const streamsWithTracks = [];
     const audioCallbacks = {};
     const videoCallbacks = {};
-    const latestSample = {};
+    let latestSample = {};
     return {
+        clearSamples: () => {
+            latestSample = {};
+        },
         addToStreamWithTrack: (src) => {
             streamsWithTracks.push(src);
         },

package/dist/containers/m3u/seek/get-chunk-to-seek-to.d.ts

@@ -0,0 +1,5 @@
+import type { M3uChunk } from '../get-chunks';
+export declare const getChunkToSeekTo: ({ chunks, seekToSecondsToProcess, }: {
+    chunks: M3uChunk[];
+    seekToSecondsToProcess: number;
+}) => number;

package/dist/containers/m3u/seek/get-chunk-to-seek-to.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChunkToSeekTo = void 0;
+const getChunkToSeekTo = ({ chunks, seekToSecondsToProcess, }) => {
+    let duration = 0;
+    for (let i = 0; i < chunks.length; i++) {
+        if (duration >= seekToSecondsToProcess) {
+            return Math.max(0, i - 1);
+        }
+        duration += chunks[i].duration;
+    }
+    return Math.max(0, chunks.length - 1);
+};
+exports.getChunkToSeekTo = getChunkToSeekTo;

package/dist/containers/m3u/seeking-hints.d.ts

@@ -0,0 +1,2 @@
+import type { M3u8SeekingHints } from '../../seeking-hints';
+export declare const getSeekingHintsForM3u: () => M3u8SeekingHints;

package/dist/containers/m3u/seeking-hints.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingHintsForM3u = void 0;
+const getSeekingHintsForM3u = () => {
+    return {
+        type: 'm3u8-seeking-hints',
+    };
+};
+exports.getSeekingHintsForM3u = getSeekingHintsForM3u;

package/dist/containers/m3u/select-stream.d.ts

@@ -7,9 +7,10 @@ export type SelectM3uAssociatedPlaylistsFnOptions = {
     associatedPlaylists: M3uAssociatedPlaylist[];
 };
 export type SelectM3uAssociatedPlaylistsFn = (options: SelectM3uAssociatedPlaylistsFnOptions) => M3uAssociatedPlaylist[] | Promise<M3uAssociatedPlaylist[]>;
-export declare const selectAssociatedPlaylists: ({ playlists, fn, }: {
+export declare const selectAssociatedPlaylists: ({ playlists, fn, skipAudioTracks, }: {
     playlists: M3uAssociatedPlaylist[];
     fn: SelectM3uAssociatedPlaylistsFn;
+    skipAudioTracks: boolean;
 }) => Promise<M3uAssociatedPlaylist[]>;
 export declare const defaultSelectM3uAssociatedPlaylists: SelectM3uAssociatedPlaylistsFn;
 export declare const selectStream: ({ streams, fn, }: {

package/dist/containers/m3u/select-stream.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultSelectM3uStreamFn = exports.selectStream = exports.defaultSelectM3uAssociatedPlaylists = exports.selectAssociatedPlaylists = void 0;
-const selectAssociatedPlaylists = async ({ playlists, fn, }) => {
+const selectAssociatedPlaylists = async ({ playlists, fn, skipAudioTracks, }) => {
     if (playlists.length < 1) {
         return Promise.resolve([]);
     }
@@ -9,12 +9,17 @@ const selectAssociatedPlaylists = async ({ playlists, fn, }) => {
     if (!Array.isArray(streams)) {
         throw new Error('Expected an array of associated playlists');
     }
+    const selectedStreams = [];
     for (const stream of streams) {
+        if (stream.isAudio && skipAudioTracks) {
+            continue;
+        }
         if (!playlists.find((playlist) => playlist.src === stream.src)) {
             throw new Error(`The associated playlist ${JSON.stringify(streams)} cannot be selected because it was not in the list of selectable playlists`);
         }
+        selectedStreams.push(stream);
     }
-    return streams;
+    return selectedStreams;
 };
 exports.selectAssociatedPlaylists = selectAssociatedPlaylists;
 const defaultSelectM3uAssociatedPlaylists = ({ associatedPlaylists }) => {

package/dist/containers/m3u/types.d.ts

@@ -67,6 +67,7 @@ export type M3uMediaInfo = {
     default: boolean;
     channels: number | null;
     uri: string;
+    mediaType: string | null;
 };
 export type M3uTextValue = {
     type: 'm3u-text-value';

package/dist/containers/mp3/get-duration.d.ts

@@ -1,2 +1,7 @@
 import type { ParserState } from '../../state/parser-state';
+import type { XingData } from './parse-xing';
+export declare const getDurationFromMp3Xing: ({ xingData, samplesPerFrame, }: {
+    xingData: XingData;
+    samplesPerFrame: number;
+}) => number;
 export declare const getDurationFromMp3: (state: ParserState) => number | null;

package/dist/containers/riff/seek/fetch-idx1.d.ts

@@ -1,13 +1,15 @@
 import type { MediaParserController } from '../../../controller/media-parser-controller';
+import type { PrefetchCache } from '../../../fetch';
 import { type LogLevel } from '../../../log';
 import type { ParseMediaSrc } from '../../../options';
 import type { ReaderInterface } from '../../../readers/reader';
-export declare const fetchIdx1: ({ src, readerInterface, controller, position, logLevel, }: {
+export declare const fetchIdx1: ({ src, readerInterface, controller, position, logLevel, prefetchCache, }: {
     src: ParseMediaSrc;
     readerInterface: ReaderInterface;
     controller: MediaParserController;
     position: number;
     logLevel: LogLevel;
+    prefetchCache: PrefetchCache;
 }) => Promise<{
     entries: import("../riff-box").Idx1Entry[];
     videoTrackIndex: number | null;

package/dist/containers/riff/seek/fetch-idx1.js

@@ -4,12 +4,14 @@ exports.fetchIdx1 = void 0;
 const buffer_iterator_1 = require("../../../iterator/buffer-iterator");
 const log_1 = require("../../../log");
 const expect_riff_box_1 = require("../expect-riff-box");
-const fetchIdx1 = async ({ src, readerInterface, controller, position, logLevel, }) => {
+const fetchIdx1 = async ({ src, readerInterface, controller, position, logLevel, prefetchCache, }) => {
     log_1.Log.verbose(logLevel, 'Making request to fetch idx1 from ', src, 'position', position);
     const result = await readerInterface.read({
         controller,
         range: position,
         src,
+        logLevel,
+        prefetchCache,
     });
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array(), Infinity);
     while (true) {

package/dist/containers/transport-stream/handle-aac-packet.d.ts

@@ -1,5 +1,5 @@
 import type { LogLevel } from '../../log';
-import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { CallbacksState } from '../../state/sample-callbacks';
 import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
 import type { OnAudioTrack } from '../../webcodec-sample-types';
 import type { TransportStreamPacketBuffer } from './process-stream-buffers';
@@ -7,7 +7,7 @@ export declare const handleAacPacket: ({ streamBuffer, programId, offset, sample
     streamBuffer: TransportStreamPacketBuffer;
     programId: number;
     offset: number;
-    sampleCallbacks: SampleCallbacks;
+    sampleCallbacks: CallbacksState;
     logLevel: LogLevel;
     onAudioTrack: OnAudioTrack | null;
     transportStream: TransportStreamState;

package/dist/containers/transport-stream/handle-avc-packet.d.ts

@@ -1,5 +1,5 @@
 import type { LogLevel } from '../../log';
-import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { CallbacksState } from '../../state/sample-callbacks';
 import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
 import type { OnVideoTrack } from '../../webcodec-sample-types';
 import type { TransportStreamPacketBuffer } from './process-stream-buffers';
@@ -8,7 +8,7 @@ export declare const handleAvcPacket: ({ streamBuffer, programId, offset, sample
     streamBuffer: TransportStreamPacketBuffer;
     programId: number;
     offset: number;
-    sampleCallbacks: SampleCallbacks;
+    sampleCallbacks: CallbacksState;
     logLevel: LogLevel;
     onVideoTrack: OnVideoTrack | null;
     transportStream: TransportStreamState;

package/dist/containers/transport-stream/process-audio.d.ts

@@ -1,6 +1,6 @@
 import type { LogLevel } from '../../log';
 import type { TransportStreamStructure } from '../../parse-result';
-import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { CallbacksState } from '../../state/sample-callbacks';
 import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
 import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
 import type { TransportStreamEntry } from './parse-pmt';
@@ -11,7 +11,7 @@ export declare const canProcessAudio: ({ streamBuffer, }: {
 export declare const processAudio: ({ transportStreamEntry, structure, offset, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }: {
     transportStreamEntry: TransportStreamEntry;
     structure: TransportStreamStructure;
-    sampleCallbacks: SampleCallbacks;
+    sampleCallbacks: CallbacksState;
     logLevel: LogLevel;
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;

package/dist/containers/transport-stream/process-stream-buffers.d.ts

@@ -1,6 +1,6 @@
 import type { LogLevel } from '../../log';
 import type { TransportStreamStructure } from '../../parse-result';
-import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { CallbacksState } from '../../state/sample-callbacks';
 import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
 import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
 import type { PacketPes } from './parse-pes';
@@ -21,7 +21,7 @@ export declare const processStreamBuffer: ({ streamBuffer, programId, structure,
     streamBuffer: TransportStreamPacketBuffer;
     programId: number;
     structure: TransportStreamStructure;
-    sampleCallbacks: SampleCallbacks;
+    sampleCallbacks: CallbacksState;
     logLevel: LogLevel;
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;
@@ -30,7 +30,7 @@ export declare const processStreamBuffer: ({ streamBuffer, programId, structure,
 }) => Promise<void>;
 export declare const processFinalStreamBuffers: ({ structure, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }: {
     structure: TransportStreamStructure;
-    sampleCallbacks: SampleCallbacks;
+    sampleCallbacks: CallbacksState;
     logLevel: LogLevel;
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;

package/dist/containers/transport-stream/process-video.d.ts

@@ -1,6 +1,6 @@
 import type { LogLevel } from '../../log';
 import type { TransportStreamStructure } from '../../parse-result';
-import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { CallbacksState } from '../../state/sample-callbacks';
 import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
 import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
 import type { TransportStreamPacketBuffer } from './process-stream-buffers';
@@ -11,7 +11,7 @@ export declare const processVideo: ({ programId, structure, streamBuffer, sample
     programId: number;
     structure: TransportStreamStructure;
     streamBuffer: TransportStreamPacketBuffer;
-    sampleCallbacks: SampleCallbacks;
+    sampleCallbacks: CallbacksState;
     logLevel: LogLevel;
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;

package/dist/containers/wav/get-duration-from-wav.d.ts

@@ -1,3 +1,2 @@
 import type { ParserState } from '../../state/parser-state';
 export declare const getDurationFromWav: (state: ParserState) => number;
-export declare const hasDurationFromWav: (state: ParserState) => number | false;

package/dist/containers/webm/get-sample-from-block.d.ts

@@ -1,6 +1,8 @@
+import type { LogLevel } from '../../log';
 import type { WebmState } from '../../state/matroska/webm';
+import type { CallbacksState } from '../../state/sample-callbacks';
 import type { StructureState } from '../../state/structure';
-import type { AudioOrVideoSample } from '../../webcodec-sample-types';
+import type { AudioOrVideoSample, OnVideoTrack } from '../../webcodec-sample-types';
 import type { BlockSegment, SimpleBlockSegment } from './segments/all-segments';
 type SampleResult = {
     type: 'video-sample';
@@ -14,5 +16,13 @@ type SampleResult = {
 } | {
     type: 'no-sample';
 };
-export declare const getSampleFromBlock: (ebml: BlockSegment | SimpleBlockSegment, webmState: WebmState, offset: number, structureState: StructureState) => SampleResult;
+export declare const getSampleFromBlock: ({ ebml, webmState, offset, structureState, callbacks, logLevel, onVideoTrack, }: {
+    ebml: BlockSegment | SimpleBlockSegment;
+    webmState: WebmState;
+    offset: number;
+    structureState: StructureState;
+    callbacks: CallbacksState;
+    logLevel: LogLevel;
+    onVideoTrack: OnVideoTrack | null;
+}) => Promise<SampleResult>;
 export {};

package/dist/containers/webm/get-sample-from-block.js

@@ -2,22 +2,50 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSampleFromBlock = void 0;
 const buffer_iterator_1 = require("../../iterator/buffer-iterator");
+const register_track_1 = require("../../register-track");
 const parse_avc_1 = require("../avc/parse-avc");
 const get_ready_tracks_1 = require("./get-ready-tracks");
 const all_segments_1 = require("./segments/all-segments");
 const block_simple_block_flags_1 = require("./segments/block-simple-block-flags");
-const addAvcToTrackIfNecessary = ({ partialVideoSample, codec, structureState, webmState, trackNumber, }) => {
-    if (codec === 'V_MPEG4/ISO/AVC' &&
-        (0, get_ready_tracks_1.getTracksFromMatroska)({ structureState, webmState }).missingInfo.length > 0) {
-        const parsed = (0, parse_avc_1.parseAvc)(partialVideoSample.data);
-        for (const parse of parsed) {
-            if (parse.type === 'avc-profile') {
-                webmState.setAvcProfileForTrackNumber(trackNumber, parse);
+const addAvcToTrackAndActivateTrackIfNecessary = async ({ partialVideoSample, codec, structureState, webmState, trackNumber, logLevel, callbacks, onVideoTrack, }) => {
+    if (codec !== 'V_MPEG4/ISO/AVC') {
+        return;
+    }
+    const missingTracks = (0, get_ready_tracks_1.getTracksFromMatroska)({
+        structureState,
+        webmState,
+    }).missingInfo;
+    if (missingTracks.length === 0) {
+        return;
+    }
+    const parsed = (0, parse_avc_1.parseAvc)(partialVideoSample.data);
+    for (const parse of parsed) {
+        if (parse.type === 'avc-profile') {
+            webmState.setAvcProfileForTrackNumber(trackNumber, parse);
+            const track = missingTracks.find((t) => t.trackId === trackNumber);
+            if (!track) {
+                throw new Error('Could not find track ' + trackNumber);
+            }
+            const resolvedTracks = (0, get_ready_tracks_1.getTracksFromMatroska)({
+                structureState,
+                webmState,
+            }).resolved;
+            const resolvedTrack = resolvedTracks.find((t) => t.trackId === trackNumber);
+            if (!resolvedTrack) {
+                throw new Error('Could not find track ' + trackNumber);
             }
+            await (0, register_track_1.registerVideoTrack)({
+                track: resolvedTrack,
+                container: 'webm',
+                logLevel,
+                onVideoTrack,
+                registerVideoSampleCallback: callbacks.registerVideoSampleCallback,
+                tracks: callbacks.tracks,
+            });
         }
     }
 };
-const getSampleFromBlock = (ebml, webmState, offset, structureState) => {
+const getSampleFromBlock = async ({ ebml, webmState, offset, structureState, callbacks, logLevel, onVideoTrack, }) => {
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(ebml.value, ebml.value.length);
     const trackNumber = iterator.getVint();
     if (trackNumber === null) {
@@ -62,12 +90,15 @@ const getSampleFromBlock = (ebml, webmState, offset, structureState) => {
                 partialVideoSample,
             };
         }
-        addAvcToTrackIfNecessary({
+        await addAvcToTrackAndActivateTrackIfNecessary({
             codec,
             partialVideoSample,
             structureState,
             webmState,
             trackNumber,
+            callbacks,
+            logLevel,
+            onVideoTrack,
         });
         const sample = {
             ...partialVideoSample,

package/dist/containers/webm/parse-ebml.js

@@ -131,21 +131,31 @@ const postprocessEbml = async ({ offset, ebml, statesForProcessing: { webmState,
             });
         }
         if (track && track.type === 'video') {
-            await (0, register_track_1.registerVideoTrack)({
-                track,
-                container: 'webm',
-                logLevel,
-                onVideoTrack,
-                registerVideoSampleCallback: callbacks.registerVideoSampleCallback,
-                tracks: callbacks.tracks,
-            });
+            if (track.codec !== make_track_1.NO_CODEC_PRIVATE_SHOULD_BE_DERIVED_FROM_SPS) {
+                await (0, register_track_1.registerVideoTrack)({
+                    track,
+                    container: 'webm',
+                    logLevel,
+                    onVideoTrack,
+                    registerVideoSampleCallback: callbacks.registerVideoSampleCallback,
+                    tracks: callbacks.tracks,
+                });
+            }
         }
     }
     if (ebml.type === 'Timestamp') {
         webmState.setTimestampOffset(offset, ebml.value.value);
     }
     if (ebml.type === 'Block' || ebml.type === 'SimpleBlock') {
-        const sample = (0, get_sample_from_block_1.getSampleFromBlock)(ebml, webmState, offset, structureState);
+        const sample = await (0, get_sample_from_block_1.getSampleFromBlock)({
+            ebml,
+            webmState,
+            offset,
+            structureState,
+            callbacks,
+            logLevel,
+            onVideoTrack,
+        });
         if (sample.type === 'video-sample') {
             await callbacks.onVideoSample(sample.videoSample.trackId, sample.videoSample);
             return {
@@ -182,7 +192,15 @@ const postprocessEbml = async ({ offset, ebml, statesForProcessing: { webmState,
         const hasReferenceBlock = ebml.value.find((c) => c.type === 'ReferenceBlock');
         const sample = block.value.length === 0
             ? null
-            : (0, get_sample_from_block_1.getSampleFromBlock)(block, webmState, offset, structureState);
+            : await (0, get_sample_from_block_1.getSampleFromBlock)({
+                ebml: block,
+                webmState,
+                offset,
+                structureState,
+                callbacks,
+                logLevel,
+                onVideoTrack,
+            });
         if (sample && sample.type === 'partial-video-sample') {
             const completeFrame = {
                 ...sample.partialVideoSample,

package/dist/containers/webm/seek/fetch-web-cues.d.ts

@@ -1,12 +1,14 @@
 import type { MediaParserController } from '../../../controller/media-parser-controller';
+import type { PrefetchCache } from '../../../fetch';
 import type { LogLevel } from '../../../log';
 import type { ParseMediaSrc } from '../../../options';
 import type { ReaderInterface } from '../../../readers/reader';
 import type { MatroskaCue } from './format-cues';
-export declare const fetchWebmCues: ({ src, readerInterface, controller, position, logLevel, }: {
+export declare const fetchWebmCues: ({ src, readerInterface, controller, position, logLevel, prefetchCache, }: {
     src: ParseMediaSrc;
     readerInterface: ReaderInterface;
     controller: MediaParserController;
     position: number;
     logLevel: LogLevel;
+    prefetchCache: PrefetchCache;
 }) => Promise<MatroskaCue[] | null>;

package/dist/containers/webm/seek/fetch-web-cues.js

@@ -4,11 +4,13 @@ exports.fetchWebmCues = void 0;
 const buffer_iterator_1 = require("../../../iterator/buffer-iterator");
 const segments_1 = require("../segments");
 const format_cues_1 = require("./format-cues");
-const fetchWebmCues = async ({ src, readerInterface, controller, position, logLevel, }) => {
+const fetchWebmCues = async ({ src, readerInterface, controller, position, logLevel, prefetchCache, }) => {
     const result = await readerInterface.read({
         controller,
         range: position,
         src,
+        logLevel,
+        prefetchCache,
     });
     const { value } = await result.reader.reader.read();
     if (!value) {

package/dist/containers/webm/state-for-processing.d.ts

@@ -1,12 +1,12 @@
 import type { LogLevel } from '../../log';
 import type { WebmState } from '../../state/matroska/webm';
 import type { ParserState } from '../../state/parser-state';
-import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { CallbacksState } from '../../state/sample-callbacks';
 import type { StructureState } from '../../state/structure';
 import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
 export type WebmRequiredStatesForProcessing = {
     webmState: WebmState;
-    callbacks: SampleCallbacks;
+    callbacks: CallbacksState;
     logLevel: LogLevel;
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;

package/dist/controller/media-parser-controller.d.ts

@@ -7,7 +7,7 @@ export type MediaParserController = {
     abort: (reason?: any) => void;
     pause: PauseSignal['pause'];
     resume: PauseSignal['resume'];
-    _experimentalSeek: SeekSignal['seek'];
+    seek: SeekSignal['seek'];
     addEventListener: MediaParserEmitter['addEventListener'];
     removeEventListener: MediaParserEmitter['removeEventListener'];
     getSeekingHints: () => Promise<SeekingHints | null>;

package/dist/controller/media-parser-controller.js

@@ -14,7 +14,11 @@ const mediaParserController = () => {
     const performedSeeksSignal = (0, performed_seeks_stats_1.performedSeeksStats)();
     const checkForAbortAndPause = async () => {
         if (abortController.signal.aborted) {
-            throw new errors_1.MediaParserAbortError('Aborted');
+            const err = new errors_1.MediaParserAbortError('Aborted');
+            if (abortController.signal.reason) {
+                err.cause = abortController.signal.reason;
+            }
+            throw err;
         }
         await pauseSignal.waitUntilResume();
     };
@@ -37,7 +41,7 @@ const mediaParserController = () => {
             abortController.abort(reason);
             emitter.dispatchAbort(reason);
         },
-        _experimentalSeek: seekSignal.seek,
+        seek: seekSignal.seek,
         pause: pauseSignal.pause,
         resume: pauseSignal.resume,
         addEventListener: emitter.addEventListener,

package/dist/controller/seek-signal.d.ts

@@ -10,10 +10,6 @@ type SeekToTime = {
     type: 'keyframe-before-time';
     timeInSeconds: number;
 };
-type SeekToByte = {
-    type: 'byte';
-    byte: number;
-};
-export type Seek = SeekToTime | SeekToByte;
+export type Seek = SeekToTime;
 export declare const makeSeekSignal: (emitter: MediaParserEmitter) => SeekSignal;
 export {};

package/dist/download-and-parse-media.js

@@ -23,7 +23,7 @@ const downloadAndParseMedia = async (options) => {
         onDimensions: (_f = options.onDimensions) !== null && _f !== void 0 ? _f : null,
         selectM3uStream: (_g = options.selectM3uStream) !== null && _g !== void 0 ? _g : select_stream_1.defaultSelectM3uStreamFn,
         selectM3uAssociatedPlaylists: (_h = options.selectM3uAssociatedPlaylists) !== null && _h !== void 0 ? _h : select_stream_1.defaultSelectM3uAssociatedPlaylists,
-        mp4HeaderSegment: (_j = options.mp4HeaderSegment) !== null && _j !== void 0 ? _j : null,
+        m3uPlaylistContext: (_j = options.m3uPlaylistContext) !== null && _j !== void 0 ? _j : null,
         onDiscardedData: async (data) => {
             await content.write(data);
         },