@remotion/media-parser 4.0.230 → 4.0.232

package/dist/options.d.ts

@@ -1,7 +1,7 @@
 import type { Dimensions } from './get-dimensions';
 import type { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, VideoTrack } from './get-tracks';
 import type { LogLevel } from './log';
-import type { AnySegment } from './parse-result';
+import type { Structure } from './parse-result';
 import type { InternalStats } from './parser-state';
 import type { ReaderInterface } from './readers/reader';
 import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
@@ -9,7 +9,7 @@ export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'vorbis
 export type ParseMediaFields = {
     dimensions: boolean;
     durationInSeconds: boolean;
-    boxes: boolean;
+    structure: boolean;
     fps: boolean;
     videoCodec: boolean;
     audioCodec: boolean;
@@ -24,7 +24,7 @@ export type ParseMediaFields = {
 export type AllParseMediaFields = {
     dimensions: true;
     durationInSeconds: true;
-    boxes: true;
+    structure: true;
     fps: true;
     videoCodec: true;
     audioCodec: true;
@@ -39,7 +39,7 @@ export type AllParseMediaFields = {
 export type Options<Fields extends ParseMediaFields> = {
     dimensions?: Fields['dimensions'];
     durationInSeconds?: Fields['durationInSeconds'];
-    boxes?: Fields['boxes'];
+    structure?: Fields['structure'];
     fps?: Fields['fps'];
     videoCodec?: Fields['videoCodec'];
     audioCodec?: Fields['audioCodec'];
@@ -55,13 +55,13 @@ export type TracksField = {
     videoTracks: VideoTrack[];
     audioTracks: AudioTrack[];
 };
-export type ParseMediaContainer = 'mp4' | 'webm';
+export type ParseMediaContainer = 'mp4' | 'webm' | 'avi';
 export type ParseMediaCallbacks<Fields extends Options<ParseMediaFields>> = (Fields['dimensions'] extends true ? {
     onDimensions?: (dimensions: Dimensions) => void;
 } : {}) & (Fields['durationInSeconds'] extends true ? {
     onDurationInSeconds?: (durationInSeconds: number | null) => void;
-} : {}) & (Fields['boxes'] extends true ? {
-    onBoxes?: (boxes: AnySegment[]) => void;
+} : {}) & (Fields['structure'] extends true ? {
+    onStructure?: (structure: Structure) => void;
 } : {}) & (Fields['fps'] extends true ? {
     onFps?: (fps: number | null) => void;
 } : {}) & (Fields['videoCodec'] extends true ? {
@@ -87,8 +87,8 @@ export type ParseMediaResult<Fields extends Options<ParseMediaFields>> = (Fields
     dimensions: Dimensions;
 } : {}) & (Fields['durationInSeconds'] extends true ? {
     durationInSeconds: number | null;
-} : {}) & (Fields['boxes'] extends true ? {
-    boxes: AnySegment[];
+} : {}) & (Fields['structure'] extends true ? {
+    structure: Structure;
 } : {}) & (Fields['fps'] extends true ? {
     fps: number | null;
 } : {}) & (Fields['videoCodec'] extends true ? {
@@ -111,12 +111,19 @@ export type ParseMediaResult<Fields extends Options<ParseMediaFields>> = (Fields
 export type ParseMediaDynamicOptions<F extends Options<ParseMediaFields>> = {
     fields?: F;
 } & ParseMediaCallbacks<F>;
+export type ParseMediaProgress = {
+    bytes: number;
+    percentage: number | null;
+    totalBytes: number | null;
+};
+export type ParseMediaOnProgress = (progress: ParseMediaProgress) => void | Promise<void>;
 export type ParseMediaOptions<F extends Options<ParseMediaFields>> = {
-    src: string | File;
+    src: string | Blob;
     reader?: ReaderInterface;
     onAudioTrack?: OnAudioTrack;
     onVideoTrack?: OnVideoTrack;
     signal?: AbortSignal;
     logLevel?: LogLevel;
+    onParseProgress?: ParseMediaOnProgress;
 } & ParseMediaDynamicOptions<F>;
 export type ParseMedia = <F extends Options<ParseMediaFields>>(options: ParseMediaOptions<F>) => Promise<ParseMediaResult<F>>;

package/dist/parse-media.js

@@ -4,10 +4,11 @@ exports.parseMedia = void 0;
 const buffer_iterator_1 = require("./buffer-iterator");
 const emit_available_info_1 = require("./emit-available-info");
 const has_all_info_1 = require("./has-all-info");
+const log_1 = require("./log");
 const parse_video_1 = require("./parse-video");
 const parser_state_1 = require("./parser-state");
 const from_fetch_1 = require("./readers/from-fetch");
-const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, logLevel = 'info', ...more }) => {
+const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.fetchReader, onAudioTrack, onVideoTrack, signal, logLevel = 'info', onParseProgress, ...more }) => {
     const state = (0, parser_state_1.makeParserState)({
         hasAudioCallbacks: onAudioTrack !== null,
         hasVideoCallbacks: onVideoTrack !== null,
@@ -23,8 +24,16 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
     const moreFields = more;
     let iterator = null;
     let parseResult = null;
+    // TODO: Should be possible to skip if `null` is returned
+    const canSkipVideoData = !onVideoTrack && !onAudioTrack;
+    if (canSkipVideoData) {
+        log_1.Log.verbose(logLevel, 'Only parsing metadata, because no onVideoTrack and onAudioTrack callbacks were passed.');
+    }
+    else {
+        log_1.Log.verbose(logLevel, 'Parsing video data, because onVideoTrack/onAudioTrack callbacks were passed.');
+    }
     const options = {
-        canSkipVideoData: !(onAudioTrack || onVideoTrack),
+        canSkipVideoData,
         onAudioTrack: onAudioTrack !== null && onAudioTrack !== void 0 ? onAudioTrack : null,
         onVideoTrack: onVideoTrack !== null && onVideoTrack !== void 0 ? onVideoTrack : null,
         parserState: state,
@@ -32,7 +41,28 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
             typeof process.env !== 'undefined' &&
             process.env.KEEP_SAMPLES === 'true'),
         supportsContentRange,
+        nextTrackIndex: 0,
+    };
+    const hasAllInfo = () => {
+        if (parseResult === null) {
+            return false;
+        }
+        const availableInfo = (0, has_all_info_1.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, parseResult, state);
+        return Object.values(availableInfo).every(Boolean);
+    };
+    const triggerInfoEmit = () => {
+        const availableInfo = (0, has_all_info_1.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, parseResult, state);
+        (0, emit_available_info_1.emitAvailableInfo)({
+            hasInfo: availableInfo,
+            moreFields,
+            parseResult,
+            state,
+            returnValue,
+            contentLength,
+            name,
+        });
     };
+    triggerInfoEmit();
     while (parseResult === null || parseResult.status === 'incomplete') {
         if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
             throw new Error('Aborted');
@@ -60,7 +90,16 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
         if (!iterator) {
             throw new Error('Unexpected null');
         }
+        await (onParseProgress === null || onParseProgress === void 0 ? void 0 : onParseProgress({
+            bytes: iterator.counter.getOffset(),
+            percentage: contentLength
+                ? iterator.counter.getOffset() / contentLength
+                : null,
+            totalBytes: contentLength,
+        }));
+        triggerInfoEmit();
         if (parseResult && parseResult.status === 'incomplete') {
+            log_1.Log.verbose(logLevel, 'Continuing parsing of file, currently at position', iterator.counter.getOffset(), (0, has_all_info_1.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, parseResult, state));
             parseResult = await parseResult.continueParsing();
         }
         else {
@@ -71,20 +110,9 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
                 logLevel,
             });
         }
-        const availableInfo = (0, has_all_info_1.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, parseResult, state);
-        const hasAllInfo = Object.values(availableInfo).every(Boolean);
-        (0, emit_available_info_1.emitAvailableInfo)({
-            hasInfo: availableInfo,
-            moreFields,
-            parseResult,
-            state,
-            returnValue,
-            contentLength,
-            name,
-        });
         // TODO Better: Check if no active listeners are registered
         // Also maybe check for canSkipVideoData
-        if (hasAllInfo && !onVideoTrack && !onAudioTrack) {
+        if (hasAllInfo() && !onVideoTrack && !onAudioTrack) {
             break;
         }
         if (parseResult &&
@@ -99,6 +127,7 @@ const parseMedia = async ({ src, fields, reader: readerInterface = from_fetch_1.
             iterator.skipTo(parseResult.skipTo, true);
         }
     }
+    log_1.Log.verbose(logLevel, 'Finished parsing file');
     // Force assign
     (0, emit_available_info_1.emitAvailableInfo)({
         hasInfo: Object.keys(fields !== null && fields !== void 0 ? fields : {}).reduce((acc, key) => {

package/dist/parse-result.d.ts

@@ -25,22 +25,51 @@ import type { TkhdBox } from './boxes/iso-base-media/tkhd';
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import type { TrunBox } from './boxes/iso-base-media/trun';
 import type { VoidBox } from './boxes/iso-base-media/void-box';
+import type { RiffBox } from './boxes/riff/riff-box';
 import type { MatroskaSegment } from './boxes/webm/segments';
 export interface RegularBox extends BaseBox {
     boxType: string;
     boxSize: number;
-    children: AnySegment[];
+    children: IsoBaseMediaBox[];
     offset: number;
     type: 'regular-box';
 }
 export type IsoBaseMediaBox = RegularBox | FtypBox | MvhdBox | TkhdBox | StsdBox | MebxBox | KeysBox | MoovBox | TrakBox | SttsBox | MdhdBox | EsdsBox | MdatBox | StszBox | StcoBox | StscBox | AvccBox | HvccBox | VoidBox | StssBox | PaspBox | CttsBox | Av1CBox | TrunBox | ColorParameterBox | TfdtBox | TfhdBox;
-export type AnySegment = MatroskaSegment | IsoBaseMediaBox;
-export type ParseResult = {
+export type AnySegment = MatroskaSegment | IsoBaseMediaBox | RiffBox;
+export type IsoBaseMediaStructure = {
+    type: 'iso-base-media';
+    boxes: IsoBaseMediaBox[];
+};
+export type RiffStructure = {
+    type: 'riff';
+    boxes: RiffBox[];
+};
+export type MatroskaStructure = {
+    type: 'matroska';
+    boxes: MatroskaSegment[];
+};
+export type Structure = IsoBaseMediaStructure | RiffStructure | MatroskaStructure;
+export type ParseResult<TStructure extends Structure> = {
+    status: 'done';
+    segments: TStructure;
+} | {
+    status: 'incomplete';
+    segments: TStructure;
+    skipTo: number | null;
+    continueParsing: () => Promise<ParseResult<TStructure>>;
+};
+export type MatroskaParseResult = {
     status: 'done';
-    segments: AnySegment[];
 } | {
     status: 'incomplete';
-    segments: AnySegment[];
     skipTo: number | null;
-    continueParsing: () => Promise<ParseResult>;
+    continueParsing: () => Promise<MatroskaParseResult>;
+};
+export type ExpectSegmentParseResult = {
+    status: 'done';
+    segment: MatroskaSegment;
+} | {
+    status: 'incomplete';
+    segment: MatroskaSegment | null;
+    continueParsing: () => Promise<ExpectSegmentParseResult>;
 };

package/dist/parse-video.d.ts

@@ -1,6 +1,6 @@
 import type { BufferIterator } from './buffer-iterator';
-import type { LogLevel } from './log';
-import type { IsoBaseMediaBox, ParseResult } from './parse-result';
+import { type LogLevel } from './log';
+import type { IsoBaseMediaBox, ParseResult, Structure } from './parse-result';
 import type { ParserContext } from './parser-context';
 export type PartialMdatBox = {
     type: 'partial-mdat-box';
@@ -20,4 +20,4 @@ export declare const parseVideo: ({ iterator, options, signal, logLevel, }: {
     options: ParserContext;
     signal: AbortSignal | null;
     logLevel: LogLevel;
-}) => Promise<ParseResult>;
+}) => Promise<ParseResult<Structure>>;

package/dist/parse-video.js

@@ -2,28 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVideo = void 0;
 const process_box_1 = require("./boxes/iso-base-media/process-box");
+const parse_box_1 = require("./boxes/riff/parse-box");
 const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
+const log_1 = require("./log");
 const parseVideo = ({ iterator, options, signal, logLevel, }) => {
     if (iterator.bytesRemaining() === 0) {
-        return Promise.resolve({
-            status: 'incomplete',
-            segments: [],
-            continueParsing: () => {
-                return (0, exports.parseVideo)({
-                    iterator,
-                    options,
-                    signal,
-                    logLevel,
-                });
-            },
-            skipTo: null,
-        });
+        return Promise.reject(new Error('no bytes'));
     }
     if (iterator.isRiff()) {
-        throw new Error('AVI files are not yet supported');
+        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, options }));
     }
     if (iterator.isIsoBaseMedia()) {
-        return (0, process_box_1.parseBoxes)({
+        log_1.Log.verbose(logLevel, 'Detected ISO Base Media container');
+        return (0, process_box_1.parseIsoBaseMediaBoxes)({
             iterator,
             maxBytes: Infinity,
             allowIncompleteBoxes: true,
@@ -35,7 +26,8 @@ const parseVideo = ({ iterator, options, signal, logLevel, }) => {
         });
     }
     if (iterator.isWebm()) {
-        return Promise.resolve((0, parse_webm_header_1.parseWebm)(iterator, options));
+        log_1.Log.verbose(logLevel, 'Detected Matroska container');
+        return (0, parse_webm_header_1.parseWebm)(iterator, options);
     }
     if (iterator.isMp3()) {
         return Promise.reject(new Error('MP3 files are not yet supported'));

package/dist/parser-context.d.ts

@@ -7,4 +7,5 @@ export type ParserContext = {
     parserState: ParserState;
     nullifySamples: boolean;
     supportsContentRange: boolean;
+    nextTrackIndex: number;
 };

package/dist/parser-state.d.ts

@@ -1,13 +1,21 @@
+import type { AvcPPs, AvcProfileInfo } from './boxes/avc/parse-avc';
 import type { OnTrackEntrySegment } from './boxes/webm/segments';
 import type { TrackInfo } from './boxes/webm/segments/track-entry';
 import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from './webcodec-sample-types';
 export type InternalStats = {};
+export type SpsAndPps = {
+    sps: AvcProfileInfo;
+    pps: AvcPPs;
+};
+type AvcProfileInfoCallback = (profile: SpsAndPps) => Promise<void>;
 export declare const makeParserState: ({ hasAudioCallbacks, hasVideoCallbacks, signal, }: {
     hasAudioCallbacks: boolean;
     hasVideoCallbacks: boolean;
     signal: AbortSignal | undefined;
 }) => {
     onTrackEntrySegment: OnTrackEntrySegment;
+    onProfile: (profile: SpsAndPps) => Promise<void>;
+    registerOnAvcProfileCallback: (callback: AvcProfileInfoCallback) => void;
     getTrackInfoByNumber: (id: number) => TrackInfo;
     registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
     setTimestampOffset: (byteOffset: number, timestamp: number) => void;
@@ -18,5 +26,8 @@ export declare const makeParserState: ({ hasAudioCallbacks, hasVideoCallbacks, s
     getInternalStats: () => {};
     getTimescale: () => number;
     setTimescale: (newTimescale: number) => void;
+    getSamplesForTrack: (trackId: number) => number;
+    getAvcProfile: () => SpsAndPps | null;
 };
 export type ParserState = ReturnType<typeof makeParserState>;
+export {};

package/dist/parser-state.js

@@ -59,8 +59,23 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
         }
         return timestampMap.get(byteOffset);
     };
+    const samplesForTrack = {};
+    const profileCallbacks = [];
+    const registerOnAvcProfileCallback = (callback) => {
+        profileCallbacks.push(callback);
+    };
+    let avcProfile = null;
+    const onProfile = async (profile) => {
+        avcProfile = profile;
+        for (const callback of profileCallbacks) {
+            await callback(profile);
+        }
+        profileCallbacks.length = 0;
+    };
     return {
         onTrackEntrySegment,
+        onProfile,
+        registerOnAvcProfileCallback,
         getTrackInfoByNumber: (id) => trackEntries[id],
         registerVideoSampleCallback: async (id, callback) => {
             var _a;
@@ -94,6 +109,10 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 throw new Error('Aborted');
             }
+            if (typeof samplesForTrack[trackId] === 'undefined') {
+                samplesForTrack[trackId] = 0;
+            }
+            samplesForTrack[trackId]++;
             const callback = audioSampleCallbacks[trackId];
             if (callback) {
                 await callback(audioSample);
@@ -111,6 +130,10 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
             if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                 throw new Error('Aborted');
             }
+            if (typeof samplesForTrack[trackId] === 'undefined') {
+                samplesForTrack[trackId] = 0;
+            }
+            samplesForTrack[trackId]++;
             const callback = videoSampleCallbacks[trackId];
             if (callback) {
                 await callback(videoSample);
@@ -127,6 +150,13 @@ const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
         getInternalStats: () => ({}),
         getTimescale,
         setTimescale,
+        getSamplesForTrack: (trackId) => {
+            var _a;
+            return (_a = samplesForTrack[trackId]) !== null && _a !== void 0 ? _a : 0;
+        },
+        getAvcProfile: () => {
+            return avcProfile;
+        },
     };
 };
 exports.makeParserState = makeParserState;

package/dist/readers/from-node.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeReader = void 0;
 const fs_1 = require("fs");
 const promises_1 = require("node:fs/promises");
+const path_1 = require("path");
 const stream_1 = require("stream");
 exports.nodeReader = {
     read: async (src, range, signal) => {
@@ -37,7 +38,7 @@ exports.nodeReader = {
                 },
             },
             contentLength: stats.size,
-            name: src.split('/').pop(),
+            name: src.split(path_1.sep).pop(),
             supportsContentRange: true,
         };
     },

package/dist/readers/reader.d.ts

@@ -8,8 +8,8 @@ type ReadResult = {
     name: string;
     supportsContentRange: boolean;
 };
-type ReadContent = (src: string | File, range: [number, number] | number | null, signal: AbortSignal | undefined) => Promise<ReadResult>;
-type GetLength = (src: string | File) => Promise<number>;
+type ReadContent = (src: string | Blob, range: [number, number] | number | null, signal: AbortSignal | undefined) => Promise<ReadResult>;
+type GetLength = (src: string | Blob) => Promise<number>;
 export type ReaderInterface = {
     read: ReadContent;
     getLength: GetLength;

package/dist/register-track.d.ts

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

package/dist/register-track.js

@@ -0,0 +1,25 @@
+"use strict";
+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 ({ state, options, track, }) => {
+    if (track.type === 'video' && options.onVideoTrack) {
+        const callback = await options.onVideoTrack(track);
+        await state.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    }
+    if (track.type === 'audio' && options.onAudioTrack) {
+        const callback = await options.onAudioTrack(track);
+        await state.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    }
+};
+exports.registerTrack = registerTrack;
+const registerVideoTrackWhenProfileIsAvailable = ({ options, state, track, }) => {
+    state.registerOnAvcProfileCallback(async (profile) => {
+        await (0, exports.registerTrack)({
+            options,
+            state,
+            track: (0, add_avc_profile_to_track_1.addAvcProfileToTrack)(track, profile),
+        });
+    });
+};
+exports.registerVideoTrackWhenProfileIsAvailable = registerVideoTrackWhenProfileIsAvailable;

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "4.0.232";

package/dist/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// Automatically generated on publish
+exports.VERSION = '4.0.232';

package/dist/writers/buffer-implementation/writer.d.ts

@@ -1,2 +1,2 @@
-import type { Writer } from '../writer';
-export declare const createContent: () => Promise<Writer>;
+import type { CreateContent } from '../writer';
+export declare const createContent: CreateContent;

package/dist/writers/buffer-implementation/writer.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createContent = void 0;
-const createContent = () => {
+const createContent = ({ filename, mimeType }) => {
     const buf = new ArrayBuffer(0, {
         // TODO: Educate that the buffer is limited to 2GB
         maxByteLength: 2000000000,
@@ -34,7 +34,7 @@ const createContent = () => {
             const arr = new Uint8Array(buf);
             return Promise.resolve(
             // TODO: Unhardcode MIME type and file name
-            new File([arr.slice()], 'hi', { type: 'video/webm' }));
+            new File([arr.slice()], filename, { type: mimeType }));
         },
         remove() {
             removed = true;

package/dist/writers/web-fs.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canUseWebFsWriter = exports.webFsWriter = void 0;
-const createContent = async () => {
+const createContent = async ({ filename }) => {
     const directoryHandle = await navigator.storage.getDirectory();
-    // TODO: Unhardcode WebM
-    const filename = `media-parser-${Math.random().toString().replace('0.', '')}.webm`;
+    directoryHandle.removeEntry(filename);
     const fileHandle = await directoryHandle.getFileHandle(filename, {
         create: true,
     });

package/dist/writers/writer.d.ts

@@ -1,13 +1,15 @@
 export type Writer = {
     write: (arr: Uint8Array) => Promise<void>;
-    save: () => Promise<File | Blob>;
+    save: () => Promise<Blob>;
     getWrittenByteCount: () => number;
     updateDataAt: (position: number, data: Uint8Array) => Promise<void>;
     waitForFinish: () => Promise<void>;
     remove: () => Promise<void>;
 };
-type CreateContent = () => Promise<Writer>;
+export type CreateContent = (options: {
+    filename: string;
+    mimeType: string;
+}) => Promise<Writer>;
 export type WriterInterface = {
     createContent: CreateContent;
 };
-export {};

package/package.json

@@ -3,14 +3,14 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.230",
+  "version": "4.0.232",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
     "eslint": "9.14.0",
-    "@remotion/example-videos": "4.0.230",
-    "@remotion/eslint-config-internal": "4.0.230"
+    "@remotion/example-videos": "4.0.232",
+    "@remotion/eslint-config-internal": "4.0.232"
   },
   "publishConfig": {
     "access": "public"