@remotion/media-parser 4.0.240 → 4.0.242

package/dist/parse-media.js

@@ -3,50 +3,56 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMedia = void 0;
 const buffer_iterator_1 = require("./buffer-iterator");
 const emit_available_info_1 = require("./emit-available-info");
+const get_fields_from_callbacks_1 = require("./get-fields-from-callbacks");
 const has_all_info_1 = require("./has-all-info");
 const log_1 = require("./log");
 const parse_video_1 = require("./parse-video");
 const from_fetch_1 = require("./readers/from-fetch");
 const parser_state_1 = require("./state/parser-state");
-const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, logLevel = 'info', onParseProgress, ...more }) => {
+const parseMedia = async function ({ src, fields: _fieldsInReturnValue, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, logLevel = 'info', onParseProgress, ...more }) {
     let iterator = null;
     let parseResult = null;
-    const state = (0, parser_state_1.makeParserState)({
-        hasAudioTrackHandlers: Boolean(onAudioTrack),
-        hasVideoTrackHandlers: Boolean(onVideoTrack),
-        signal,
-        getIterator: () => iterator,
-        fields: fields !== null && fields !== void 0 ? fields : {},
+    const fieldsInReturnValue = _fieldsInReturnValue !== null && _fieldsInReturnValue !== void 0 ? _fieldsInReturnValue : {};
+    const fields = (0, get_fields_from_callbacks_1.getFieldsFromCallback)({
+        fields: fieldsInReturnValue,
+        callbacks: more,
     });
-    const { reader, contentLength, name, supportsContentRange: readerSupportsContentRange, } = await readerInterface.read(src, null, signal);
-    let currentReader = reader;
+    const { reader, contentLength, name, contentType, supportsContentRange: readerSupportsContentRange, } = await readerInterface.read(src, null, signal);
     const supportsContentRange = readerSupportsContentRange &&
         !(typeof process !== 'undefined' &&
             typeof process.env !== 'undefined' &&
             process.env.DISABLE_CONTENT_RANGE === 'true');
-    const returnValue = {};
-    const moreFields = more;
-    const options = {
+    const state = (0, parser_state_1.makeParserState)({
+        hasAudioTrackHandlers: Boolean(onAudioTrack),
+        hasVideoTrackHandlers: Boolean(onVideoTrack),
+        signal,
+        getIterator: () => iterator,
+        fields,
         onAudioTrack: onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : null,
         onVideoTrack: onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : null,
-        parserState: state,
         nullifySamples: !(typeof process !== 'undefined' &&
             typeof process.env !== 'undefined' &&
             process.env.KEEP_SAMPLES === 'true'),
         supportsContentRange,
-        nextTrackIndex: 0,
-    };
+    });
+    let currentReader = reader;
+    const returnValue = {};
+    const moreFields = more;
     const triggerInfoEmit = () => {
-        var _a;
-        const availableInfo = (0, has_all_info_1.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, (_a = parseResult === null || parseResult === void 0 ? void 0 : parseResult.segments) !== null && _a !== void 0 ? _a : null, state);
+        const availableInfo = (0, has_all_info_1.getAvailableInfo)({
+            fieldsToFetch: fields,
+            state,
+        });
         (0, emit_available_info_1.emitAvailableInfo)({
             hasInfo: availableInfo,
-            moreFields,
+            callbacks: moreFields,
+            fieldsInReturnValue,
             parseResult,
             state,
             returnValue,
             contentLength,
             name,
+            mimeType: contentType,
         });
     };
     triggerInfoEmit();
@@ -86,24 +92,26 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
         }));
         triggerInfoEmit();
         if (parseResult && parseResult.status === 'incomplete') {
-            log_1.Log.verbose(logLevel, 'Continuing parsing of file, currently at position', iterator.counter.getOffset());
+            log_1.Log.trace(logLevel, 'Continuing parsing of file, currently at position', iterator.counter.getOffset());
             parseResult = await parseResult.continueParsing();
         }
         else {
             parseResult = await (0, parse_video_1.parseVideo)({
                 iterator,
-                options,
+                state,
                 signal: signal !== null && signal !== void 0 ? signal : null,
                 logLevel,
-                fields: fields !== null && fields !== void 0 ? fields : {},
+                fields,
+                mimeType: contentType,
+                contentLength,
+                name,
             });
         }
         if (parseResult.status === 'incomplete' && parseResult.skipTo !== null) {
             state.increaseSkippedBytes(parseResult.skipTo - iterator.counter.getOffset());
         }
         if ((0, has_all_info_1.hasAllInfo)({
-            fields: fields !== null && fields !== void 0 ? fields : {},
-            structure: parseResult.segments,
+            fields,
             state,
         })) {
             log_1.Log.verbose(logLevel, 'Got all info, skipping to the end.');
@@ -128,24 +136,27 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
         }
     }
     log_1.Log.verbose(logLevel, 'Finished parsing file');
+    const hasInfo = Object.keys(fields).reduce((acc, key) => {
+        if (fields === null || fields === void 0 ? void 0 : fields[key]) {
+            acc[key] = true;
+        }
+        return acc;
+    }, {});
     // Force assign
     (0, emit_available_info_1.emitAvailableInfo)({
-        hasInfo: Object.keys(fields !== null && fields !== void 0 ? fields : {}).reduce((acc, key) => {
-            if (fields === null || fields === void 0 ? void 0 : fields[key]) {
-                acc[key] = true;
-            }
-            return acc;
-        }, {}),
-        moreFields,
+        hasInfo,
+        callbacks: moreFields,
+        fieldsInReturnValue,
         parseResult,
         state,
         returnValue,
         contentLength,
+        mimeType: contentType,
         name,
     });
     currentReader.abort();
     iterator === null || iterator === void 0 ? void 0 : iterator.destroy();
-    state.tracks.ensureHasTracksAtEnd();
+    state.callbacks.tracks.ensureHasTracksAtEnd();
     return returnValue;
 };
 exports.parseMedia = parseMedia;

package/dist/parse-result.d.ts

@@ -56,14 +56,12 @@ export type TransportStreamStructure = {
     boxes: TransportStreamBox[];
 };
 export type Structure = IsoBaseMediaStructure | RiffStructure | MatroskaStructure | TransportStreamStructure;
-export type ParseResult<TStructure extends Structure> = {
+export type ParseResult = {
     status: 'done';
-    segments: TStructure;
 } | {
     status: 'incomplete';
-    segments: TStructure;
     skipTo: number | null;
-    continueParsing: () => Promise<ParseResult<TStructure>>;
+    continueParsing: () => Promise<ParseResult>;
 };
 export type MatroskaParseResult = {
     status: 'done';

package/dist/parse-video.d.ts

@@ -1,8 +1,8 @@
 import type { BufferIterator } from './buffer-iterator';
 import { type LogLevel } from './log';
 import type { Options, ParseMediaFields } from './options';
-import type { IsoBaseMediaBox, ParseResult, Structure } from './parse-result';
-import type { ParserContext } from './parser-context';
+import type { IsoBaseMediaBox, ParseResult } from './parse-result';
+import type { ParserState } from './state/parser-state';
 export type PartialMdatBox = {
     type: 'partial-mdat-box';
     boxSize: number;
@@ -16,10 +16,13 @@ export type BoxAndNext = {
 } | {
     type: 'incomplete';
 } | PartialMdatBox;
-export declare const parseVideo: ({ iterator, options, signal, logLevel, fields, }: {
+export declare const parseVideo: ({ iterator, state, signal, logLevel, fields, mimeType, contentLength, name, }: {
     iterator: BufferIterator;
-    options: ParserContext;
+    state: ParserState;
     signal: AbortSignal | null;
     logLevel: LogLevel;
     fields: Options<ParseMediaFields>;
-}) => Promise<ParseResult<Structure>>;
+    mimeType: string | null;
+    contentLength: number | null;
+    name: string | null;
+}) => Promise<ParseResult>;

package/dist/parse-video.js

@@ -6,49 +6,126 @@ const parse_box_1 = require("./boxes/riff/parse-box");
 const next_pes_header_store_1 = require("./boxes/transport-stream/next-pes-header-store");
 const parse_transport_stream_1 = require("./boxes/transport-stream/parse-transport-stream");
 const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
+const errors_1 = require("./errors");
 const log_1 = require("./log");
-const parseVideo = ({ iterator, options, signal, logLevel, fields, }) => {
+const parseVideo = ({ iterator, state, signal, logLevel, fields, mimeType, contentLength, name, }) => {
     if (iterator.bytesRemaining() === 0) {
         return Promise.reject(new Error('no bytes'));
     }
-    if (iterator.isRiff()) {
+    const fileType = iterator.detectFileType();
+    if (fileType.type === 'riff') {
         log_1.Log.verbose(logLevel, 'Detected RIFF container');
-        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, options, fields }));
+        state.structure.setStructure({
+            type: 'riff',
+            boxes: [],
+        });
+        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, state, fields }));
     }
-    if (iterator.isIsoBaseMedia()) {
+    if (fileType.type === 'iso-base-media') {
         log_1.Log.verbose(logLevel, 'Detected ISO Base Media container');
+        const initialBoxes = [];
+        state.structure.setStructure({
+            type: 'iso-base-media',
+            boxes: initialBoxes,
+        });
         return (0, process_box_1.parseIsoBaseMediaBoxes)({
             iterator,
             maxBytes: Infinity,
             allowIncompleteBoxes: true,
-            initialBoxes: [],
-            options,
+            initialBoxes,
+            state,
             continueMdat: false,
             signal,
             logLevel,
             fields,
         });
     }
-    if (iterator.isWebm()) {
+    if (fileType.type === 'webm') {
         log_1.Log.verbose(logLevel, 'Detected Matroska container');
-        return (0, parse_webm_header_1.parseWebm)({ counter: iterator, parserContext: options, fields });
+        state.structure.setStructure({
+            boxes: [],
+            type: 'matroska',
+        });
+        return (0, parse_webm_header_1.parseWebm)({ counter: iterator, state, fields });
     }
-    if (iterator.isTransportStream()) {
+    if (fileType.type === 'transport-stream') {
+        log_1.Log.verbose(logLevel, 'Detected MPEG-2 Transport Stream');
+        state.structure.setStructure({
+            boxes: [],
+            type: 'transport-stream',
+        });
         return (0, parse_transport_stream_1.parseTransportStream)({
             iterator,
-            parserContext: options,
-            structure: {
-                type: 'transport-stream',
-                boxes: [],
-            },
+            state,
             streamBuffers: new Map(),
             fields,
             nextPesHeaderStore: (0, next_pes_header_store_1.makeNextPesHeaderStore)(),
         });
     }
-    if (iterator.isMp3()) {
-        return Promise.reject(new Error('MP3 files are not yet supported'));
+    if (fileType.type === 'mp3') {
+        return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
+            message: 'MP3 files are not yet supported',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+            audioType: 'mp3',
+        }));
+    }
+    if (fileType.type === 'wav') {
+        return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
+            message: 'WAV files are not yet supported',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+            audioType: 'wav',
+        }));
+    }
+    if (fileType.type === 'aac') {
+        return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
+            message: 'AAC files are not yet supported',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+            audioType: 'aac',
+        }));
+    }
+    if (fileType.type === 'gif') {
+        return Promise.reject(new errors_1.IsAGifError({
+            message: 'GIF files are not yet supported',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+        }));
+    }
+    if (fileType.type === 'pdf') {
+        return Promise.reject(new errors_1.IsAPdfError({
+            message: 'GIF files are not supported',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+        }));
+    }
+    if (fileType.type === 'bmp' ||
+        fileType.type === 'jpeg' ||
+        fileType.type === 'png' ||
+        fileType.type === 'webp') {
+        return Promise.reject(new errors_1.IsAnImageError({
+            message: 'Image files are not supported',
+            imageType: fileType.type,
+            dimensions: fileType.dimensions,
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+        }));
+    }
+    if (fileType.type === 'unknown') {
+        return Promise.reject(new errors_1.IsAnUnsupportedFileTypeError({
+            message: 'Unknown file format',
+            mimeType,
+            sizeInBytes: contentLength,
+            fileName: name,
+        }));
     }
-    return Promise.reject(new Error('Unknown video format'));
+    return Promise.reject(new Error('Unknown video format ' + fileType));
 };
 exports.parseVideo = parseVideo;

package/dist/probing/detect-file-type.d.ts

@@ -0,0 +1 @@
+export declare const detectFileType: (data: Uint8Array) => "webp" | "riff" | "webm" | "iso-base-media" | "transport-stream" | "mp3" | "gif" | "png" | "bmp" | "jpeg" | "unknown";

package/dist/probing/detect-file-type.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFileType = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const get_jpeg_dimensions_1 = require("./get-jpeg-dimensions");
+const matchesPattern = (pattern) => {
+    return (data) => {
+        return pattern.every((value, index) => data[index] === value);
+    };
+};
+const isRiff = (data) => {
+    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    return matchesPattern(riffPattern)(data.subarray(0, 4));
+};
+const isWebm = (data) => {
+    return matchesPattern(make_header_1.webmPattern)(data.subarray(0, 4));
+};
+const isIsoBaseMedia = (data) => {
+    const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
+    return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
+};
+const isTransportStream = (data) => {
+    return data[0] === 0x47 && data[188] === 0x47;
+};
+const isMp3 = (data) => {
+    const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
+    return matchesPattern(mpegPattern)(data.subarray(0, 4));
+};
+const isGif = (data) => {
+    const gifPattern = new Uint8Array([0x47, 0x49, 0x46, 0x38]);
+    return matchesPattern(gifPattern)(data.subarray(0, 4));
+};
+const isPng = (data) => {
+    const pngPattern = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
+    return matchesPattern(pngPattern)(data.subarray(0, 4));
+};
+const isBmp = (data) => {
+    const bmpPattern = new Uint8Array([0x42, 0x4d]);
+    return matchesPattern(bmpPattern)(data.subarray(0, 2));
+};
+const isJpeg = (data) => {
+    const jpegPattern = new Uint8Array([0xff, 0xd8]);
+    const jpeg = matchesPattern(jpegPattern)(data.subarray(0, 2));
+    if (!jpeg) {
+        return false;
+    }
+    const dim = (0, get_jpeg_dimensions_1.getJpegDimensions)(data);
+    console.log(dim);
+    return true;
+};
+const isWebp = (data) => {
+    const webpPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
+    return matchesPattern(webpPattern)(data.subarray(0, 4));
+};
+const detectFileType = (data) => {
+    if (isWebp(data)) {
+        return 'webp';
+    }
+    if (isRiff(data)) {
+        return 'riff';
+    }
+    if (isWebm(data)) {
+        return 'webm';
+    }
+    if (isIsoBaseMedia(data)) {
+        return 'iso-base-media';
+    }
+    if (isTransportStream(data)) {
+        return 'transport-stream';
+    }
+    if (isMp3(data)) {
+        return 'mp3';
+    }
+    if (isGif(data)) {
+        return 'gif';
+    }
+    if (isPng(data)) {
+        return 'png';
+    }
+    if (isBmp(data)) {
+        return 'bmp';
+    }
+    if (isJpeg(data)) {
+        return 'jpeg';
+    }
+    return 'unknown';
+};
+exports.detectFileType = detectFileType;

package/dist/probing/get-jpeg-dimensions.d.ts

@@ -0,0 +1,4 @@
+export declare function getJpegDimensions(data: Uint8Array): {
+    width: number;
+    height: number;
+} | null;

package/dist/probing/get-jpeg-dimensions.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJpegDimensions = getJpegDimensions;
+function getJpegDimensions(data) {
+    let offset = 0;
+    // Helper function to read a 16-bit big-endian integer
+    function readUint16BE(o) {
+        return (data[o] << 8) | data[o + 1];
+    }
+    // Skip the Start of Image (SOI) marker
+    if (readUint16BE(offset) !== 0xffd8) {
+        return null; // Not a valid JPEG file
+    }
+    offset += 2;
+    while (offset < data.length) {
+        if (data[offset] === 0xff) {
+            const marker = data[offset + 1];
+            if (marker === 0xc0 || marker === 0xc2) {
+                // SOF0 or SOF2
+                const height = readUint16BE(offset + 5);
+                const width = readUint16BE(offset + 7);
+                return { width, height };
+            }
+            const length = readUint16BE(offset + 2);
+            offset += length + 2; // Move to the next marker
+        }
+        else {
+            offset++;
+        }
+    }
+    return null; // Return null if dimensions are not found
+}

package/dist/readers/from-fetch.js

@@ -110,6 +110,7 @@ exports.fetchReader = {
                 },
             },
             contentLength,
+            contentType: res.headers.get('content-type'),
             name: name !== null && name !== void 0 ? name : fallbackName,
             supportsContentRange,
         };

package/dist/readers/from-node.js

@@ -38,6 +38,7 @@ exports.nodeReader = {
                 },
             },
             contentLength: stats.size,
+            contentType: null,
             name: src.split(path_1.sep).pop(),
             supportsContentRange: true,
         };

package/dist/readers/from-web-file.js

@@ -39,6 +39,7 @@ exports.webFileReader = {
                     contentLength: file.size,
                     name: file.name,
                     supportsContentRange: true,
+                    contentType: file.type,
                 });
             };
             reader.onerror = (error) => {

package/dist/readers/reader.d.ts

@@ -5,6 +5,7 @@ type Reader = {
 type ReadResult = {
     reader: Reader;
     contentLength: number | null;
+    contentType: string | null;
     name: string;
     supportsContentRange: boolean;
 };

package/dist/register-track.d.ts

@@ -1,13 +1,13 @@
 import type { Track, VideoTrack } from './get-tracks';
 import type { ParseMediaContainer } from './options';
-import type { ParserContext } from './parser-context';
-export declare const registerTrack: ({ options, track, container, }: {
-    options: ParserContext;
+import type { ParserState } from './state/parser-state';
+export declare const registerTrack: ({ state, track, container, }: {
+    state: ParserState;
     track: Track;
     container: ParseMediaContainer;
 }) => Promise<void>;
-export declare const registerVideoTrackWhenProfileIsAvailable: ({ options, track, container, }: {
-    options: ParserContext;
+export declare const registerVideoTrackWhenProfileIsAvailable: ({ state, track, container, }: {
+    state: ParserState;
     track: VideoTrack;
     container: ParseMediaContainer;
 }) => void;

package/dist/register-track.js

@@ -2,27 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerVideoTrackWhenProfileIsAvailable = exports.registerTrack = void 0;
 const add_avc_profile_to_track_1 = require("./add-avc-profile-to-track");
-const registerTrack = async ({ options, track, container, }) => {
+const registerTrack = async ({ state, track, container, }) => {
     if (track.type === 'video') {
-        options.parserState.tracks.addTrack(track);
-        if (options.onVideoTrack) {
-            const callback = await options.onVideoTrack({ track, container });
-            await options.parserState.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+        state.callbacks.tracks.addTrack(track);
+        if (state.onVideoTrack) {
+            const callback = await state.onVideoTrack({ track, container });
+            await state.callbacks.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
         }
     }
     if (track.type === 'audio') {
-        options.parserState.tracks.addTrack(track);
-        if (options.onAudioTrack) {
-            const callback = await options.onAudioTrack({ track, container });
-            await options.parserState.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+        state.callbacks.tracks.addTrack(track);
+        if (state.onAudioTrack) {
+            const callback = await state.onAudioTrack({ track, container });
+            await state.callbacks.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
         }
     }
 };
 exports.registerTrack = registerTrack;
-const registerVideoTrackWhenProfileIsAvailable = ({ options, track, container, }) => {
-    options.parserState.registerOnAvcProfileCallback(async (profile) => {
+const registerVideoTrackWhenProfileIsAvailable = ({ state, track, container, }) => {
+    state.riff.registerOnAvcProfileCallback(async (profile) => {
         await (0, exports.registerTrack)({
-            options,
+            state,
             track: (0, add_avc_profile_to_track_1.addAvcProfileToTrack)(track, profile),
             container,
         });

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

@@ -6,6 +6,8 @@ const needsTracksField = {
     container: false,
     dimensions: true,
     durationInSeconds: true,
+    slowDurationInSeconds: true,
+    slowFps: true,
     fps: true,
     internalStats: false,
     isHdr: true,
@@ -18,6 +20,10 @@ const needsTracksField = {
     videoCodec: true,
     metadata: true,
     location: true,
+    mimeType: false,
+    slowKeyframes: true,
+    slowNumberOfFrames: true,
+    keyframes: true,
 };
 const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, }) => {
     return {

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

@@ -0,0 +1,2 @@
+import type { AllOptions, ParseMediaFields } from '../options';
+export declare const emittedState: () => AllOptions<ParseMediaFields>;

package/dist/state/emitted-fields.js

@@ -0,0 +1,31 @@
+"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,
+    };
+    return emittedFields;
+};
+exports.emittedState = emittedState;

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

@@ -7,3 +7,4 @@ export declare const makeTracksSectionState: (canSkipTracksState: CanSkipTracksS
     getTracks: () => Track[];
     ensureHasTracksAtEnd: () => void;
 };
+export type TracksState = ReturnType<typeof makeTracksSectionState>;

package/dist/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/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;