@remotion/media-parser 4.0.280 → 4.0.284

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMediaOnWorkerImplementation = void 0;
+const with_resolvers_1 = require("./with-resolvers");
 const serialize_error_1 = require("./worker/serialize-error");
 const convertToWorkerPayload = (
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -48,16 +49,12 @@ payload) => {
 const post = (worker, payload) => {
     worker.postMessage(payload);
 };
-const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params }, workerUrlEntry, apiName) => {
-    if (typeof Worker === 'undefined') {
-        throw new Error('"Worker" is not available. Cannot call workerClient()');
-    }
+const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params }, worker, apiName) => {
     if (reader) {
         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().`);
     }
-    const worker = new Worker(workerUrlEntry);
     post(worker, convertToWorkerPayload(params));
-    const { promise, resolve, reject } = Promise.withResolvers();
+    const { promise, resolve, reject } = (0, with_resolvers_1.withResolvers)();
     const onAbort = () => {
         post(worker, { type: 'request-abort' });
     };
@@ -67,6 +64,10 @@ const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params
     const onPause = () => {
         post(worker, { type: 'request-pause' });
     };
+    const onSeek = ({ detail: { seek } }) => {
+        post(worker, { type: 'request-seek', payload: seek });
+        controller === null || controller === void 0 ? void 0 : controller._internals.seekSignal.clearSeekIfStillSame(seek);
+    };
     const callbacks = {};
     function onMessage(message) {
         const data = message.data;
@@ -259,13 +260,16 @@ const parseMediaOnWorkerImplementation = async ({ controller, reader, ...params
     controller === null || controller === void 0 ? void 0 : controller.addEventListener('abort', onAbort);
     controller === null || controller === void 0 ? void 0 : controller.addEventListener('resume', onResume);
     controller === null || controller === void 0 ? void 0 : controller.addEventListener('pause', onPause);
+    controller === null || controller === void 0 ? void 0 : controller.addEventListener('seek', onSeek);
     function cleanup() {
         worker.removeEventListener('message', onMessage);
         controller === null || controller === void 0 ? void 0 : controller.removeEventListener('abort', onAbort);
         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);
         worker.terminate();
     }
+    controller === null || controller === void 0 ? void 0 : controller._internals.markAsReadyToEmitEvents();
     const val = await promise;
     cleanup();
     return val;

package/dist/perform-seek.d.ts

@@ -1,5 +1,25 @@
-import type { ParserState } from './state/parser-state';
-export declare const performSeek: ({ seekTo, state, }: {
+import type { MediaParserController } from './controller/media-parser-controller';
+import type { AllOptions, ParseMediaFields } from './fields';
+import type { BufferIterator } from './iterator/buffer-iterator';
+import type { LogLevel } from './log';
+import type { ParseMediaMode, ParseMediaSrc } from './options';
+import type { ReaderInterface } from './readers/reader';
+import type { CurrentReader } from './state/current-reader';
+import type { SeekInfiniteLoop } from './state/seek-infinite-loop';
+import type { MediaSectionState } from './state/video-section';
+export declare const performSeek: ({ seekTo, userInitiated, controller, mediaSection, iterator, seekInfiniteLoop, logLevel, mode, contentLength, currentReader, readerInterface, src, discardReadBytes, fields, }: {
     seekTo: number;
-    state: ParserState;
+    userInitiated: boolean;
+    controller: MediaParserController;
+    mediaSection: MediaSectionState;
+    iterator: BufferIterator;
+    logLevel: LogLevel;
+    mode: ParseMediaMode;
+    contentLength: number;
+    seekInfiniteLoop: SeekInfiniteLoop;
+    currentReader: CurrentReader;
+    readerInterface: ReaderInterface;
+    fields: Partial<AllOptions<ParseMediaFields>>;
+    src: ParseMediaSrc;
+    discardReadBytes: (force: boolean) => Promise<void>;
 }) => Promise<void>;

package/dist/perform-seek.js

@@ -4,13 +4,24 @@ exports.performSeek = void 0;
 const log_1 = require("./log");
 const seek_backwards_1 = require("./seek-backwards");
 const seek_forwards_1 = require("./seek-forwards");
-const performSeek = async ({ seekTo, state, }) => {
-    var _a, _b;
-    const { iterator, logLevel, mode, contentLength } = state;
+const video_section_1 = require("./state/video-section");
+const performSeek = async ({ seekTo, userInitiated, controller, mediaSection, iterator, seekInfiniteLoop, logLevel, mode, contentLength, currentReader, readerInterface, src, discardReadBytes, fields, }) => {
+    const byteInMediaSection = (0, video_section_1.isByteInMediaSection)({
+        position: seekTo,
+        mediaSections: mediaSection.getMediaSections(),
+    });
+    if (byteInMediaSection !== 'in-section' && userInitiated) {
+        const sections = mediaSection.getMediaSections();
+        const sectionStrings = sections.map((section) => {
+            return `start: ${section.start}, end: ${section.size + section.start}`;
+        });
+        throw new Error(`Cannot seek to a byte that is not in the video section. Seeking to: ${seekTo}, sections: ${sectionStrings.join(' | ')}`);
+    }
+    seekInfiniteLoop.registerSeek(seekTo);
     if (seekTo <= iterator.counter.getOffset() && mode === 'download') {
         throw new Error(`Seeking backwards is not supported in parseAndDownloadMedia() mode. Current position: ${iterator.counter.getOffset()}, seekTo: ${seekTo}`);
     }
-    if (seekTo > state.contentLength) {
+    if (seekTo > contentLength) {
         throw new Error(`Cannot seek beyond the end of the file: ${seekTo} > ${contentLength}`);
     }
     if (mode === 'download') {
@@ -18,19 +29,44 @@ const performSeek = async ({ seekTo, state, }) => {
         iterator.discard(seekTo - iterator.counter.getOffset());
         return;
     }
-    await ((_a = state.controller) === null || _a === void 0 ? void 0 : _a._internals.checkForAbortAndPause());
+    await controller._internals.checkForAbortAndPause();
     const alreadyAtByte = iterator.counter.getOffset() === seekTo;
     if (alreadyAtByte) {
         log_1.Log.verbose(logLevel, `Already at the desired position, seeking done`);
+        controller._internals.performedSeeksSignal.markLastSeekAsUserInitiated();
         return;
     }
     const skippingForward = seekTo > iterator.counter.getOffset();
+    controller._internals.performedSeeksSignal.recordSeek({
+        from: iterator.counter.getOffset(),
+        to: seekTo,
+        type: userInitiated ? 'user-initiated' : 'internal',
+    });
     if (skippingForward) {
-        await (0, seek_forwards_1.seekForward)(state, seekTo);
+        await (0, seek_forwards_1.seekForward)({
+            seekTo,
+            userInitiated,
+            iterator,
+            fields,
+            logLevel,
+            currentReader,
+            readerInterface,
+            src,
+            controller,
+            discardReadBytes,
+        });
     }
     else {
-        await (0, seek_backwards_1.seekBackwards)(state, seekTo);
+        await (0, seek_backwards_1.seekBackwards)({
+            controller,
+            seekTo,
+            iterator,
+            logLevel,
+            currentReader,
+            readerInterface,
+            src,
+        });
     }
-    await ((_b = state.controller) === null || _b === void 0 ? void 0 : _b._internals.checkForAbortAndPause());
+    await controller._internals.checkForAbortAndPause();
 };
 exports.performSeek = performSeek;

package/dist/readers/reader.d.ts

@@ -1,4 +1,4 @@
-import type { MediaParserController } from '../media-parser-controller';
+import type { MediaParserController } from '../controller/media-parser-controller';
 import type { ParseMediaSrc } from '../options';
 export type Reader = {
     reader: ReadableStreamDefaultReader<Uint8Array>;

package/dist/readers/state/aac-state.d.ts

@@ -0,0 +1,13 @@
+type AacSamplePosition = {
+    offset: number;
+    index: number;
+    size: number;
+};
+export declare const aacState: () => {
+    addSample: ({ offset, size }: {
+        offset: number;
+        size: number;
+    }) => AacSamplePosition;
+    getSamples: () => AacSamplePosition[];
+};
+export {};

package/dist/readers/state/aac-state.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aacState = void 0;
+const aacState = () => {
+    const samples = [];
+    return {
+        addSample: ({ offset, size }) => {
+            if (samples.find((s) => s.offset === offset)) {
+                throw new Error('Duplicate sample');
+            }
+            samples.push({ offset, index: samples.length, size });
+            return samples[samples.length - 1];
+        },
+        getSamples: () => samples,
+    };
+};
+exports.aacState = aacState;

package/dist/readers/state/can-skip-tracks.d.ts

@@ -0,0 +1,16 @@
+import type { Options, ParseMediaFields } from '../fields';
+import type { MediaParserStructureUnstable } from '../parse-result';
+import type { StructureState } from './structure';
+export declare const needsTracksForField: ({ field, structure, }: {
+    field: keyof Options<ParseMediaFields>;
+    structure: MediaParserStructureUnstable | null;
+}) => boolean;
+export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }: {
+    hasAudioTrackHandlers: boolean;
+    hasVideoTrackHandlers: boolean;
+    fields: Options<ParseMediaFields>;
+    structure: StructureState;
+}) => {
+    canSkipTracks: () => boolean;
+};
+export type CanSkipTracksState = ReturnType<typeof makeCanSkipTracksState>;

package/dist/readers/state/can-skip-tracks.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCanSkipTracksState = exports.needsTracksForField = void 0;
+const needsTracksForField = ({ field, structure, }) => {
+    if (field === 'dimensions') {
+        if ((structure === null || structure === void 0 ? void 0 : structure.type) === 'riff') {
+            return false;
+        }
+        return true;
+    }
+    if (field === 'audioCodec' ||
+        field === 'durationInSeconds' ||
+        field === 'slowDurationInSeconds' ||
+        field === 'slowFps' ||
+        field === 'fps' ||
+        field === 'isHdr' ||
+        field === 'rotation' ||
+        field === 'structure' ||
+        field === 'tracks' ||
+        field === 'unrotatedDimensions' ||
+        field === 'videoCodec' ||
+        field === 'metadata' ||
+        field === 'location' ||
+        field === 'slowKeyframes' ||
+        field === 'slowNumberOfFrames' ||
+        field === 'keyframes' ||
+        field === 'images' ||
+        field === 'sampleRate' ||
+        field === 'numberOfAudioChannels' ||
+        field === 'slowAudioBitrate' ||
+        field === 'slowVideoBitrate' ||
+        field === 'm3uStreams') {
+        return true;
+    }
+    if (field === 'container' ||
+        field === 'internalStats' ||
+        field === 'mimeType' ||
+        field === 'name' ||
+        field === 'size') {
+        return false;
+    }
+    throw new Error(`field not implemeted ${field}`);
+};
+exports.needsTracksForField = needsTracksForField;
+const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }) => {
+    return {
+        canSkipTracks: () => {
+            if (hasAudioTrackHandlers || hasVideoTrackHandlers) {
+                return false;
+            }
+            const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});
+            const selectedKeys = keys.filter((k) => fields[k]);
+            return !selectedKeys.some((k) => (0, exports.needsTracksForField)({
+                field: k,
+                structure: structure.getStructureOrNull(),
+            }));
+        },
+    };
+};
+exports.makeCanSkipTracksState = makeCanSkipTracksState;

package/dist/readers/state/current-reader.d.ts

@@ -0,0 +1,6 @@
+import type { Reader } from '../readers/reader';
+export declare const currentReader: (initialReader: Reader) => {
+    getCurrent: () => Reader;
+    setCurrent: (newReader: Reader) => void;
+};
+export type CurrentReader = ReturnType<typeof currentReader>;

package/dist/readers/state/current-reader.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentReader = void 0;
+const currentReader = (initialReader) => {
+    let current = initialReader;
+    return {
+        getCurrent: () => current,
+        setCurrent: (newReader) => {
+            current = newReader;
+        },
+    };
+};
+exports.currentReader = currentReader;

package/dist/readers/state/emitted-fields.d.ts

@@ -0,0 +1 @@
+export declare const emittedState: () => AllOptions<ParseMediaFields>;

package/dist/readers/state/emitted-fields.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emittedState = void 0;
+const emittedState = () => {
+    const emittedFields = {
+        audioCodec: false,
+        container: false,
+        dimensions: false,
+        durationInSeconds: false,
+        fps: false,
+        internalStats: false,
+        isHdr: false,
+        location: false,
+        metadata: false,
+        mimeType: false,
+        name: false,
+        rotation: false,
+        size: false,
+        structure: false,
+        tracks: false,
+        videoCodec: false,
+        unrotatedDimensions: false,
+        slowDurationInSeconds: false,
+        slowFps: false,
+        slowKeyframes: false,
+        slowNumberOfFrames: false,
+        keyframes: false,
+        images: false,
+        numberOfAudioChannels: false,
+        sampleRate: false,
+        slowAudioBitrate: false,
+        slowVideoBitrate: false,
+        m3uStreams: false,
+    };
+    return emittedFields;
+};
+exports.emittedState = emittedState;

package/dist/readers/state/flac-state.d.ts

@@ -0,0 +1,4 @@
+export declare const flacState: () => {
+    setBlockingBitStrategy: (strategy: number) => void;
+    getBlockingBitStrategy: () => number | undefined;
+};

package/dist/readers/state/flac-state.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flacState = void 0;
+const flacState = () => {
+    let blockingBitStrategy;
+    return {
+        setBlockingBitStrategy: (strategy) => {
+            blockingBitStrategy = strategy;
+        },
+        getBlockingBitStrategy: () => blockingBitStrategy,
+    };
+};
+exports.flacState = flacState;

package/dist/readers/state/has-tracks-section.d.ts

@@ -0,0 +1,14 @@
+import type { Options, ParseMediaFields } from '../fields';
+import type { Track } from '../get-tracks';
+import type { LogLevel } from '../log';
+import type { ParseMediaSrc } from '../options';
+import type { CanSkipTracksState } from './can-skip-tracks';
+export declare const makeTracksSectionState: (canSkipTracksState: CanSkipTracksState, src: ParseMediaSrc) => {
+    hasAllTracks: () => boolean;
+    getIsDone: () => boolean;
+    setIsDone: (logLevel: LogLevel) => void;
+    addTrack: (track: Track) => void;
+    getTracks: () => Track[];
+    ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;
+};
+export type TracksState = ReturnType<typeof makeTracksSectionState>;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTracksSectionState = void 0;
+const log_1 = require("../log");
+const makeTracksSectionState = (canSkipTracksState, src) => {
+    const tracks = [];
+    let doneWithTracks = false;
+    return {
+        hasAllTracks: () => doneWithTracks,
+        getIsDone: () => doneWithTracks,
+        setIsDone: (logLevel) => {
+            if (doneWithTracks) {
+                throw new Error('Error in Media Parser: Tracks have already been parsed');
+            }
+            log_1.Log.verbose(logLevel, 'All tracks have been parsed');
+            doneWithTracks = true;
+        },
+        addTrack: (track) => {
+            tracks.push(track);
+        },
+        getTracks: () => tracks,
+        ensureHasTracksAtEnd: (fields) => {
+            if (canSkipTracksState.canSkipTracks()) {
+                return;
+            }
+            if (!fields.tracks) {
+                return;
+            }
+            if (!doneWithTracks) {
+                throw new Error('Error in Media Parser: End of parsing of ' +
+                    src +
+                    ' has been reached, but no tracks have been found ');
+            }
+        },
+    };
+};
+exports.makeTracksSectionState = makeTracksSectionState;

package/dist/readers/state/images.d.ts

@@ -0,0 +1,9 @@
+export type MediaParserEmbeddedImage = {
+    description: string | null;
+    mimeType: string | null;
+    data: Uint8Array;
+};
+export declare const imagesState: () => {
+    images: MediaParserEmbeddedImage[];
+    addImage: (image: MediaParserEmbeddedImage) => void;
+};

package/dist/readers/state/images.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imagesState = void 0;
+const imagesState = () => {
+    const images = [];
+    const addImage = (image) => {
+        images.push(image);
+    };
+    return {
+        images,
+        addImage,
+    };
+};
+exports.imagesState = imagesState;

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

@@ -0,0 +1,12 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { ParserState } from '../parser-state';
+export type FlatSample = {
+    track: VideoTrack | AudioTrack | OtherTrack;
+    samplePosition: SamplePosition;
+};
+export declare const calculateFlatSamples: (state: ParserState) => any[];
+export declare const cachedSamplePositionsState: () => {
+    getSamples: (mdatStart: number) => FlatSample[] | null;
+    setSamples: (mdatStart: number, samples: FlatSample[]) => void;
+};

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedSamplePositionsState = exports.calculateFlatSamples = void 0;
+const get_sample_positions_from_track_1 = require("../../containers/iso-base-media/get-sample-positions-from-track");
+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 allTracks = [
+        ...tracks.videoTracks,
+        ...tracks.audioTracks,
+        ...tracks.otherTracks,
+    ];
+    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),
+            tfraBoxes: (0, traversal_1.getTfraBoxes)(state.structure.getIsoStructure()),
+        });
+        return samplePositions.map((samplePosition) => {
+            return {
+                track,
+                samplePosition,
+            };
+        });
+    })
+        .flat(1);
+    return flatSamples;
+};
+exports.calculateFlatSamples = calculateFlatSamples;
+const cachedSamplePositionsState = () => {
+    const cachedForMdatStart = {};
+    return {
+        getSamples: (mdatStart) => {
+            if (cachedForMdatStart[mdatStart]) {
+                return cachedForMdatStart[mdatStart];
+            }
+            return null;
+        },
+        setSamples: (mdatStart, samples) => {
+            cachedForMdatStart[mdatStart] = samples;
+        },
+    };
+};
+exports.cachedSamplePositionsState = cachedSamplePositionsState;

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

@@ -0,0 +1,24 @@
+import type { MediaParserController } from '../../controller/media-parser-controller';
+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, }: {
+    contentLength: number;
+    controller: MediaParserController;
+    readerInterface: ReaderInterface;
+    src: ParseMediaSrc;
+    logLevel: LogLevel;
+}) => {
+    flatSamples: {
+        getSamples: (mdatStart: number) => import("./cached-sample-positions").FlatSample[] | null;
+        setSamples: (mdatStart: number, samples: import("./cached-sample-positions").FlatSample[]) => void;
+    };
+    moov: {
+        setMoovBox: (moov: MediaParserController) => void;
+        getMoovBox: () => any;
+    };
+    mfra: {
+        triggerLoad: () => Promise<IsoBaseMediaBox[] | null> | null;
+    };
+};
+export type IsoBaseMediaState = ReturnType<typeof isoBaseMediaState>;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 isoBaseMediaState = ({ contentLength, controller, readerInterface, src, logLevel, }) => {
+    return {
+        flatSamples: (0, cached_sample_positions_1.cachedSamplePositionsState)(),
+        moov: (0, moov_box_1.moovState)(),
+        mfra: (0, lazy_mfra_load_1.lazyMfraLoad)({
+            contentLength,
+            controller,
+            readerInterface,
+            src,
+            logLevel,
+        }),
+    };
+};
+exports.isoBaseMediaState = isoBaseMediaState;

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

@@ -0,0 +1,13 @@
+import type { MediaParserController } from '../../controller/media-parser-controller';
+import { type LogLevel } from '../../log';
+import type { ParseMediaSrc } from '../../options';
+import type { ReaderInterface } from '../../readers/reader';
+export declare const lazyMfraLoad: ({ contentLength, controller, readerInterface, src, logLevel, }: {
+    contentLength: number;
+    controller: MediaParserController;
+    readerInterface: ReaderInterface;
+    src: ParseMediaSrc;
+    logLevel: LogLevel;
+}) => {
+    triggerLoad: () => Promise<IsoBaseMediaBox[] | null> | null;
+};

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

@@ -0,0 +1,29 @@
+"use strict";
+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, }) => {
+    let prom = null;
+    const triggerLoad = () => {
+        if (prom) {
+            return prom;
+        }
+        log_1.Log.verbose(logLevel, 'Moof box found, trying to lazy load mfra');
+        prom = (0, get_mfra_seeking_box_1.getMfraSeekingBox)({
+            contentLength,
+            controller,
+            readerInterface,
+            src,
+            logLevel,
+        }).then((boxes) => {
+            log_1.Log.verbose(logLevel, 'Lazily found mfra atom.');
+            return boxes;
+        });
+        return prom;
+    };
+    return {
+        triggerLoad,
+    };
+};
+exports.lazyMfraLoad = lazyMfraLoad;

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

@@ -0,0 +1,5 @@
+import type { MoovBox } from '../../containers/iso-base-media/moov/moov';
+export declare const moovState: () => {
+    setMoovBox: (moov: MoovBox) => void;
+    getMoovBox: () => any;
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moovState = void 0;
+const moovState = () => {
+    let moovBox = null;
+    return {
+        setMoovBox: (moov) => {
+            moovBox = moov;
+        },
+        getMoovBox: () => moovBox,
+    };
+};
+exports.moovState = moovState;

package/dist/readers/state/keyframes.d.ts

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

package/dist/readers/state/keyframes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyframesState = void 0;
+const keyframesState = () => {
+    const keyframes = [];
+    return {
+        addKeyframe: (keyframe) => {
+            keyframes.push(keyframe);
+        },
+        getKeyframes: () => {
+            return keyframes;
+        },
+    };
+};
+exports.keyframesState = keyframesState;