@remotion/media-parser 4.0.290 → 4.0.292

package/dist/state/iso-base-media/cached-sample-positions.d.ts

@@ -1,3 +1,4 @@
+import type { JumpMark } from '../../containers/iso-base-media/mdat/calculate-jump-marks';
 import type { SamplePosition } from '../../get-sample-positions';
 import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
 import type { ParserState } from '../parser-state';
@@ -5,11 +6,24 @@ export type FlatSample = {
     track: VideoTrack | AudioTrack | OtherTrack;
     samplePosition: SamplePosition;
 };
+export type MinimalFlatSampleForTesting = {
+    track: {
+        trackId: number;
+        timescale: number;
+        type: 'audio' | 'video' | 'other';
+    };
+    samplePosition: {
+        dts: number;
+        offset: number;
+    };
+};
 export declare const calculateFlatSamples: (state: ParserState) => {
     track: VideoTrack | AudioTrack | OtherTrack;
     samplePosition: SamplePosition;
-}[];
+}[][];
 export declare const cachedSamplePositionsState: () => {
     getSamples: (mdatStart: number) => FlatSample[] | null;
     setSamples: (mdatStart: number, samples: FlatSample[]) => void;
+    setJumpMarks: (mdatStart: number, marks: JumpMark[]) => void;
+    getJumpMarks: (mdatStart: number) => JumpMark[];
 };

package/dist/state/iso-base-media/cached-sample-positions.js

@@ -11,8 +11,7 @@ const calculateFlatSamples = (state) => {
         ...tracks.audioTracks,
         ...tracks.otherTracks,
     ];
-    const flatSamples = allTracks
-        .map((track) => {
+    const flatSamples = allTracks.map((track) => {
         const { samplePositions } = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
             trakBox: track.trakBox,
             moofBoxes: (0, traversal_1.getMoofBoxes)(state.structure.getIsoStructure().boxes),
@@ -24,13 +23,13 @@ const calculateFlatSamples = (state) => {
                 samplePosition,
             };
         });
-    })
-        .flat(1);
+    });
     return flatSamples;
 };
 exports.calculateFlatSamples = calculateFlatSamples;
 const cachedSamplePositionsState = () => {
     const cachedForMdatStart = {};
+    const jumpMarksForMdatStart = {};
     return {
         getSamples: (mdatStart) => {
             if (cachedForMdatStart[mdatStart]) {
@@ -41,6 +40,12 @@ const cachedSamplePositionsState = () => {
         setSamples: (mdatStart, samples) => {
             cachedForMdatStart[mdatStart] = samples;
         },
+        setJumpMarks: (mdatStart, marks) => {
+            jumpMarksForMdatStart[mdatStart] = marks;
+        },
+        getJumpMarks: (mdatStart) => {
+            return jumpMarksForMdatStart[mdatStart];
+        },
     };
 };
 exports.cachedSamplePositionsState = cachedSamplePositionsState;

package/dist/state/iso-base-media/iso-state.d.ts

@@ -1,17 +1,21 @@
 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 isoBaseMediaState: ({ contentLength, controller, readerInterface, src, logLevel, }: {
+export declare const isoBaseMediaState: ({ contentLength, controller, readerInterface, src, logLevel, prefetchCache, }: {
     contentLength: number;
     controller: MediaParserController;
     readerInterface: ReaderInterface;
     src: ParseMediaSrc;
     logLevel: LogLevel;
+    prefetchCache: PrefetchCache;
 }) => {
     flatSamples: {
         getSamples: (mdatStart: number) => import("./cached-sample-positions").FlatSample[] | null;
         setSamples: (mdatStart: number, samples: import("./cached-sample-positions").FlatSample[]) => void;
+        setJumpMarks: (mdatStart: number, marks: import("../../containers/iso-base-media/mdat/calculate-jump-marks").JumpMark[]) => void;
+        getJumpMarks: (mdatStart: number) => import("../../containers/iso-base-media/mdat/calculate-jump-marks").JumpMark[];
     };
     moov: {
         setMoovBox: (moov: {

package/dist/state/iso-base-media/iso-state.js

@@ -6,7 +6,7 @@ const lazy_mfra_load_1 = require("./lazy-mfra-load");
 const moov_box_1 = require("./moov-box");
 const precomputed_moof_1 = require("./precomputed-moof");
 const precomputed_tfra_1 = require("./precomputed-tfra");
-const isoBaseMediaState = ({ contentLength, controller, readerInterface, src, logLevel, }) => {
+const isoBaseMediaState = ({ contentLength, controller, readerInterface, src, logLevel, prefetchCache, }) => {
     return {
         flatSamples: (0, cached_sample_positions_1.cachedSamplePositionsState)(),
         moov: (0, moov_box_1.moovState)(),
@@ -16,6 +16,7 @@ const isoBaseMediaState = ({ contentLength, controller, readerInterface, src, lo
             readerInterface,
             src,
             logLevel,
+            prefetchCache,
         }),
         moof: (0, precomputed_moof_1.precomputedMoofState)(),
         tfra: (0, precomputed_tfra_1.precomputedTfraState)(),

package/dist/state/iso-base-media/lazy-mfra-load.d.ts

@@ -1,15 +1,17 @@
 import type { IsoBaseMediaBox } from '../../containers/iso-base-media/base-media-box';
 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 { IsoBaseMediaSeekingHints } from '../../seeking-hints';
-export declare const lazyMfraLoad: ({ contentLength, controller, readerInterface, src, logLevel, }: {
+export declare const lazyMfraLoad: ({ contentLength, controller, readerInterface, src, logLevel, prefetchCache, }: {
     contentLength: number;
     controller: MediaParserController;
     readerInterface: ReaderInterface;
     src: ParseMediaSrc;
     logLevel: LogLevel;
+    prefetchCache: PrefetchCache;
 }) => {
     triggerLoad: () => Promise<IsoBaseMediaBox[] | null>;
     getIfAlreadyLoaded: () => IsoBaseMediaBox[] | null;

package/dist/state/iso-base-media/lazy-mfra-load.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.lazyMfraLoad = void 0;
 const get_mfra_seeking_box_1 = require("../../containers/iso-base-media/get-mfra-seeking-box");
 const log_1 = require("../../log");
-const lazyMfraLoad = ({ contentLength, controller, readerInterface, src, logLevel, }) => {
+const lazyMfraLoad = ({ contentLength, controller, readerInterface, src, logLevel, prefetchCache, }) => {
     let prom = null;
     let result = null;
     const triggerLoad = () => {
@@ -17,6 +17,7 @@ const lazyMfraLoad = ({ contentLength, controller, readerInterface, src, logLeve
             readerInterface,
             src,
             logLevel,
+            prefetchCache,
         }).then((boxes) => {
             log_1.Log.verbose(logLevel, 'Lazily found mfra atom.');
             result = boxes;

package/dist/state/keyframes.js

@@ -10,6 +10,7 @@ const keyframesState = () => {
         keyframes.push(keyframe);
     };
     const getKeyframes = () => {
+        keyframes.sort((a, b) => a.positionInBytes - b.positionInBytes);
         return keyframes;
     };
     const setFromSeekingHints = (keyframesFromHints) => {

package/dist/state/m3u-state.d.ts

@@ -9,10 +9,13 @@ export type M3uStreamOrInitialUrl = {
     type: 'initial-url';
     url: string;
 };
-export type ExistingM3uRun = {
-    continue: () => Promise<ExistingM3uRun | null>;
+export type M3uRun = {
+    continue: () => Promise<M3uRun | null>;
     abort: () => void;
 };
+type M3uSeek = {
+    targetTime: number;
+};
 export declare const m3uState: (logLevel: LogLevel) => {
     setSelectedMainPlaylist: (stream: M3uStreamOrInitialUrl) => void;
     getSelectedMainPlaylist: () => M3uStreamOrInitialUrl | null;
@@ -25,19 +28,22 @@ export declare const m3uState: (logLevel: LogLevel) => {
     setReadyToIterateOverM3u: () => void;
     isReadyToIterateOverM3u: () => boolean;
     setAllChunksProcessed: (src: string) => void;
+    clearAllChunksProcessed: () => void;
     getAllChunksProcessedForPlaylist: (src: string) => boolean;
     getAllChunksProcessedOverall: () => boolean;
     setHasFinishedManifest: () => void;
     hasFinishedManifest: () => boolean;
-    setM3uStreamRun: (playlistUrl: string, run: ExistingM3uRun | null) => void;
+    setM3uStreamRun: (playlistUrl: string, run: M3uRun | null) => void;
     setTracksDone: (playlistUrl: string) => boolean;
     getTrackDone: (playlistUrl: string) => boolean;
-    getM3uStreamRun: (playlistUrl: string) => ExistingM3uRun;
+    clearTracksDone: () => void;
+    getM3uStreamRun: (playlistUrl: string) => M3uRun;
     abortM3UStreamRuns: () => void;
     setAssociatedPlaylists: (playlists: M3uAssociatedPlaylist[]) => void;
     getAssociatedPlaylists: () => M3uAssociatedPlaylist[] | null;
     getSelectedPlaylists: () => string[];
     sampleSorter: {
+        clearSamples: () => void;
         addToStreamWithTrack: (src: string) => void;
         addVideoStreamToConsider: (src: string, callback: OnVideoSample) => void;
         addAudioStreamToConsider: (src: string, callback: OnAudioSample) => void;
@@ -49,5 +55,10 @@ export declare const m3uState: (logLevel: LogLevel) => {
     };
     setMp4HeaderSegment: (playlistUrl: string, structure: IsoBaseMediaStructure) => void;
     getMp4HeaderSegment: (playlistUrl: string) => IsoBaseMediaStructure;
+    setSeekToSecondsToProcess: (playlistUrl: string, m3uSeek: M3uSeek | null) => void;
+    getSeekToSecondsToProcess: (playlistUrl: string) => M3uSeek | null;
+    setNextSeekShouldSubtractChunks: (playlistUrl: string, chunks: number) => void;
+    getNextSeekShouldSubtractChunks: (playlistUrl: string) => number;
 };
 export type M3uState = ReturnType<typeof m3uState>;
+export {};

package/dist/state/m3u-state.js

@@ -10,6 +10,8 @@ const m3uState = (logLevel) => {
     const hasEmittedAudioTrack = {};
     const hasEmittedDoneWithTracks = {};
     let hasFinishedManifest = false;
+    const seekToSecondsToProcess = {};
+    const nextSeekShouldSubtractChunks = {};
     let readyToIterateOverM3u = false;
     const allChunksProcessed = {};
     const m3uStreamRuns = {};
@@ -73,6 +75,11 @@ const m3uState = (logLevel) => {
         setAllChunksProcessed: (src) => {
             allChunksProcessed[src] = true;
         },
+        clearAllChunksProcessed: () => {
+            Object.keys(allChunksProcessed).forEach((key) => {
+                delete allChunksProcessed[key];
+            });
+        },
         getAllChunksProcessedForPlaylist,
         getAllChunksProcessedOverall: () => {
             if (!selectedMainPlaylist) {
@@ -100,6 +107,11 @@ const m3uState = (logLevel) => {
         getTrackDone: (playlistUrl) => {
             return tracksDone[playlistUrl];
         },
+        clearTracksDone: () => {
+            Object.keys(tracksDone).forEach((key) => {
+                delete tracksDone[key];
+            });
+        },
         getM3uStreamRun: (playlistUrl) => { var _a; return (_a = m3uStreamRuns[playlistUrl]) !== null && _a !== void 0 ? _a : null; },
         abortM3UStreamRuns: () => {
             const values = Object.values(m3uStreamRuns);
@@ -119,6 +131,14 @@ const m3uState = (logLevel) => {
         sampleSorter: (0, sample_sorter_1.sampleSorter)({ logLevel, getAllChunksProcessedForPlaylist }),
         setMp4HeaderSegment,
         getMp4HeaderSegment,
+        setSeekToSecondsToProcess: (playlistUrl, m3uSeek) => {
+            seekToSecondsToProcess[playlistUrl] = m3uSeek;
+        },
+        getSeekToSecondsToProcess: (playlistUrl) => { var _a; return (_a = seekToSecondsToProcess[playlistUrl]) !== null && _a !== void 0 ? _a : null; },
+        setNextSeekShouldSubtractChunks: (playlistUrl, chunks) => {
+            nextSeekShouldSubtractChunks[playlistUrl] = chunks;
+        },
+        getNextSeekShouldSubtractChunks: (playlistUrl) => { var _a; return (_a = nextSeekShouldSubtractChunks[playlistUrl]) !== null && _a !== void 0 ? _a : 0; },
     };
 };
 exports.m3uState = m3uState;

package/dist/state/matroska/lazy-cues-fetch.d.ts

@@ -1,14 +1,16 @@
 import type { MatroskaCue } from '../../containers/webm/seek/format-cues';
 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 { WebmSeekingHints } from '../../seeking-hints';
-export declare const lazyCuesFetch: ({ controller, logLevel, readerInterface, src, }: {
+export declare const lazyCuesFetch: ({ controller, logLevel, readerInterface, src, prefetchCache, }: {
     controller: MediaParserController;
     logLevel: LogLevel;
     readerInterface: ReaderInterface;
     src: ParseMediaSrc;
+    prefetchCache: PrefetchCache;
 }) => {
     triggerLoad: (position: number, segmentOffset: number) => Promise<MatroskaCue[] | null>;
     getLoadedCues: () => Promise<{

package/dist/state/matroska/lazy-cues-fetch.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.lazyCuesFetch = void 0;
 const fetch_web_cues_1 = require("../../containers/webm/seek/fetch-web-cues");
 const log_1 = require("../../log");
-const lazyCuesFetch = ({ controller, logLevel, readerInterface, src, }) => {
+const lazyCuesFetch = ({ controller, logLevel, readerInterface, src, prefetchCache, }) => {
     let prom = null;
     let sOffset = null;
     let result = null;
@@ -25,6 +25,7 @@ const lazyCuesFetch = ({ controller, logLevel, readerInterface, src, }) => {
             position,
             readerInterface,
             src,
+            prefetchCache,
         }).then((cues) => {
             log_1.Log.verbose(logLevel, 'Cues loaded');
             result = cues;

package/dist/state/matroska/webm.d.ts

@@ -2,6 +2,7 @@ import type { AvcProfileInfo } from '../../containers/avc/parse-avc';
 import type { OnTrackEntrySegment } from '../../containers/webm/segments';
 import type { TrackInfo } from '../../containers/webm/segments/track-entry';
 import type { MediaParserController } from '../../controller/media-parser-controller';
+import type { PrefetchCache } from '../../fetch';
 import type { BufferIterator } from '../../iterator/buffer-iterator';
 import type { LogLevel } from '../../log';
 import type { ParseMediaSrc } from '../../options';
@@ -16,11 +17,12 @@ export type ClusterSection = {
     size: number;
     segment: number;
 };
-export declare const webmState: ({ controller, logLevel, readerInterface, src, }: {
+export declare const webmState: ({ controller, logLevel, readerInterface, src, prefetchCache, }: {
     controller: MediaParserController;
     logLevel: LogLevel;
     readerInterface: ReaderInterface;
     src: ParseMediaSrc;
+    prefetchCache: PrefetchCache;
 }) => {
     cues: {
         triggerLoad: (position: number, segmentOffset: number) => Promise<import("../../containers/webm/seek/format-cues").MatroskaCue[] | null>;

package/dist/state/matroska/webm.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.webmState = void 0;
 const traversal_1 = require("../../containers/webm/traversal");
 const lazy_cues_fetch_1 = require("./lazy-cues-fetch");
-const webmState = ({ controller, logLevel, readerInterface, src, }) => {
+const webmState = ({ controller, logLevel, readerInterface, src, prefetchCache, }) => {
     const trackEntries = {};
     const onTrackEntrySegment = (trackEntry) => {
         var _a;
@@ -70,6 +70,7 @@ const webmState = ({ controller, logLevel, readerInterface, src, }) => {
         logLevel,
         readerInterface,
         src,
+        prefetchCache,
     });
     const getTimeStampMapForSeekingHints = () => {
         return timestampMap;

package/dist/state/parser-state.d.ts

@@ -1,11 +1,11 @@
 import type { AvcPPs, AvcProfileInfo } from '../containers/avc/parse-avc';
 import type { SelectM3uAssociatedPlaylistsFn, SelectM3uStreamFn } from '../containers/m3u/select-stream';
 import type { MediaParserController } from '../controller/media-parser-controller';
+import type { PrefetchCache } from '../fetch';
 import type { Options, ParseMediaFields } from '../fields';
 import { type BufferIterator } from '../iterator/buffer-iterator';
 import { type LogLevel } from '../log';
-import type { AllParseMediaFields, OnDiscardedData, ParseMediaCallbacks, ParseMediaMode, ParseMediaResult, ParseMediaSrc } from '../options';
-import type { IsoBaseMediaStructure } from '../parse-result';
+import type { AllParseMediaFields, M3uPlaylistContext, OnDiscardedData, ParseMediaCallbacks, ParseMediaMode, ParseMediaResult, ParseMediaSrc } from '../options';
 import type { Reader, ReaderInterface } from '../readers/reader';
 import type { OnAudioTrack, OnVideoTrack } from '../webcodec-sample-types';
 export type InternalStats = {
@@ -16,7 +16,7 @@ export type SpsAndPps = {
     sps: AvcProfileInfo;
     pps: AvcPPs;
 };
-export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, makeSamplesStartAtZero, }: {
+export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, m3uPlaylistContext, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, makeSamplesStartAtZero, prefetchCache, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     controller: MediaParserController;
@@ -30,7 +30,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     onDiscardedData: OnDiscardedData | null;
     selectM3uStreamFn: SelectM3uStreamFn;
     selectM3uAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
-    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    m3uPlaylistContext: M3uPlaylistContext | null;
     contentType: string | null;
     name: string;
     callbacks: ParseMediaCallbacks;
@@ -38,6 +38,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     mimeType: string | null;
     initialReaderInstance: Reader;
     makeSamplesStartAtZero: boolean;
+    prefetchCache: PrefetchCache;
 }) => {
     riff: {
         getAvcProfile: () => SpsAndPps | null;
@@ -136,6 +137,8 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         flatSamples: {
             getSamples: (mdatStart: number) => import("./iso-base-media/cached-sample-positions").FlatSample[] | null;
             setSamples: (mdatStart: number, samples: import("./iso-base-media/cached-sample-positions").FlatSample[]) => void;
+            setJumpMarks: (mdatStart: number, marks: import("../containers/iso-base-media/mdat/calculate-jump-marks").JumpMark[]) => void;
+            getJumpMarks: (mdatStart: number) => import("../containers/iso-base-media/mdat/calculate-jump-marks").JumpMark[];
         };
         moov: {
             setMoovBox: (moov: {
@@ -213,19 +216,22 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         setReadyToIterateOverM3u: () => void;
         isReadyToIterateOverM3u: () => boolean;
         setAllChunksProcessed: (src: string) => void;
+        clearAllChunksProcessed: () => void;
         getAllChunksProcessedForPlaylist: (src: string) => boolean;
         getAllChunksProcessedOverall: () => boolean;
         setHasFinishedManifest: () => void;
         hasFinishedManifest: () => boolean;
-        setM3uStreamRun: (playlistUrl: string, run: import("./m3u-state").ExistingM3uRun | null) => void;
+        setM3uStreamRun: (playlistUrl: string, run: import("./m3u-state").M3uRun | null) => void;
         setTracksDone: (playlistUrl: string) => boolean;
         getTrackDone: (playlistUrl: string) => boolean;
-        getM3uStreamRun: (playlistUrl: string) => import("./m3u-state").ExistingM3uRun;
+        clearTracksDone: () => void;
+        getM3uStreamRun: (playlistUrl: string) => import("./m3u-state").M3uRun;
         abortM3UStreamRuns: () => void;
         setAssociatedPlaylists: (playlists: import("..").M3uAssociatedPlaylist[]) => void;
         getAssociatedPlaylists: () => import("..").M3uAssociatedPlaylist[] | null;
         getSelectedPlaylists: () => string[];
         sampleSorter: {
+            clearSamples: () => void;
             addToStreamWithTrack: (src: string) => void;
             addVideoStreamToConsider: (src: string, callback: import("../webcodec-sample-types").OnVideoSample) => void;
             addAudioStreamToConsider: (src: string, callback: import("../webcodec-sample-types").OnAudioSample) => void;
@@ -235,8 +241,16 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
             addVideoSample: (src: string, sample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
             getNextStreamToRun: (streams: string[]) => string;
         };
-        setMp4HeaderSegment: (playlistUrl: string, structure: IsoBaseMediaStructure) => void;
-        getMp4HeaderSegment: (playlistUrl: string) => IsoBaseMediaStructure;
+        setMp4HeaderSegment: (playlistUrl: string, structure: import("../parse-result").IsoBaseMediaStructure) => void;
+        getMp4HeaderSegment: (playlistUrl: string) => import("../parse-result").IsoBaseMediaStructure;
+        setSeekToSecondsToProcess: (playlistUrl: string, m3uSeek: {
+            targetTime: number;
+        } | null) => void;
+        getSeekToSecondsToProcess: (playlistUrl: string) => {
+            targetTime: number;
+        } | null;
+        setNextSeekShouldSubtractChunks: (playlistUrl: string, chunks: number) => void;
+        getNextSeekShouldSubtractChunks: (playlistUrl: string) => number;
     };
     timings: {
         timeIterating: number;
@@ -250,6 +264,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         onAudioSample: (trackId: number, audioSample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
         onVideoSample: (trackId: number, videoSample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
         canSkipTracksState: {
+            doFieldsNeedTracks: () => boolean;
             canSkipTracks: () => boolean;
         };
         registerAudioSampleCallback: (id: number, callback: import("../webcodec-sample-types").OnAudioSample | null) => Promise<void>;
@@ -275,11 +290,11 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         setFromSeekingHints: (keyframesFromHints: import("../options").MediaParserKeyframe[]) => void;
     };
     structure: {
-        getStructureOrNull: () => import("../parse-result").MediaParserStructureUnstable | null;
-        getStructure: () => import("../parse-result").MediaParserStructureUnstable;
-        setStructure: (value: import("../parse-result").MediaParserStructureUnstable) => void;
+        getStructureOrNull: () => import("..").MediaParserStructureUnstable | null;
+        getStructure: () => import("..").MediaParserStructureUnstable;
+        setStructure: (value: import("..").MediaParserStructureUnstable) => void;
         getFlacStructure: () => import("../containers/flac/types").FlacStructure;
-        getIsoStructure: () => IsoBaseMediaStructure;
+        getIsoStructure: () => import("../parse-result").IsoBaseMediaStructure;
         getMp3Structure: () => import("../parse-result").Mp3Structure;
         getM3uStructure: () => import("../containers/m3u/types").M3uStructure;
         getRiffStructure: () => import("../containers/riff/riff-box").RiffStructure;
@@ -402,7 +417,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     discardReadBytes: (force: boolean) => Promise<void>;
     selectM3uStreamFn: SelectM3uStreamFn;
     selectM3uAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
-    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    m3uPlaylistContext: M3uPlaylistContext | null;
     contentType: string | null;
     name: string;
     returnValue: ParseMediaResult<AllParseMediaFields>;
@@ -419,5 +434,6 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         reset: () => void;
     };
     makeSamplesStartAtZero: boolean;
+    prefetchCache: PrefetchCache;
 };
 export type ParserState = ReturnType<typeof makeParserState>;

package/dist/state/parser-state.js

@@ -22,7 +22,7 @@ const structure_1 = require("./structure");
 const timings_1 = require("./timings");
 const transport_stream_1 = require("./transport-stream/transport-stream");
 const video_section_1 = require("./video-section");
-const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, makeSamplesStartAtZero, }) => {
+const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, m3uPlaylistContext, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, makeSamplesStartAtZero, prefetchCache, }) => {
     let skippedBytes = 0;
     const returnValue = {};
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), contentLength);
@@ -53,22 +53,35 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
         callbacks,
     });
     return {
-        riff: (0, riff_1.riffSpecificState)({ controller, logLevel, readerInterface, src }),
+        riff: (0, riff_1.riffSpecificState)({
+            controller,
+            logLevel,
+            readerInterface,
+            src,
+            prefetchCache,
+        }),
         transportStream: (0, transport_stream_1.transportStreamState)(),
-        webm: (0, webm_1.webmState)({ controller, logLevel, readerInterface, src }),
+        webm: (0, webm_1.webmState)({
+            controller,
+            logLevel,
+            readerInterface,
+            src,
+            prefetchCache,
+        }),
         iso: (0, iso_state_1.isoBaseMediaState)({
             contentLength,
             controller,
             readerInterface,
             src,
             logLevel,
+            prefetchCache,
         }),
         mp3,
         aac: (0, aac_state_1.aacState)(),
         flac: (0, flac_state_1.flacState)(),
         m3u: (0, m3u_state_1.m3uState)(logLevel),
         timings,
-        callbacks: (0, sample_callbacks_1.sampleCallback)({
+        callbacks: (0, sample_callbacks_1.callbacksState)({
             controller,
             hasAudioTrackHandlers,
             hasVideoTrackHandlers,
@@ -109,7 +122,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
         discardReadBytes,
         selectM3uStreamFn,
         selectM3uAssociatedPlaylistsFn,
-        mp4HeaderSegment,
+        m3uPlaylistContext,
         contentType,
         name,
         returnValue,
@@ -120,6 +133,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
         currentReader: currentReaderState,
         seekInfiniteLoop,
         makeSamplesStartAtZero,
+        prefetchCache,
     };
 };
 exports.makeParserState = makeParserState;

package/dist/state/riff/lazy-idx1-fetch.d.ts

@@ -1,13 +1,15 @@
 import type { RiffSeekingHints } from '../../containers/riff/seeking-hints';
 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 lazyIdx1Fetch: ({ controller, logLevel, readerInterface, src, }: {
+export declare const lazyIdx1Fetch: ({ controller, logLevel, readerInterface, src, prefetchCache, }: {
     controller: MediaParserController;
     logLevel: LogLevel;
     readerInterface: ReaderInterface;
     src: ParseMediaSrc;
+    prefetchCache: PrefetchCache;
 }) => {
     triggerLoad: (position: number) => Promise<{
         entries: import("../../containers/riff/riff-box").Idx1Entry[];

package/dist/state/riff/lazy-idx1-fetch.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lazyIdx1Fetch = void 0;
 const fetch_idx1_1 = require("../../containers/riff/seek/fetch-idx1");
-const lazyIdx1Fetch = ({ controller, logLevel, readerInterface, src, }) => {
+const lazyIdx1Fetch = ({ controller, logLevel, readerInterface, src, prefetchCache, }) => {
     let prom = null;
     let result = null;
     const triggerLoad = (position) => {
@@ -18,6 +18,7 @@ const lazyIdx1Fetch = ({ controller, logLevel, readerInterface, src, }) => {
             position,
             readerInterface,
             src,
+            prefetchCache,
         }).then((entries) => {
             prom = null;
             result = entries;

package/dist/state/riff.d.ts

@@ -1,14 +1,16 @@
 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 { SpsAndPps } from './parser-state';
 type AvcProfileInfoCallback = (profile: SpsAndPps) => Promise<void>;
-export declare const riffSpecificState: ({ controller, logLevel, readerInterface, src, }: {
+export declare const riffSpecificState: ({ controller, logLevel, readerInterface, src, prefetchCache, }: {
     controller: MediaParserController;
     logLevel: LogLevel;
     readerInterface: ReaderInterface;
     src: ParseMediaSrc;
+    prefetchCache: PrefetchCache;
 }) => {
     getAvcProfile: () => SpsAndPps | null;
     onProfile: (profile: SpsAndPps) => Promise<void>;

package/dist/state/riff.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.riffSpecificState = void 0;
 const lazy_idx1_fetch_1 = require("./riff/lazy-idx1-fetch");
 const sample_counter_1 = require("./riff/sample-counter");
-const riffSpecificState = ({ controller, logLevel, readerInterface, src, }) => {
+const riffSpecificState = ({ controller, logLevel, readerInterface, src, prefetchCache, }) => {
     let avcProfile = null;
     let nextTrackIndex = 0;
     const profileCallbacks = [];
@@ -22,6 +22,7 @@ const riffSpecificState = ({ controller, logLevel, readerInterface, src, }) => {
         logLevel,
         readerInterface,
         src,
+        prefetchCache,
     });
     const sampleCounter = (0, sample_counter_1.riffSampleCounter)();
     return {

package/dist/state/sample-callbacks.d.ts

@@ -7,7 +7,7 @@ import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../webcod
 import { type KeyframesState } from './keyframes';
 import type { SamplesObservedState } from './samples-observed/slow-duration-fps';
 import type { StructureState } from './structure';
-export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, samplesObserved, structure, src, seekSignal, logLevel, }: {
+export declare const callbacksState: ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, samplesObserved, structure, src, seekSignal, logLevel, }: {
     controller: MediaParserController;
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
@@ -24,6 +24,7 @@ export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVi
     onAudioSample: (trackId: number, audioSample: AudioOrVideoSample) => Promise<void>;
     onVideoSample: (trackId: number, videoSample: AudioOrVideoSample) => Promise<void>;
     canSkipTracksState: {
+        doFieldsNeedTracks: () => boolean;
         canSkipTracks: () => boolean;
     };
     registerAudioSampleCallback: (id: number, callback: OnAudioSample | null) => Promise<void>;
@@ -40,4 +41,4 @@ export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVi
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
 };
-export type SampleCallbacks = ReturnType<typeof sampleCallback>;
+export type CallbacksState = ReturnType<typeof callbacksState>;

package/dist/state/sample-callbacks.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sampleCallback = void 0;
+exports.callbacksState = void 0;
 const log_1 = require("../log");
 const can_skip_tracks_1 = require("./can-skip-tracks");
 const has_tracks_section_1 = require("./has-tracks-section");
 const need_samples_for_fields_1 = require("./need-samples-for-fields");
-const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, samplesObserved, structure, src, seekSignal, logLevel, }) => {
+const callbacksState = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, samplesObserved, structure, src, seekSignal, logLevel, }) => {
     const videoSampleCallbacks = {};
     const audioSampleCallbacks = {};
     const queuedAudioSamples = {};
@@ -102,4 +102,4 @@ const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandle
         hasVideoTrackHandlers,
     };
 };
-exports.sampleCallback = sampleCallback;
+exports.callbacksState = callbacksState;