@remotion/media-parser 4.0.286 → 4.0.288

package/dist/internal-parse-media.js

@@ -3,13 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.internalParseMedia = void 0;
 const media_parser_controller_1 = require("./controller/media-parser-controller");
 const emit_all_info_1 = require("./emit-all-info");
+const get_seeking_hints_1 = require("./get-seeking-hints");
 const log_1 = require("./log");
 const parse_loop_1 = require("./parse-loop");
 const print_timings_1 = require("./print-timings");
 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, ...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, mp4HeaderSegment, makeSamplesStartAtZero, seekingHints, ...more }) {
     var _a;
     controller._internals.markAsReadyToEmitEvents();
     (0, remotion_license_acknowledge_1.warnIfRemotionLicenseNotAcknowledged)({
@@ -50,6 +52,19 @@ const internalParseMedia = async function ({ src, fields: _fieldsInReturnValue,
         initialReaderInstance: readerInstance,
         makeSamplesStartAtZero,
     });
+    if (seekingHints) {
+        (0, set_seeking_hints_1.setSeekingHints)({ hints: seekingHints, state });
+    }
+    controller._internals.attachSeekingHintResolution(() => Promise.resolve((0, get_seeking_hints_1.getSeekingHints)({
+        tracksState: state.callbacks.tracks,
+        keyframesState: state.keyframes,
+        webmState: state.webm,
+        structureState: state.structure,
+        mp4HeaderSegment: state.mp4HeaderSegment,
+        mediaSectionState: state.mediaSection,
+        isoState: state.iso,
+        transportStream: state.transportStream,
+    })));
     if (!hasAudioTrackHandlers &&
         !hasVideoTrackHandlers &&
         Object.values(state.fields).every((v) => !v) &&

package/dist/iterator/buffer-iterator.js

@@ -4,6 +4,7 @@ exports.getArrayBufferIterator = void 0;
 /* eslint-disable @typescript-eslint/no-use-before-define */
 const all_segments_1 = require("../containers/webm/segments/all-segments");
 const file_types_1 = require("../file-types");
+const log_1 = require("../log");
 const buffer_manager_1 = require("./buffer-manager");
 const offset_counter_1 = require("./offset-counter");
 const getArrayBufferIterator = (initialData, maxBytes) => {
@@ -174,13 +175,11 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         return (1 << zerosCount) - 1 + suffix;
     };
     const peekB = (length) => {
-        // eslint-disable-next-line no-console
-        console.log([...getSlice(length)].map((b) => b.toString(16).padStart(2, '0')));
+        log_1.Log.info('info', [...getSlice(length)].map((b) => b.toString(16).padStart(2, '0')));
         counter.decrement(length);
     };
     const peekD = (length) => {
-        // eslint-disable-next-line no-console
-        console.log([...getSlice(length)].map((b) => b));
+        log_1.Log.info('info', [...getSlice(length)].map((b) => b.toString(16).padStart(2, '0')));
         counter.decrement(length);
     };
     const leb128 = () => {

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

@@ -120,6 +120,7 @@ const getMetadataFromIsoBase = (state) => {
         structureState: state.structure,
         isoState: state.iso,
         mp4HeaderSegment: state.mp4HeaderSegment,
+        mayUsePrecomputed: true,
     });
     if (!moov) {
         return [];

package/dist/options.d.ts

@@ -9,6 +9,7 @@ import type { LogLevel } from './log';
 import type { MediaParserMetadataEntry } from './metadata/get-metadata';
 import type { IsoBaseMediaStructure, MediaParserStructureUnstable } from './parse-result';
 import type { ReaderInterface } from './readers/reader';
+import type { SeekingHints } from './seeking-hints';
 import type { MediaParserEmbeddedImage } from './state/images';
 import type { InternalStats } from './state/parser-state';
 import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
@@ -136,6 +137,7 @@ export type SerializeableOptionalParseMediaParams<F extends Options<ParseMediaFi
     acknowledgeRemotionLicense: boolean;
     mp4HeaderSegment: IsoBaseMediaStructure | null;
     makeSamplesStartAtZero: boolean;
+    seekingHints: SeekingHints | null;
 };
 type OptionalParseMediaParams<F extends Options<ParseMediaFields>> = SerializeableOptionalParseMediaParams<F> & {
     controller: MediaParserController | undefined;

package/dist/parse-media-on-worker-entry.js

@@ -54,6 +54,7 @@ const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params
         throw new Error(`\`reader\` should not be provided to \`${apiName}\`. If you want to use it in the browser, use parseMediaOnWorker(). If you also want to read files from the file system, use parseMediaOnServerWorker().`);
     }
     post(worker, convertToWorkerPayload(params));
+    let workerTerminated = false;
     const { promise, resolve, reject } = (0, with_resolvers_1.withResolvers)();
     const onAbort = () => {
         post(worker, { type: 'request-abort' });
@@ -68,16 +69,54 @@ const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params
         post(worker, { type: 'request-seek', payload: seek });
         controller === null || controller === void 0 ? void 0 : controller._internals.seekSignal.clearSeekIfStillSame(seek);
     };
+    const seekingHintPromises = [];
+    let finalSeekingHints = null;
+    controller === null || controller === void 0 ? void 0 : controller._internals.attachSeekingHintResolution(() => {
+        if (finalSeekingHints) {
+            return Promise.resolve(finalSeekingHints);
+        }
+        if (workerTerminated) {
+            return Promise.reject(new Error('Worker terminated'));
+        }
+        const prom = (0, with_resolvers_1.withResolvers)();
+        post(worker, { type: 'request-get-seeking-hints' });
+        seekingHintPromises.push(prom);
+        return prom.promise;
+    });
     const callbacks = {};
     function onMessage(message) {
         const data = message.data;
         if (data.type === 'response-done') {
             resolve(data.payload);
+            if (data.seekingHints) {
+                finalSeekingHints = data.seekingHints;
+                for (const prom of seekingHintPromises) {
+                    prom.resolve(finalSeekingHints);
+                }
+            }
+            return;
         }
         if (data.type === 'response-error') {
             // eslint-disable-next-line @typescript-eslint/no-use-before-define
             cleanup();
-            reject((0, serialize_error_1.deserializeError)(data));
+            // Reject main loop
+            const error = (0, serialize_error_1.deserializeError)(data);
+            reject(error);
+            // If aborted, we send the seeking hints we got,
+            // otherwise we reject all .getSeekingHints() promises
+            if (data.errorName === 'MediaParserAbortError') {
+                finalSeekingHints = data.seekingHints;
+                for (const prom of seekingHintPromises) {
+                    prom.resolve(finalSeekingHints);
+                }
+            }
+            else {
+                // Reject all .getSeekingHints() promises
+                for (const prom of seekingHintPromises) {
+                    prom.reject(error);
+                }
+            }
+            return;
         }
         if (data.type === 'response-on-callback-request') {
             Promise.resolve()
@@ -254,7 +293,17 @@ const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params
                     nonce: data.nonce,
                 });
             });
+            return;
+        }
+        if (data.type === 'response-get-seeking-hints') {
+            const firstPromise = seekingHintPromises.shift();
+            if (!firstPromise) {
+                throw new Error('No seeking hint promise found');
+            }
+            firstPromise.resolve(data.payload);
+            return;
         }
+        throw new Error(`Unknown response type: ${JSON.stringify(data)}`);
     }
     worker.addEventListener('message', onMessage);
     controller === null || controller === void 0 ? void 0 : controller.addEventListener('abort', onAbort);
@@ -267,6 +316,7 @@ const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params
         controller === null || controller === void 0 ? void 0 : controller.removeEventListener('resume', onResume);
         controller === null || controller === void 0 ? void 0 : controller.removeEventListener('pause', onPause);
         controller === null || controller === void 0 ? void 0 : controller.removeEventListener('seek', onSeek);
+        workerTerminated = true;
         worker.terminate();
     }
     controller === null || controller === void 0 ? void 0 : controller._internals.markAsReadyToEmitEvents();

package/dist/parse-media.js

@@ -5,7 +5,7 @@ const select_stream_1 = require("./containers/m3u/select-stream");
 const internal_parse_media_1 = require("./internal-parse-media");
 const web_1 = require("./web");
 const parseMedia = (options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16;
     return (0, internal_parse_media_1.internalParseMedia)({
         fields: (_a = options.fields) !== null && _a !== void 0 ? _a : null,
         logLevel: (_b = options.logLevel) !== null && _b !== void 0 ? _b : 'info',
@@ -53,6 +53,7 @@ const parseMedia = (options) => {
         acknowledgeRemotionLicense: Boolean(options.acknowledgeRemotionLicense),
         apiName: 'parseMedia()',
         makeSamplesStartAtZero: (_15 = options.makeSamplesStartAtZero) !== null && _15 !== void 0 ? _15 : true,
+        seekingHints: (_16 = options.seekingHints) !== null && _16 !== void 0 ? _16 : null,
     });
 };
 exports.parseMedia = parseMedia;

package/dist/samples-from-moof.d.ts

@@ -1,6 +1,6 @@
 import type { SamplePosition } from './get-sample-positions';
-import type { AnySegment } from './parse-result';
+import type { MoofBox } from './state/iso-base-media/precomputed-moof';
 export declare const getSamplesFromMoof: ({ moofBox, trackId, }: {
-    moofBox: AnySegment;
+    moofBox: MoofBox;
     trackId: number;
 }) => SamplePosition[];

package/dist/samples-from-moof.js

@@ -52,6 +52,8 @@ const getSamplesFromTraf = (trafSegment, moofOffset) => {
                 isKeyframe: keyframe,
                 size,
                 chunk: 0,
+                bigEndian: false,
+                chunkSize: null,
             };
             samples.push(samplePosition);
             offset += size;
@@ -61,15 +63,12 @@ const getSamplesFromTraf = (trafSegment, moofOffset) => {
     return samples;
 };
 const getSamplesFromMoof = ({ moofBox, trackId, }) => {
-    if (moofBox.type !== 'regular-box') {
-        throw new Error('Expected moof-box');
-    }
-    const trafs = moofBox.children.filter((c) => c.type === 'regular-box' && c.boxType === 'traf');
-    const mapped = trafs.map((traf) => {
+    const mapped = moofBox.trafBoxes.map((traf) => {
         const tfhdBox = (0, traversal_1.getTfhdBox)(traf);
-        return (tfhdBox === null || tfhdBox === void 0 ? void 0 : tfhdBox.trackId) === trackId
-            ? getSamplesFromTraf(traf, moofBox.offset)
-            : [];
+        if (!tfhdBox || tfhdBox.trackId !== trackId) {
+            return [];
+        }
+        return getSamplesFromTraf(traf, moofBox.offset);
     });
     return mapped.flat(1);
 };

package/dist/seeking-hints.d.ts

@@ -0,0 +1,39 @@
+import type { IsoBaseMediaBox } from './containers/iso-base-media/base-media-box';
+import type { TfraBox } from './containers/iso-base-media/mfra/tfra';
+import type { MoovBox } from './containers/iso-base-media/moov/moov';
+import type { PacketPes } from './containers/transport-stream/parse-pes';
+import type { MediaParserKeyframe } from './options';
+import type { MoofBox } from './state/iso-base-media/precomputed-moof';
+import type { LazyCuesLoadedOrNull } from './state/matroska/lazy-cues-fetch';
+import type { MediaSection } from './state/video-section';
+export type IsoBaseMediaSeekingHints = {
+    type: 'iso-base-media-seeking-hints';
+    moovBox: MoovBox;
+    moofBoxes: MoofBox[];
+    tfraBoxes: TfraBox[];
+    mediaSections: MediaSection[];
+    mfraAlreadyLoaded: IsoBaseMediaBox[] | null;
+};
+export type WavSeekingHints = {
+    type: 'wav-seeking-hints';
+    sampleRate: number;
+    blockAlign: number;
+    mediaSection: MediaSection;
+};
+export type TransportStreamSeekingHints = {
+    type: 'transport-stream-seeking-hints';
+    observedPesHeaders: PacketPes[];
+    ptsStartOffset: number;
+    firstVideoTrackId: number;
+};
+export type WebmSeekingHints = {
+    type: 'webm-seeking-hints';
+    track: null | {
+        timescale: number;
+        trackId: number;
+    };
+    keyframes: MediaParserKeyframe[];
+    loadedCues: LazyCuesLoadedOrNull;
+    timestampMap: Map<number, number>;
+};
+export type SeekingHints = IsoBaseMediaSeekingHints | WavSeekingHints | TransportStreamSeekingHints | WebmSeekingHints;

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

@@ -0,0 +1,6 @@
+import type { SeekingHints } from './seeking-hints';
+import type { ParserState } from './state/parser-state';
+export declare const setSeekingHints: ({ hints, state, }: {
+    hints: SeekingHints;
+    state: ParserState;
+}) => void;

package/dist/set-seeking-hints.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSeekingHints = void 0;
+const seeking_hints_1 = require("./containers/iso-base-media/seeking-hints");
+const seeking_hints_2 = require("./containers/transport-stream/seeking-hints");
+const seeking_hints_3 = require("./containers/wav/seeking-hints");
+const seeking_hints_4 = require("./containers/webm/seek/seeking-hints");
+const setSeekingHints = ({ hints, state, }) => {
+    if (hints.type === 'iso-base-media-seeking-hints') {
+        (0, seeking_hints_1.setSeekingHintsForMp4)({ hints, state });
+        return;
+    }
+    if (hints.type === 'wav-seeking-hints') {
+        (0, seeking_hints_3.setSeekingHintsForWav)({ hints, state });
+        return;
+    }
+    if (hints.type === 'transport-stream-seeking-hints') {
+        (0, seeking_hints_2.setSeekingHintsForTransportStream)({ hints, state });
+        return;
+    }
+    if (hints.type === 'webm-seeking-hints') {
+        (0, seeking_hints_4.setSeekingHintsForWebm)({ hints, state });
+        return;
+    }
+    throw new Error(`Unknown seeking hints type: ${hints}`);
+};
+exports.setSeekingHints = setSeekingHints;

package/dist/state/audio-sample-map.d.ts

@@ -0,0 +1,11 @@
+export type AudioSampleOffset = {
+    timeInSeconds: number;
+    offset: number;
+    durationInSeconds: number;
+};
+export declare const audioSampleMapState: () => {
+    addSample: (audioSampleOffset: AudioSampleOffset) => void;
+    getSamples: () => AudioSampleOffset[];
+    setFromSeekingHints: (newMap: AudioSampleOffset[]) => void;
+};
+export type AudioSampleMapState = ReturnType<typeof audioSampleMapState>;

package/dist/state/audio-sample-map.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.audioSampleMapState = void 0;
+const audioSampleMapState = () => {
+    // {[]}
+    let map = [];
+    const addSample = (audioSampleOffset) => {
+        if (map.find((m) => m.offset === audioSampleOffset.offset)) {
+            return;
+        }
+        map.push(audioSampleOffset);
+    };
+    return {
+        addSample,
+        getSamples: () => map,
+        setFromSeekingHints: (newMap) => {
+            map = newMap;
+        },
+    };
+};
+exports.audioSampleMapState = audioSampleMapState;

package/dist/state/has-tracks-section.js

@@ -18,7 +18,9 @@ const makeTracksSectionState = (canSkipTracksState, src) => {
         addTrack: (track) => {
             tracks.push(track);
         },
-        getTracks: () => tracks,
+        getTracks: () => {
+            return tracks;
+        },
         ensureHasTracksAtEnd: (fields) => {
             if (canSkipTracksState.canSkipTracks()) {
                 return;

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

@@ -5,7 +5,7 @@ const get_sample_positions_from_track_1 = require("../../containers/iso-base-med
 const traversal_1 = require("../../containers/iso-base-media/traversal");
 const get_tracks_1 = require("../../get-tracks");
 const calculateFlatSamples = (state) => {
-    const tracks = (0, get_tracks_1.getTracks)(state);
+    const tracks = (0, get_tracks_1.getTracks)(state, true);
     const allTracks = [
         ...tracks.videoTracks,
         ...tracks.audioTracks,

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

@@ -14,11 +14,27 @@ export declare const isoBaseMediaState: ({ contentLength, controller, readerInte
         setSamples: (mdatStart: number, samples: import("./cached-sample-positions").FlatSample[]) => void;
     };
     moov: {
-        setMoovBox: (moov: import("../../containers/iso-base-media/moov/moov").MoovBox) => void;
-        getMoovBox: () => import("../../containers/iso-base-media/moov/moov").MoovBox | null;
+        setMoovBox: (moov: {
+            moovBox: import("../../containers/iso-base-media/moov/moov").MoovBox;
+            precomputed: boolean;
+        }) => void;
+        getMoovBoxAndPrecomputed: () => {
+            moovBox: import("../../containers/iso-base-media/moov/moov").MoovBox;
+            precomputed: boolean;
+        } | null;
     };
     mfra: {
         triggerLoad: () => Promise<import("../../containers/iso-base-media/base-media-box").IsoBaseMediaBox[] | null>;
+        getIfAlreadyLoaded: () => import("../../containers/iso-base-media/base-media-box").IsoBaseMediaBox[] | null;
+        setFromSeekingHints: (hints: import("../../seeking-hints").IsoBaseMediaSeekingHints) => void;
+    };
+    moof: {
+        getMoofBoxes: () => import("./precomputed-moof").MoofBox[];
+        setMoofBoxes: (boxes: import("./precomputed-moof").MoofBox[]) => void;
+    };
+    tfra: {
+        getTfraBoxes: () => import("../../containers/iso-base-media/mfra/tfra").TfraBox[];
+        setTfraBoxes: (boxes: import("../../containers/iso-base-media/mfra/tfra").TfraBox[]) => void;
     };
 };
 export type IsoBaseMediaState = ReturnType<typeof isoBaseMediaState>;

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

@@ -4,6 +4,8 @@ exports.isoBaseMediaState = void 0;
 const cached_sample_positions_1 = require("./cached-sample-positions");
 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, }) => {
     return {
         flatSamples: (0, cached_sample_positions_1.cachedSamplePositionsState)(),
@@ -15,6 +17,8 @@ const isoBaseMediaState = ({ contentLength, controller, readerInterface, src, lo
             src,
             logLevel,
         }),
+        moof: (0, precomputed_moof_1.precomputedMoofState)(),
+        tfra: (0, precomputed_tfra_1.precomputedTfraState)(),
     };
 };
 exports.isoBaseMediaState = isoBaseMediaState;

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

@@ -3,6 +3,7 @@ import type { MediaParserController } from '../../controller/media-parser-contro
 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, }: {
     contentLength: number;
     controller: MediaParserController;
@@ -11,4 +12,6 @@ export declare const lazyMfraLoad: ({ contentLength, controller, readerInterface
     logLevel: LogLevel;
 }) => {
     triggerLoad: () => Promise<IsoBaseMediaBox[] | null>;
+    getIfAlreadyLoaded: () => IsoBaseMediaBox[] | null;
+    setFromSeekingHints: (hints: IsoBaseMediaSeekingHints) => void;
 };

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

@@ -5,6 +5,7 @@ const get_mfra_seeking_box_1 = require("../../containers/iso-base-media/get-mfra
 const log_1 = require("../../log");
 const lazyMfraLoad = ({ contentLength, controller, readerInterface, src, logLevel, }) => {
     let prom = null;
+    let result = null;
     const triggerLoad = () => {
         if (prom) {
             return prom;
@@ -18,12 +19,24 @@ const lazyMfraLoad = ({ contentLength, controller, readerInterface, src, logLeve
             logLevel,
         }).then((boxes) => {
             log_1.Log.verbose(logLevel, 'Lazily found mfra atom.');
+            result = boxes;
             return boxes;
         });
         return prom;
     };
+    const getIfAlreadyLoaded = () => {
+        if (result) {
+            return result;
+        }
+        return null;
+    };
+    const setFromSeekingHints = (hints) => {
+        result = hints.mfraAlreadyLoaded;
+    };
     return {
         triggerLoad,
+        getIfAlreadyLoaded,
+        setFromSeekingHints,
     };
 };
 exports.lazyMfraLoad = lazyMfraLoad;

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

@@ -1,5 +1,10 @@
 import type { MoovBox } from '../../containers/iso-base-media/moov/moov';
+type MoovBoxAndPrecomputed = {
+    moovBox: MoovBox;
+    precomputed: boolean;
+};
 export declare const moovState: () => {
-    setMoovBox: (moov: MoovBox) => void;
-    getMoovBox: () => MoovBox | null;
+    setMoovBox: (moov: MoovBoxAndPrecomputed) => void;
+    getMoovBoxAndPrecomputed: () => MoovBoxAndPrecomputed | null;
 };
+export {};

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

@@ -7,7 +7,7 @@ const moovState = () => {
         setMoovBox: (moov) => {
             moovBox = moov;
         },
-        getMoovBox: () => moovBox,
+        getMoovBoxAndPrecomputed: () => moovBox,
     };
 };
 exports.moovState = moovState;

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

@@ -0,0 +1,11 @@
+import type { IsoBaseMediaBox } from '../../containers/iso-base-media/base-media-box';
+export type MoofBox = {
+    offset: number;
+    trafBoxes: IsoBaseMediaBox[];
+};
+export declare const precomputedMoofState: () => {
+    getMoofBoxes: () => MoofBox[];
+    setMoofBoxes: (boxes: MoofBox[]) => void;
+};
+export declare const toMoofBox: (box: IsoBaseMediaBox) => MoofBox;
+export declare const deduplicateMoofBoxesByOffset: (moofBoxes: MoofBox[]) => MoofBox[];

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicateMoofBoxesByOffset = exports.toMoofBox = exports.precomputedMoofState = void 0;
+// Note: May be duplicated!
+const precomputedMoofState = () => {
+    let moofBoxes = [];
+    return {
+        getMoofBoxes: () => moofBoxes,
+        setMoofBoxes: (boxes) => {
+            moofBoxes = boxes;
+        },
+    };
+};
+exports.precomputedMoofState = precomputedMoofState;
+const toMoofBox = (box) => {
+    if (box.type !== 'regular-box') {
+        throw new Error('expected regular bpx');
+    }
+    return {
+        offset: box.offset,
+        trafBoxes: box.children.filter((c) => c.type === 'regular-box' && c.boxType === 'traf'),
+    };
+};
+exports.toMoofBox = toMoofBox;
+const deduplicateMoofBoxesByOffset = (moofBoxes) => {
+    return moofBoxes.filter((m, i, arr) => i === arr.findIndex((t) => t.offset === m.offset));
+};
+exports.deduplicateMoofBoxesByOffset = deduplicateMoofBoxesByOffset;

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

@@ -0,0 +1,6 @@
+import type { TfraBox } from '../../containers/iso-base-media/mfra/tfra';
+export declare const precomputedTfraState: () => {
+    getTfraBoxes: () => TfraBox[];
+    setTfraBoxes: (boxes: TfraBox[]) => void;
+};
+export declare const deduplicateTfraBoxesByOffset: (tfraBoxes: TfraBox[]) => TfraBox[];

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicateTfraBoxesByOffset = exports.precomputedTfraState = void 0;
+const precomputedTfraState = () => {
+    let tfraBoxes = [];
+    return {
+        getTfraBoxes: () => tfraBoxes,
+        setTfraBoxes: (boxes) => {
+            tfraBoxes = boxes;
+        },
+    };
+};
+exports.precomputedTfraState = precomputedTfraState;
+const deduplicateTfraBoxesByOffset = (tfraBoxes) => {
+    return tfraBoxes.filter((m, i, arr) => i === arr.findIndex((t) => t.offset === m.offset));
+};
+exports.deduplicateTfraBoxesByOffset = deduplicateTfraBoxesByOffset;

package/dist/state/keyframes.d.ts

@@ -1,6 +1,8 @@
 import type { MediaParserKeyframe } from '../options';
+import type { WebmSeekingHints } from '../seeking-hints';
 export declare const keyframesState: () => {
     addKeyframe: (keyframe: MediaParserKeyframe) => void;
     getKeyframes: () => MediaParserKeyframe[];
+    setFromSeekingHints: (hints: WebmSeekingHints) => void;
 };
 export type KeyframesState = ReturnType<typeof keyframesState>;

package/dist/state/keyframes.js

@@ -3,16 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.keyframesState = void 0;
 const keyframesState = () => {
     const keyframes = [];
+    const addKeyframe = (keyframe) => {
+        if (keyframes.find((k) => k.positionInBytes === keyframe.positionInBytes)) {
+            return;
+        }
+        keyframes.push(keyframe);
+    };
+    const getKeyframes = () => {
+        return keyframes;
+    };
+    const setFromSeekingHints = (hints) => {
+        for (const keyframe of hints.keyframes) {
+            addKeyframe(keyframe);
+        }
+    };
     return {
-        addKeyframe: (keyframe) => {
-            if (keyframes.find((k) => k.positionInBytes === keyframe.positionInBytes)) {
-                return;
-            }
-            keyframes.push(keyframe);
-        },
-        getKeyframes: () => {
-            return keyframes;
-        },
+        addKeyframe,
+        getKeyframes,
+        setFromSeekingHints,
     };
 };
 exports.keyframesState = keyframesState;

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

@@ -3,6 +3,7 @@ import type { MediaParserController } from '../../controller/media-parser-contro
 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, }: {
     controller: MediaParserController;
     logLevel: LogLevel;
@@ -14,6 +15,11 @@ export declare const lazyCuesFetch: ({ controller, logLevel, readerInterface, sr
         cues: MatroskaCue[];
         segmentOffset: number;
     } | null>;
+    getIfAlreadyLoaded: () => {
+        cues: MatroskaCue[];
+        segmentOffset: number;
+    } | null;
+    setFromSeekingHints: (hints: WebmSeekingHints) => void;
 };
 export type LazyCuesFetch = ReturnType<typeof lazyCuesFetch>;
-export type LazyCuesLoaded = Awaited<ReturnType<LazyCuesFetch['getLoadedCues']>>;
+export type LazyCuesLoadedOrNull = Awaited<ReturnType<LazyCuesFetch['getLoadedCues']>>;