@remotion/media-parser 4.0.286 → 4.0.287

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

@@ -61,15 +61,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/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']>>;

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

@@ -6,6 +6,7 @@ const log_1 = require("../../log");
 const lazyCuesFetch = ({ controller, logLevel, readerInterface, src, }) => {
     let prom = null;
     let sOffset = null;
+    let result = null;
     const triggerLoad = (position, segmentOffset) => {
         if (prom) {
             return prom;
@@ -23,6 +24,7 @@ const lazyCuesFetch = ({ controller, logLevel, readerInterface, src, }) => {
             src,
         }).then((cues) => {
             log_1.Log.verbose(logLevel, 'Cues loaded');
+            result = cues;
             return cues;
         });
         return prom;
@@ -43,9 +45,28 @@ const lazyCuesFetch = ({ controller, logLevel, readerInterface, src, }) => {
             segmentOffset: sOffset,
         };
     };
+    const getIfAlreadyLoaded = () => {
+        if (result) {
+            if (!sOffset) {
+                throw new Error('Segment offset not set');
+            }
+            return {
+                cues: result,
+                segmentOffset: sOffset,
+            };
+        }
+        return null;
+    };
+    const setFromSeekingHints = (hints) => {
+        var _a, _b, _c, _d;
+        result = (_b = (_a = hints.loadedCues) === null || _a === void 0 ? void 0 : _a.cues) !== null && _b !== void 0 ? _b : null;
+        sOffset = (_d = (_c = hints.loadedCues) === null || _c === void 0 ? void 0 : _c.segmentOffset) !== null && _d !== void 0 ? _d : null;
+    };
     return {
         triggerLoad,
         getLoadedCues,
+        getIfAlreadyLoaded,
+        setFromSeekingHints,
     };
 };
 exports.lazyCuesFetch = lazyCuesFetch;

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

@@ -28,11 +28,18 @@ export declare const webmState: ({ controller, logLevel, readerInterface, src, }
             cues: import("../../containers/webm/seek/format-cues").MatroskaCue[];
             segmentOffset: number;
         } | null>;
+        getIfAlreadyLoaded: () => {
+            cues: import("../../containers/webm/seek/format-cues").MatroskaCue[];
+            segmentOffset: number;
+        } | null;
+        setFromSeekingHints: (hints: import("../../seeking-hints").WebmSeekingHints) => void;
     };
     onTrackEntrySegment: OnTrackEntrySegment;
     getTrackInfoByNumber: (id: number) => TrackInfo;
     setTimestampOffset: (byteOffset: number, timestamp: number) => void;
     getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
+    getTimeStampMapForSeekingHints: () => Map<number, number>;
+    setTimeStampMapForSeekingHints: (newTimestampMap: Map<number, number>) => void;
     getTimescale: () => number;
     setTimescale: (newTimescale: number) => void;
     addSegment: (seg: Omit<SegmentSection, "index">) => void;

package/dist/state/matroska/webm.js

@@ -24,7 +24,7 @@ const webmState = ({ controller, logLevel, readerInterface, src, }) => {
             trackTimescale: (_a = trackTimescale === null || trackTimescale === void 0 ? void 0 : trackTimescale.value) !== null && _a !== void 0 ? _a : null,
         };
     };
-    const timestampMap = new Map();
+    let timestampMap = new Map();
     const getTimestampOffsetForByteOffset = (byteOffset) => {
         const entries = Array.from(timestampMap.entries());
         const sortedByByteOffset = entries
@@ -71,12 +71,20 @@ const webmState = ({ controller, logLevel, readerInterface, src, }) => {
         readerInterface,
         src,
     });
+    const getTimeStampMapForSeekingHints = () => {
+        return timestampMap;
+    };
+    const setTimeStampMapForSeekingHints = (newTimestampMap) => {
+        timestampMap = newTimestampMap;
+    };
     return {
         cues,
         onTrackEntrySegment,
         getTrackInfoByNumber: (id) => trackEntries[id],
         setTimestampOffset,
         getTimestampOffsetForByteOffset,
+        getTimeStampMapForSeekingHints,
+        setTimeStampMapForSeekingHints,
         getTimescale,
         setTimescale,
         addSegment: (seg) => {