@remotion/media-parser 4.0.231 → 4.0.233

package/dist/has-all-info.js

@@ -6,12 +6,14 @@ const get_container_1 = require("./get-container");
 const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
 const get_fps_1 = require("./get-fps");
+const get_is_hdr_1 = require("./get-is-hdr");
 const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
 const getAvailableInfo = (options, parseResult, state) => {
     const keys = Object.entries(options).filter(([, value]) => value);
-    const infos = keys.map(([key]) => {
-        if (key === 'boxes') {
+    const infos = keys.map(([_key]) => {
+        const key = _key;
+        if (key === 'structure') {
             return Boolean(parseResult && parseResult.status === 'done');
         }
         if (key === 'durationInSeconds') {
@@ -25,14 +27,17 @@ const getAvailableInfo = (options, parseResult, state) => {
         if (key === 'fps') {
             return Boolean(parseResult && (0, get_fps_1.hasFps)(parseResult.segments));
         }
+        if (key === 'isHdr') {
+            return Boolean(parseResult && (0, get_is_hdr_1.hasHdr)(parseResult.segments, state));
+        }
         if (key === 'videoCodec') {
-            return Boolean(parseResult && (0, get_video_codec_1.hasVideoCodec)(parseResult.segments));
+            return Boolean(parseResult && (0, get_video_codec_1.hasVideoCodec)(parseResult.segments, state));
         }
         if (key === 'audioCodec') {
-            return Boolean(parseResult && (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments));
+            return Boolean(parseResult && (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments, state));
         }
         if (key === 'tracks') {
-            return Boolean(parseResult && (0, get_tracks_1.hasTracks)(parseResult.segments));
+            return Boolean(parseResult && (0, get_tracks_1.hasTracks)(parseResult.segments, state));
         }
         if (key === 'internalStats') {
             return false;

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { IoEventEmitter } from './create/event-emitter';
+import type { ProgressTracker } from './create/progress-tracker';
 import type { LogLevel } from './log';
 export { WriterInterface } from './writers/writer';
 export { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, OtherTrack, Track, VideoTrack, VideoTrackColorParams, } from './get-tracks';
@@ -7,10 +9,10 @@ export { AudioOrVideoSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideo
 export type { MediaFn } from './create/media-fn';
 export { Dimensions } from './get-dimensions';
 export type { ReaderInterface } from './readers/reader';
-export type { LogLevel };
 export declare const MediaParserInternals: {
-    createMatroskaMedia: ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
-    createIsoBaseMedia: ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
+    createMatroskaMedia: ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, progressTracker, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
+    createIsoBaseMedia: ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, progressTracker, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
+    createWav: ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, progressTracker, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
     Log: {
         trace: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
         verbose: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
@@ -18,5 +20,23 @@ export declare const MediaParserInternals: {
         warn: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
         error: (...args: Parameters<typeof console.log>) => void;
     };
+    IoEventEmitter: typeof IoEventEmitter;
+    makeProgressTracker: () => {
+        registerTrack: (trackNumber: number) => void;
+        getSmallestProgress: () => number;
+        updateTrackProgress: (trackNumber: number, progress: number) => void;
+        waitForProgress: () => Promise<void>;
+    };
+    withResolvers: <T>() => {
+        promise: Promise<T>;
+        resolve: (value: T | PromiseLike<T>) => void;
+        reject: (reason?: any) => void;
+    };
+    withResolversAndWaitForReturn: <T>() => {
+        getPromiseToImmediatelyReturn: () => Promise<T>;
+        reject: (reason: unknown) => void;
+        resolve: (value: T | PromiseLike<T>) => void;
+    };
 };
+export type { IoEventEmitter, LogLevel, ProgressTracker };
 export { VERSION } from './version';

package/dist/index.js

@@ -1,15 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = exports.MediaParserInternals = exports.parseMedia = void 0;
+const event_emitter_1 = require("./create/event-emitter");
 const create_iso_base_media_1 = require("./create/iso-base-media/create-iso-base-media");
 const create_matroska_media_1 = require("./create/matroska/create-matroska-media");
+const progress_tracker_1 = require("./create/progress-tracker");
+const create_wav_1 = require("./create/wav/create-wav");
+const with_resolvers_1 = require("./create/with-resolvers");
 const log_1 = require("./log");
 var parse_media_1 = require("./parse-media");
 Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });
 exports.MediaParserInternals = {
     createMatroskaMedia: create_matroska_media_1.createMatroskaMedia,
     createIsoBaseMedia: create_iso_base_media_1.createIsoBaseMedia,
+    createWav: create_wav_1.createWav,
     Log: log_1.Log,
+    IoEventEmitter: event_emitter_1.IoEventEmitter,
+    makeProgressTracker: progress_tracker_1.makeProgressTracker,
+    withResolvers: with_resolvers_1.withResolvers,
+    withResolversAndWaitForReturn: with_resolvers_1.withResolversAndWaitForReturn,
 };
 var version_1 = require("./version");
 Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });

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;
@@ -20,11 +20,12 @@ export type ParseMediaFields = {
     size: boolean;
     name: boolean;
     container: boolean;
+    isHdr: boolean;
 };
 export type AllParseMediaFields = {
     dimensions: true;
     durationInSeconds: true;
-    boxes: true;
+    structure: true;
     fps: true;
     videoCodec: true;
     audioCodec: true;
@@ -35,11 +36,12 @@ export type AllParseMediaFields = {
     size: true;
     name: true;
     container: true;
+    isHdr: true;
 };
 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'];
@@ -50,18 +52,19 @@ export type Options<Fields extends ParseMediaFields> = {
     size?: Fields['size'];
     name?: Fields['name'];
     container?: Fields['container'];
+    isHdr?: Fields['isHdr'];
 };
 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 ? {
@@ -74,6 +77,8 @@ export type ParseMediaCallbacks<Fields extends Options<ParseMediaFields>> = (Fie
     onRotation?: (rotation: number | null) => void;
 } : {}) & (Fields['unrotatedDimensions'] extends true ? {
     onUnrotatedDimensions?: (dimensions: Dimensions) => void;
+} : {}) & (Fields['isHdr'] extends true ? {
+    onIsHdr?: (isHdr: boolean) => void;
 } : {}) & (Fields['internalStats'] extends true ? {
     onInternalStats?: (stats: InternalStats) => void;
 } : {}) & (Fields['size'] extends true ? {
@@ -87,8 +92,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 ? {
@@ -99,6 +104,8 @@ export type ParseMediaResult<Fields extends Options<ParseMediaFields>> = (Fields
     rotation: number | null;
 } : {}) & (Fields['unrotatedDimensions'] extends true ? {
     unrotatedDimensions: Dimensions;
+} : {}) & (Fields['isHdr'] extends true ? {
+    isHdr: boolean;
 } : {}) & (Fields['internalStats'] extends true ? {
     internalStats: InternalStats;
 } : {}) & (Fields['size'] extends true ? {

package/dist/parse-media.js

@@ -24,6 +24,7 @@ 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.');
@@ -40,6 +41,7 @@ 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) {
@@ -97,7 +99,7 @@ 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(), (0, has_all_info_1.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, parseResult, state));
+            log_1.Log.verbose(logLevel, 'Continuing parsing of file, currently at position', iterator.counter.getOffset());
             parseResult = await parseResult.continueParsing();
         }
         else {

package/dist/parse-result.d.ts

@@ -25,24 +25,38 @@ 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: AnySegment[];
+    segments: TStructure;
 } | {
     status: 'incomplete';
-    segments: AnySegment[];
+    segments: TStructure;
     skipTo: number | null;
-    continueParsing: () => Promise<ParseResult>;
+    continueParsing: () => Promise<ParseResult<TStructure>>;
 };
 export type MatroskaParseResult = {
     status: 'done';

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 { 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,30 +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()) {
         log_1.Log.verbose(logLevel, 'Detected ISO Base Media container');
-        return (0, process_box_1.parseBoxes)({
+        return (0, process_box_1.parseIsoBaseMediaBoxes)({
             iterator,
             maxBytes: Infinity,
             allowIncompleteBoxes: true,
@@ -38,7 +27,7 @@ const parseVideo = ({ iterator, options, signal, logLevel, }) => {
     }
     if (iterator.isWebm()) {
         log_1.Log.verbose(logLevel, 'Detected Matroska container');
-        return Promise.resolve((0, parse_webm_header_1.parseWebm)(iterator, options));
+        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/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

@@ -1 +1 @@
-export declare const VERSION = "4.0.231";
+export declare const VERSION = "4.0.233";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Automatically generated on publish
-exports.VERSION = '4.0.231';
+exports.VERSION = '4.0.233';

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.231",
+  "version": "4.0.233",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
     "eslint": "9.14.0",
-    "@remotion/example-videos": "4.0.231",
-    "@remotion/eslint-config-internal": "4.0.231"
+    "@remotion/example-videos": "4.0.233",
+    "@remotion/eslint-config-internal": "4.0.233"
   },
   "publishConfig": {
     "access": "public"