@remotion/media-parser 4.0.289 → 4.0.291

package/dist/esm/worker.mjs

@@ -144,8 +144,14 @@ var deserializeError = (error) => {
       });
     case "MediaParserAbortError":
       return new MediaParserAbortError(error.errorMessage);
-    default:
+    case "Error":
+      return new Error(error.errorMessage);
+    case "AbortError":
       return new Error(error.errorMessage);
+    case "NotReadableError":
+      return new Error(error.errorMessage);
+    default:
+      throw new Error(`Unknown error name: ${error}`);
   }
 };
 
@@ -280,6 +286,7 @@ var parseMediaOnWorkerImplementation = async ({ controller, reader, ...params },
     if (data.type === "response-error") {
       cleanup();
       const error = deserializeError(data);
+      error.stack = data.errorStack;
       reject(error);
       if (data.errorName === "MediaParserAbortError") {
         finalSeekingHints = data.seekingHints;

package/dist/get-audio-codec.js

@@ -223,6 +223,9 @@ const getAudioCodecFromAudioCodecInfo = (codec) => {
     if (codec.format === 'ac-3') {
         return 'ac3';
     }
+    if (codec.format === 'Opus') {
+        return 'opus';
+    }
     if (codec.format === 'mp4a') {
         if (codec.primarySpecificator === 0x40) {
             return 'aac';

package/dist/get-duration.js

@@ -39,11 +39,12 @@ const isMatroska = (boxes) => {
 };
 exports.isMatroska = isMatroska;
 const getDurationFromIsoBaseMedia = (parserState) => {
+    var _a, _b;
     const structure = parserState.structure.getIsoStructure();
     const moovBox = (0, traversal_1.getMoovBoxFromState)({
         structureState: parserState.structure,
         isoState: parserState.iso,
-        mp4HeaderSegment: parserState.mp4HeaderSegment,
+        mp4HeaderSegment: (_b = (_a = parserState.m3uPlaylistContext) === null || _a === void 0 ? void 0 : _a.mp4HeaderSegment) !== null && _b !== void 0 ? _b : null,
         mayUsePrecomputed: true,
     });
     if (!moovBox) {

package/dist/get-fps.js

@@ -65,10 +65,11 @@ const getFpsFromMp4TrakBox = (trakBox) => {
 };
 exports.getFpsFromMp4TrakBox = getFpsFromMp4TrakBox;
 const getFpsFromIsoMaseMedia = (state) => {
+    var _a, _b;
     const moovBox = (0, traversal_1.getMoovBoxFromState)({
         structureState: state.structure,
         isoState: state.iso,
-        mp4HeaderSegment: state.mp4HeaderSegment,
+        mp4HeaderSegment: (_b = (_a = state.m3uPlaylistContext) === null || _a === void 0 ? void 0 : _a.mp4HeaderSegment) !== null && _b !== void 0 ? _b : null,
         mayUsePrecomputed: true,
     });
     if (!moovBox) {

package/dist/get-sample-positions-from-mp4.js

@@ -23,11 +23,16 @@ const getGroupedSamplesPositionsFromMp4 = ({ trakBox, bigEndian, }) => {
     }
     const samples = [];
     let timestamp = 0;
+    const stscKeys = Array.from(stscBox.entries.keys());
     for (let i = 0; i < stcoBox.entries.length; i++) {
         const entry = stcoBox.entries[i];
         const chunk = i + 1;
-        const stscEntry = stscBox.entries.findLast((e) => e.firstChunk <= chunk);
-        if (!stscEntry) {
+        const stscEntry = stscKeys.findLast((e) => e <= chunk);
+        if (stscEntry === undefined) {
+            throw new Error('should not be');
+        }
+        const samplesPerChunk = stscBox.entries.get(stscEntry);
+        if (samplesPerChunk === undefined) {
             throw new Error('should not be');
         }
         samples.push({
@@ -35,13 +40,13 @@ const getGroupedSamplesPositionsFromMp4 = ({ trakBox, bigEndian, }) => {
             cts: timestamp,
             dts: timestamp,
             offset: Number(entry),
-            size: stszBox.sampleSize * stscEntry.samplesPerChunk,
-            duration: stscEntry.samplesPerChunk,
+            size: stszBox.sampleSize * samplesPerChunk,
+            duration: samplesPerChunk,
             isKeyframe: true,
             bigEndian,
             chunkSize: stszBox.sampleSize,
         });
-        timestamp += stscEntry.samplesPerChunk;
+        timestamp += samplesPerChunk;
     }
     return samples;
 };

package/dist/get-sample-positions.js

@@ -22,9 +22,9 @@ const getSamplePositions = ({ stcoBox, stszBox, stscBox, stssBox, sttsBox, cttsB
     const samples = [];
     let samplesPerChunk = 1;
     for (let i = 0; i < chunks.length; i++) {
-        const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
-        if (hasEntry) {
-            samplesPerChunk = hasEntry.samplesPerChunk;
+        const hasEntry = stscBox.entries.get(i + 1);
+        if (hasEntry !== undefined) {
+            samplesPerChunk = hasEntry;
         }
         let offsetInThisChunk = 0;
         for (let j = 0; j < samplesPerChunk; j++) {
@@ -32,7 +32,7 @@ const getSamplePositions = ({ stcoBox, stszBox, stscBox, stssBox, sttsBox, cttsB
                 ? stszBox.sampleSize
                 : stszBox.entries[samples.length];
             const isKeyframe = stssBox
-                ? stssBox.sampleNumber.includes(samples.length + 1)
+                ? stssBox.sampleNumber.has(samples.length + 1)
                 : true;
             const delta = sttsDeltas[samples.length];
             const ctsOffset = cttsEntries[samples.length];

package/dist/get-seeking-byte.d.ts

@@ -1,14 +1,15 @@
 import type { LogLevel } from './log';
-import type { IsoBaseMediaStructure } from './parse-result';
+import type { M3uPlaylistContext } from './options';
 import type { SeekingHints } from './seeking-hints';
 import type { IsoBaseMediaState } from './state/iso-base-media/iso-state';
+import type { M3uState } from './state/m3u-state';
 import type { WebmState } from './state/matroska/webm';
 import type { RiffState } from './state/riff';
 import type { StructureState } from './state/structure';
 import type { TransportStreamState } from './state/transport-stream/transport-stream';
 import type { MediaSectionState } from './state/video-section';
 import type { SeekResolution } from './work-on-seek-request';
-export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, mp4HeaderSegment, structure, riffState, }: {
+export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, m3uPlaylistContext, structure, riffState, m3uState, }: {
     info: SeekingHints;
     time: number;
     logLevel: LogLevel;
@@ -18,6 +19,7 @@ export declare const getSeekingByte: ({ info, time, logLevel, currentPosition, i
     webmState: WebmState;
     mediaSection: MediaSectionState;
     structure: StructureState;
-    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    m3uPlaylistContext: M3uPlaylistContext | null;
     riffState: RiffState;
+    m3uState: M3uState;
 }) => Promise<SeekResolution>;

package/dist/get-seeking-byte.js

@@ -4,12 +4,13 @@ exports.getSeekingByte = void 0;
 const get_seeking_byte_1 = require("./containers/aac/get-seeking-byte");
 const get_seeking_byte_2 = require("./containers/flac/get-seeking-byte");
 const get_seeking_byte_3 = require("./containers/iso-base-media/get-seeking-byte");
-const get_seeking_byte_4 = require("./containers/mp3/get-seeking-byte");
-const get_seeking_byte_5 = require("./containers/riff/get-seeking-byte");
-const get_seeking_byte_6 = require("./containers/wav/get-seeking-byte");
-const get_seeking_byte_7 = require("./containers/webm/seek/get-seeking-byte");
+const get_seeking_byte_4 = require("./containers/m3u/get-seeking-byte");
+const get_seeking_byte_5 = require("./containers/mp3/get-seeking-byte");
+const get_seeking_byte_6 = require("./containers/riff/get-seeking-byte");
+const get_seeking_byte_7 = require("./containers/wav/get-seeking-byte");
+const get_seeking_byte_8 = require("./containers/webm/seek/get-seeking-byte");
 const observed_pes_header_1 = require("./state/transport-stream/observed-pes-header");
-const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, mp4HeaderSegment, structure, riffState, }) => {
+const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, transportStream, webmState, mediaSection, m3uPlaylistContext, structure, riffState, m3uState, }) => {
     var _a;
     if (info.type === 'iso-base-media-seeking-hints') {
         return (0, get_seeking_byte_3.getSeekingByteFromIsoBaseMedia)({
@@ -18,18 +19,18 @@ const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, trans
             logLevel,
             currentPosition,
             isoState,
-            mp4HeaderSegment,
             structure,
+            m3uPlaylistContext,
         });
     }
     if (info.type === 'wav-seeking-hints') {
-        return (0, get_seeking_byte_6.getSeekingByteFromWav)({
+        return (0, get_seeking_byte_7.getSeekingByteFromWav)({
             info,
             time,
         });
     }
     if (info.type === 'webm-seeking-hints') {
-        return (0, get_seeking_byte_7.getSeekingByteFromMatroska)({
+        return (0, get_seeking_byte_8.getSeekingByteFromMatroska)({
             info,
             time,
             webmState,
@@ -66,14 +67,14 @@ const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, trans
         });
     }
     if (info.type === 'riff-seeking-hints') {
-        return (0, get_seeking_byte_5.getSeekingByteForRiff)({
+        return (0, get_seeking_byte_6.getSeekingByteForRiff)({
             info,
             time,
             riffState,
         });
     }
     if (info.type === 'mp3-seeking-hints') {
-        return Promise.resolve((0, get_seeking_byte_4.getSeekingByteForMp3)({
+        return Promise.resolve((0, get_seeking_byte_5.getSeekingByteForMp3)({
             info,
             time,
         }));
@@ -84,6 +85,14 @@ const getSeekingByte = ({ info, time, logLevel, currentPosition, isoState, trans
             seekingHints: info,
         }));
     }
+    if (info.type === 'm3u8-seeking-hints') {
+        return Promise.resolve((0, get_seeking_byte_4.getSeekingByteForM3u8)({
+            time,
+            currentPosition,
+            m3uState,
+            logLevel,
+        }));
+    }
     throw new Error(`Unknown seeking info type: ${info}`);
 };
 exports.getSeekingByte = getSeekingByte;

package/dist/get-seeking-hints.d.ts

@@ -1,4 +1,4 @@
-import type { IsoBaseMediaStructure } from './parse-result';
+import type { M3uPlaylistContext } from './options';
 import type { SeekingHints } from './seeking-hints';
 import type { AacState } from './state/aac-state';
 import type { FlacState } from './state/flac-state';
@@ -12,9 +12,9 @@ import type { SamplesObservedState } from './state/samples-observed/slow-duratio
 import type { StructureState } from './state/structure';
 import type { TransportStreamState } from './state/transport-stream/transport-stream';
 import type { MediaSectionState } from './state/video-section';
-export declare const getSeekingHints: ({ structureState, mp4HeaderSegment, mediaSectionState, isoState, transportStream, tracksState, keyframesState, webmState, flacState, samplesObserved, riffState, mp3State, contentLength, aacState, }: {
+export declare const getSeekingHints: ({ structureState, m3uPlaylistContext, mediaSectionState, isoState, transportStream, tracksState, keyframesState, webmState, flacState, samplesObserved, riffState, mp3State, contentLength, aacState, }: {
     structureState: StructureState;
-    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    m3uPlaylistContext: M3uPlaylistContext | null;
     mediaSectionState: MediaSectionState;
     isoState: IsoBaseMediaState;
     transportStream: TransportStreamState;

package/dist/get-seeking-hints.js

@@ -4,12 +4,14 @@ exports.getSeekingHints = void 0;
 const seeking_hints_1 = require("./containers/aac/seeking-hints");
 const seeking_hints_2 = require("./containers/flac/seeking-hints");
 const seeking_hints_3 = require("./containers/iso-base-media/seeking-hints");
-const seeking_hints_4 = require("./containers/mp3/seeking-hints");
-const seeking_hints_5 = require("./containers/riff/seeking-hints");
-const seeking_hints_6 = require("./containers/transport-stream/seeking-hints");
-const seeking_hints_7 = require("./containers/wav/seeking-hints");
-const seeking_hints_8 = require("./containers/webm/seek/seeking-hints");
-const getSeekingHints = ({ structureState, mp4HeaderSegment, mediaSectionState, isoState, transportStream, tracksState, keyframesState, webmState, flacState, samplesObserved, riffState, mp3State, contentLength, aacState, }) => {
+const seeking_hints_4 = require("./containers/m3u/seeking-hints");
+const seeking_hints_5 = require("./containers/mp3/seeking-hints");
+const seeking_hints_6 = require("./containers/riff/seeking-hints");
+const seeking_hints_7 = require("./containers/transport-stream/seeking-hints");
+const seeking_hints_8 = require("./containers/wav/seeking-hints");
+const seeking_hints_9 = require("./containers/webm/seek/seeking-hints");
+const getSeekingHints = ({ structureState, m3uPlaylistContext, mediaSectionState, isoState, transportStream, tracksState, keyframesState, webmState, flacState, samplesObserved, riffState, mp3State, contentLength, aacState, }) => {
+    var _a;
     const structure = structureState.getStructureOrNull();
     if (!structure) {
         return null;
@@ -18,21 +20,21 @@ const getSeekingHints = ({ structureState, mp4HeaderSegment, mediaSectionState,
         return (0, seeking_hints_3.getSeekingHintsFromMp4)({
             structureState,
             isoState,
-            mp4HeaderSegment,
+            mp4HeaderSegment: (_a = m3uPlaylistContext === null || m3uPlaylistContext === void 0 ? void 0 : m3uPlaylistContext.mp4HeaderSegment) !== null && _a !== void 0 ? _a : null,
             mediaSectionState,
         });
     }
     if (structure.type === 'wav') {
-        return (0, seeking_hints_7.getSeekingHintsFromWav)({
+        return (0, seeking_hints_8.getSeekingHintsFromWav)({
             structure,
             mediaSectionState,
         });
     }
     if (structure.type === 'matroska') {
-        return (0, seeking_hints_8.getSeekingHintsFromMatroska)(tracksState, keyframesState, webmState);
+        return (0, seeking_hints_9.getSeekingHintsFromMatroska)(tracksState, keyframesState, webmState);
     }
     if (structure.type === 'transport-stream') {
-        return (0, seeking_hints_6.getSeekingHintsFromTransportStream)(transportStream, tracksState);
+        return (0, seeking_hints_7.getSeekingHintsFromTransportStream)(transportStream, tracksState);
     }
     if (structure.type === 'flac') {
         return (0, seeking_hints_2.getSeekingHintsForFlac)({
@@ -41,14 +43,14 @@ const getSeekingHints = ({ structureState, mp4HeaderSegment, mediaSectionState,
         });
     }
     if (structure.type === 'riff') {
-        return (0, seeking_hints_5.getSeekingHintsForRiff)({
+        return (0, seeking_hints_6.getSeekingHintsForRiff)({
             structureState,
             riffState,
             mediaSectionState,
         });
     }
     if (structure.type === 'mp3') {
-        return (0, seeking_hints_4.getSeekingHintsForMp3)({
+        return (0, seeking_hints_5.getSeekingHintsForMp3)({
             mp3State,
             samplesObserved,
             mediaSectionState,
@@ -61,6 +63,9 @@ const getSeekingHints = ({ structureState, mp4HeaderSegment, mediaSectionState,
             samplesObserved,
         });
     }
-    throw new Error(`Seeking is not supported for this format: ${structure.type}`);
+    if (structure.type === 'm3u') {
+        return (0, seeking_hints_4.getSeekingHintsForM3u)();
+    }
+    throw new Error(`Seeking is not supported for this format: ${structure}`);
 };
 exports.getSeekingHints = getSeekingHints;

package/dist/get-tracks.d.ts

@@ -2,7 +2,10 @@ import type { MatrixCoefficients, Primaries, TransferCharacteristics } from './c
 import type { MoovBox } from './containers/iso-base-media/moov/moov';
 import type { TrakBox } from './containers/iso-base-media/trak/trak';
 import type { AllTracks } from './containers/riff/get-tracks-from-avi';
+import type { M3uPlaylistContext } from './options';
+import type { IsoBaseMediaState } from './state/iso-base-media/iso-state';
 import type { ParserState } from './state/parser-state';
+import type { StructureState } from './state/structure';
 type SampleAspectRatio = {
     numerator: number;
     denominator: number;
@@ -63,7 +66,12 @@ export declare const getTracksFromMoovBox: (moovBox: MoovBox) => {
     audioTracks: AudioTrack[];
     otherTracks: OtherTrack[];
 };
-export declare const getTracksFromIsoBaseMedia: (state: ParserState, mayUsePrecomputed: boolean) => {
+export declare const getTracksFromIsoBaseMedia: ({ mayUsePrecomputed, structure, isoState, m3uPlaylistContext, }: {
+    structure: StructureState;
+    isoState: IsoBaseMediaState;
+    m3uPlaylistContext: M3uPlaylistContext | null;
+    mayUsePrecomputed: boolean;
+}) => {
     videoTracks: VideoTrack[];
     audioTracks: AudioTrack[];
     otherTracks: OtherTrack[];

package/dist/get-tracks.js

@@ -15,10 +15,11 @@ const getNumberOfTracks = (moovBox) => {
 };
 exports.getNumberOfTracks = getNumberOfTracks;
 const isoBaseMediaHasTracks = (state, mayUsePrecomputed) => {
+    var _a, _b;
     return Boolean((0, traversal_1.getMoovBoxFromState)({
         structureState: state.structure,
         isoState: state.iso,
-        mp4HeaderSegment: state.mp4HeaderSegment,
+        mp4HeaderSegment: (_b = (_a = state.m3uPlaylistContext) === null || _a === void 0 ? void 0 : _a.mp4HeaderSegment) !== null && _b !== void 0 ? _b : null,
         mayUsePrecomputed,
     }));
 };
@@ -110,11 +111,12 @@ const getTracksFromMoovBox = (moovBox) => {
     };
 };
 exports.getTracksFromMoovBox = getTracksFromMoovBox;
-const getTracksFromIsoBaseMedia = (state, mayUsePrecomputed) => {
+const getTracksFromIsoBaseMedia = ({ mayUsePrecomputed, structure, isoState, m3uPlaylistContext, }) => {
+    var _a;
     const moovBox = (0, traversal_1.getMoovBoxFromState)({
-        structureState: state.structure,
-        isoState: state.iso,
-        mp4HeaderSegment: state.mp4HeaderSegment,
+        structureState: structure,
+        isoState,
+        mp4HeaderSegment: (_a = m3uPlaylistContext === null || m3uPlaylistContext === void 0 ? void 0 : m3uPlaylistContext.mp4HeaderSegment) !== null && _a !== void 0 ? _a : null,
         mayUsePrecomputed,
     });
     if (!moovBox) {
@@ -155,7 +157,12 @@ const getTracks = (state, mayUsePrecomputed) => {
         return getCategorizedTracksFromMatroska(state);
     }
     if (structure.type === 'iso-base-media') {
-        return (0, exports.getTracksFromIsoBaseMedia)(state, mayUsePrecomputed);
+        return (0, exports.getTracksFromIsoBaseMedia)({
+            isoState: state.iso,
+            m3uPlaylistContext: state.m3uPlaylistContext,
+            structure: state.structure,
+            mayUsePrecomputed,
+        });
     }
     if (structure.type === 'riff') {
         return (0, get_tracks_from_avi_1.getTracksFromAvi)(structure, state);

package/dist/index.d.ts

@@ -739,7 +739,7 @@ export declare const MediaParserInternals: {
         logLevel: LogLevel;
         contentLength: number;
     }) => Promise<import("./containers/iso-base-media/stsd/stsd").StsdBox>;
-    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, makeSamplesStartAtZero, }: {
+    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: import("./controller/media-parser-controller").MediaParserController;
@@ -753,7 +753,7 @@ export declare const MediaParserInternals: {
         onDiscardedData: import("./options").OnDiscardedData | null;
         selectM3uStreamFn: import("./containers/m3u/select-stream").SelectM3uStreamFn;
         selectM3uAssociatedPlaylistsFn: import("./containers/m3u/select-stream").SelectM3uAssociatedPlaylistsFn;
-        mp4HeaderSegment: import("./parse-result").IsoBaseMediaStructure | null;
+        m3uPlaylistContext: import("./options").M3uPlaylistContext | null;
         contentType: string | null;
         name: string;
         callbacks: import("./options").ParseMediaCallbacks;
@@ -761,6 +761,7 @@ export declare const MediaParserInternals: {
         mimeType: string | null;
         initialReaderInstance: import("./readers/reader").Reader;
         makeSamplesStartAtZero: boolean;
+        prefetchCache: import("./fetch").PrefetchCache;
     }) => {
         riff: {
             getAvcProfile: () => import("./state/parser-state").SpsAndPps | null;
@@ -859,6 +860,8 @@ export declare const MediaParserInternals: {
             flatSamples: {
                 getSamples: (mdatStart: number) => import("./state/iso-base-media/cached-sample-positions").FlatSample[] | null;
                 setSamples: (mdatStart: number, samples: import("./state/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: {
@@ -936,19 +939,22 @@ export declare const MediaParserInternals: {
             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("./state/m3u-state").ExistingM3uRun | null) => void;
+            setM3uStreamRun: (playlistUrl: string, run: import("./state/m3u-state").M3uRun | null) => void;
             setTracksDone: (playlistUrl: string) => boolean;
             getTrackDone: (playlistUrl: string) => boolean;
-            getM3uStreamRun: (playlistUrl: string) => import("./state/m3u-state").ExistingM3uRun;
+            clearTracksDone: () => void;
+            getM3uStreamRun: (playlistUrl: string) => import("./state/m3u-state").M3uRun;
             abortM3UStreamRuns: () => void;
             setAssociatedPlaylists: (playlists: import("./containers/m3u/get-streams").M3uAssociatedPlaylist[]) => void;
             getAssociatedPlaylists: () => import("./containers/m3u/get-streams").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;
@@ -960,6 +966,14 @@ export declare const MediaParserInternals: {
             };
             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;
@@ -973,6 +987,7 @@ export declare const MediaParserInternals: {
             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>;
@@ -1125,7 +1140,7 @@ export declare const MediaParserInternals: {
         discardReadBytes: (force: boolean) => Promise<void>;
         selectM3uStreamFn: import("./containers/m3u/select-stream").SelectM3uStreamFn;
         selectM3uAssociatedPlaylistsFn: import("./containers/m3u/select-stream").SelectM3uAssociatedPlaylistsFn;
-        mp4HeaderSegment: import("./parse-result").IsoBaseMediaStructure | null;
+        m3uPlaylistContext: import("./options").M3uPlaylistContext | null;
         contentType: string | null;
         name: string;
         returnValue: import("./options").ParseMediaResult<import("./options").AllParseMediaFields>;
@@ -1142,6 +1157,7 @@ export declare const MediaParserInternals: {
             reset: () => void;
         };
         makeSamplesStartAtZero: boolean;
+        prefetchCache: import("./fetch").PrefetchCache;
     };
     processSample: ({ iterator, logLevel, contentLength, }: {
         iterator: import("./iterator/buffer-iterator").BufferIterator;

package/dist/init-video.js

@@ -7,6 +7,7 @@ const get_tracks_1 = require("./get-tracks");
 const log_1 = require("./log");
 const register_track_1 = require("./register-track");
 const initVideo = async ({ state }) => {
+    var _a;
     const fileType = state.iterator.detectFileType();
     const { mimeType, name, contentLength } = state;
     if (fileType.type === 'riff') {
@@ -17,9 +18,9 @@ const initVideo = async ({ state }) => {
         });
         return;
     }
-    if (state.mp4HeaderSegment) {
+    if ((_a = state.m3uPlaylistContext) === null || _a === void 0 ? void 0 : _a.mp4HeaderSegment) {
         log_1.Log.verbose(state.logLevel, 'Detected ISO Base Media segment');
-        const moovAtom = (0, traversal_1.getMoovFromFromIsoStructure)(state.mp4HeaderSegment);
+        const moovAtom = (0, traversal_1.getMoovFromFromIsoStructure)(state.m3uPlaylistContext.mp4HeaderSegment);
         if (!moovAtom) {
             throw new Error('No moov box found');
         }

package/dist/internal-parse-media.js

@@ -11,7 +11,7 @@ const remotion_license_acknowledge_1 = require("./remotion-license-acknowledge")
 const set_seeking_hints_1 = require("./set-seeking-hints");
 const parser_state_1 = require("./state/parser-state");
 const throttled_progress_1 = require("./throttled-progress");
-const internalParseMedia = async function ({ src, fields: _fieldsInReturnValue, reader: readerInterface, onAudioTrack, onVideoTrack, controller = (0, media_parser_controller_1.mediaParserController)(), logLevel, onParseProgress: onParseProgressDoNotCallDirectly, progressIntervalInMs, mode, onDiscardedData, onError, acknowledgeRemotionLicense, apiName, selectM3uStream: selectM3uStreamFn, selectM3uAssociatedPlaylists: selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, makeSamplesStartAtZero, seekingHints, ...more }) {
+const internalParseMedia = async function ({ src, fields: _fieldsInReturnValue, reader: readerInterface, onAudioTrack, onVideoTrack, controller = (0, media_parser_controller_1.mediaParserController)(), logLevel, onParseProgress: onParseProgressDoNotCallDirectly, progressIntervalInMs, mode, onDiscardedData, onError, acknowledgeRemotionLicense, apiName, selectM3uStream: selectM3uStreamFn, selectM3uAssociatedPlaylists: selectM3uAssociatedPlaylistsFn, m3uPlaylistContext, makeSamplesStartAtZero, seekingHints, ...more }) {
     var _a;
     controller._internals.markAsReadyToEmitEvents();
     (0, remotion_license_acknowledge_1.warnIfRemotionLicenseNotAcknowledged)({
@@ -20,7 +20,14 @@ const internalParseMedia = async function ({ src, fields: _fieldsInReturnValue,
         apiName,
     });
     log_1.Log.verbose(logLevel, `Reading ${typeof src === 'string' ? src : src instanceof URL ? src.toString() : src instanceof File ? src.name : src.toString()}`);
-    const { reader: readerInstance, contentLength, name, contentType, supportsContentRange, needsContentRange, } = await readerInterface.read({ src, range: null, controller });
+    const prefetchCache = new Map();
+    const { reader: readerInstance, contentLength, name, contentType, supportsContentRange, needsContentRange, } = await readerInterface.read({
+        src,
+        range: null,
+        controller,
+        logLevel,
+        prefetchCache,
+    });
     if (contentLength === null) {
         throw new Error(`Cannot read media ${src} without a content length. This is currently not supported. Ensure the media has a "Content-Length" HTTP header.`);
     }
@@ -43,7 +50,7 @@ const internalParseMedia = async function ({ src, fields: _fieldsInReturnValue,
         onDiscardedData,
         selectM3uStreamFn,
         selectM3uAssociatedPlaylistsFn,
-        mp4HeaderSegment,
+        m3uPlaylistContext,
         contentType,
         name,
         callbacks: more,
@@ -51,6 +58,7 @@ const internalParseMedia = async function ({ src, fields: _fieldsInReturnValue,
         mimeType: contentType,
         initialReaderInstance: readerInstance,
         makeSamplesStartAtZero,
+        prefetchCache,
     });
     if (seekingHints) {
         (0, set_seeking_hints_1.setSeekingHints)({ hints: seekingHints, state });
@@ -60,7 +68,7 @@ const internalParseMedia = async function ({ src, fields: _fieldsInReturnValue,
         keyframesState: state.keyframes,
         webmState: state.webm,
         structureState: state.structure,
-        mp4HeaderSegment: state.mp4HeaderSegment,
+        m3uPlaylistContext: state.m3uPlaylistContext,
         mediaSectionState: state.mediaSection,
         isoState: state.iso,
         transportStream: state.transportStream,
@@ -92,6 +100,7 @@ const internalParseMedia = async function ({ src, fields: _fieldsInReturnValue,
     (_a = state.iterator) === null || _a === void 0 ? void 0 : _a.destroy();
     state.callbacks.tracks.ensureHasTracksAtEnd(state.fields);
     state.m3u.abortM3UStreamRuns();
+    prefetchCache.clear();
     if (state.errored) {
         throw state.errored;
     }

package/dist/iterator/buffer-iterator.js

@@ -66,14 +66,15 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             const six = getUint8();
             const seven = getUint8();
             const eight = getUint8();
-            return ((eight << 56) |
+            return (((eight << 56) |
                 (seven << 48) |
                 (six << 40) |
                 (five << 32) |
                 (four << 24) |
                 (three << 16) |
                 (two << 8) |
-                one);
+                one) >>>
+                0);
         }
         function byteArrayToBigInt(byteArray) {
             let result = BigInt(0);
@@ -95,7 +96,8 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         return Number(bigInt);
     };
     const getFourByteNumber = () => {
-        return ((getUint8() << 24) | (getUint8() << 16) | (getUint8() << 8) | getUint8());
+        const unsigned = (getUint8() << 24) | (getUint8() << 16) | (getUint8() << 8) | getUint8();
+        return unsigned >>> 0;
     };
     const getPaddedFourByteNumber = () => {
         let lastInt = 128;

package/dist/metadata/metadata-from-iso.js

@@ -116,10 +116,11 @@ const parseIsoMetaBox = (meta, trackId) => {
 };
 exports.parseIsoMetaBox = parseIsoMetaBox;
 const getMetadataFromIsoBase = (state) => {
+    var _a, _b;
     const moov = (0, traversal_1.getMoovBoxFromState)({
         structureState: state.structure,
         isoState: state.iso,
-        mp4HeaderSegment: state.mp4HeaderSegment,
+        mp4HeaderSegment: (_b = (_a = state.m3uPlaylistContext) === null || _a === void 0 ? void 0 : _a.mp4HeaderSegment) !== null && _b !== void 0 ? _b : null,
         mayUsePrecomputed: true,
     });
     if (!moov) {

package/dist/options.d.ts

@@ -130,12 +130,16 @@ export type ParseMediaOnProgress = (progress: ParseMediaProgress) => void | Prom
 type ReaderParams = {
     reader: ReaderInterface;
 };
+export type M3uPlaylistContext = {
+    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    isLastChunkInPlaylist: boolean;
+};
 export type SerializeableOptionalParseMediaParams<F extends Options<ParseMediaFields>> = {
     logLevel: LogLevel;
     progressIntervalInMs: number | null;
     fields: F | null;
     acknowledgeRemotionLicense: boolean;
-    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    m3uPlaylistContext: M3uPlaylistContext | null;
     makeSamplesStartAtZero: boolean;
     seekingHints: SeekingHints | null;
 };
@@ -151,6 +155,7 @@ type ParseMediaSampleCallbacks = {
 };
 export type ParseMediaMode = 'query' | 'download';
 export type ParseMediaSrc = string | Blob | URL;
+export type ParseMediaRange = [number, number] | number | null;
 export type OnDiscardedData = (data: Uint8Array) => Promise<void>;
 export type ContinueAfterError = {
     action: 'fail';