@remotion/media-parser 4.0.249 → 4.0.251

package/dist/state/parser-state.d.ts

@@ -1,5 +1,6 @@
-import type { AvcPPs, AvcProfileInfo } from '../boxes/avc/parse-avc';
 import type { BufferIterator } from '../buffer-iterator';
+import type { AvcPPs, AvcProfileInfo } from '../containers/avc/parse-avc';
+import type { LogLevel } from '../log';
 import type { Options, ParseMediaFields } from '../options';
 import type { OnAudioTrack, OnVideoTrack } from '../webcodec-sample-types';
 export type InternalStats = {
@@ -10,16 +11,17 @@ export type SpsAndPps = {
     sps: AvcProfileInfo;
     pps: AvcPPs;
 };
-export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, }: {
+export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, iterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     signal: AbortSignal | undefined;
-    getIterator: () => BufferIterator | null;
+    iterator: BufferIterator;
     fields: Options<ParseMediaFields>;
     supportsContentRange: boolean;
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;
     contentLength: number | null;
+    logLevel: LogLevel;
 }) => {
     riff: {
         getAvcProfile: () => SpsAndPps | null;
@@ -28,6 +30,57 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         getNextTrackIndex: () => number;
         incrementNextTrackIndex: () => void;
     };
+    transportStream: {
+        nextPesHeaderStore: {
+            setNextPesHeader: (pesHeader: import("../containers/transport-stream/parse-pes").PacketPes) => void;
+            getNextPesHeader: () => import("../containers/transport-stream/parse-pes").PacketPes;
+        };
+        streamBuffers: Map<number, import("../containers/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
+    };
+    webm: {
+        onTrackEntrySegment: import("../containers/webm/segments").OnTrackEntrySegment;
+        getTrackInfoByNumber: (id: number) => import("../containers/webm/segments/track-entry").TrackInfo;
+        setTimestampOffset: (byteOffset: number, timestamp: number) => void;
+        getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
+        timescale: null;
+        getTimescale: () => number;
+        setTimescale: (newTimescale: number) => void;
+        addSegment: (seg: Omit<import("./webm").SegmentSection, "index">) => void;
+        addCluster: (cluster: import("./webm").ClusterSection) => void;
+        isInsideSegment: (iterator: BufferIterator) => import("./webm").SegmentSection | null;
+        isInsideCluster: (iterator: BufferIterator) => import("./webm").ClusterSection | null;
+    };
+    iso: {
+        getShouldReturnToVideoSectionAfterEnd: () => boolean;
+        setShouldReturnToVideoSectionAfterEnd: (value: boolean) => void;
+        flatSamples: {
+            getSamples: () => import("./iso-base-media/cached-sample-positions").FlatSample[] | null;
+            setSamples: (samples: import("./iso-base-media/cached-sample-positions").FlatSample[]) => void;
+        };
+    };
+    mp3Info: {
+        getMp3Info: () => import("./mp3").Mp3Info | null;
+        setMp3Info: (info: import("./mp3").Mp3Info) => void;
+    };
+    aac: {
+        addSample: ({ offset, size }: {
+            offset: number;
+            size: number;
+        }) => {
+            offset: number;
+            index: number;
+            size: number;
+        };
+        getSamples: () => {
+            offset: number;
+            index: number;
+            size: number;
+        }[];
+    };
+    flac: {
+        setBlockingBitStrategy: (strategy: number) => void;
+        getBlockingBitStrategy: () => number | undefined;
+    };
     callbacks: {
         registerVideoSampleCallback: (id: number, callback: import("../webcodec-sample-types").OnVideoSample | null) => Promise<void>;
         onAudioSample: (trackId: number, audioSample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
@@ -42,10 +95,12 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
             setIsDone: () => void;
             addTrack: (track: import("..").Track) => void;
             getTracks: () => import("..").Track[];
-            ensureHasTracksAtEnd: () => void;
+            ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;
         };
         audioSampleCallbacks: Record<number, import("../webcodec-sample-types").OnAudioSample>;
         videoSampleCallbacks: Record<number, import("../webcodec-sample-types").OnVideoSample>;
+        hasAudioTrackHandlers: boolean;
+        hasVideoTrackHandlers: boolean;
     };
     getInternalStats: () => InternalStats;
     getSkipBytes: () => number;
@@ -62,15 +117,6 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;
     supportsContentRange: boolean;
-    webm: {
-        onTrackEntrySegment: import("../boxes/webm/segments").OnTrackEntrySegment;
-        getTrackInfoByNumber: (id: number) => import("../boxes/webm/segments/track-entry").TrackInfo;
-        setTimestampOffset: (byteOffset: number, timestamp: number) => void;
-        getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
-        timescale: null;
-        getTimescale: () => number;
-        setTimescale: (newTimescale: number) => void;
-    };
     emittedFields: import("../options").AllOptions<ParseMediaFields>;
     fields: Partial<import("../options").AllOptions<ParseMediaFields>>;
     slowDurationAndFps: {
@@ -79,15 +125,83 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         getSlowDurationInSeconds: () => number;
         getFps: () => number;
         getSlowNumberOfFrames: () => number;
-    };
-    mp3Info: {
-        getMp3Info: () => import("./mp3").Mp3Info | null;
-        setMp3Info: (info: import("./mp3").Mp3Info) => void;
+        getAudioBitrate: () => number | null;
+        getVideoBitrate: () => number | null;
     };
     contentLength: number | null;
     images: {
         images: import("./images").MediaParserEmbeddedImage[];
         addImage: (image: import("./images").MediaParserEmbeddedImage) => void;
     };
+    videoSection: {
+        setVideoSection: (section: {
+            start: number;
+            size: number;
+        }) => void;
+        getVideoSection: () => {
+            start: number;
+            size: number;
+        };
+        isInVideoSectionState: (iterator: BufferIterator) => "no-section-defined" | "in-section" | "outside-section";
+    };
+    logLevel: "trace" | "verbose" | "info" | "warn" | "error";
+    iterator: {
+        startReadingBits: () => void;
+        stopReadingBits: () => void;
+        skipTo: (offset: number) => void;
+        addData: (newData: Uint8Array) => void;
+        counter: import("../buffer-iterator").OffsetCounter;
+        peekB: (length: number) => void;
+        peekD: (length: number) => void;
+        getBits: (bits: number) => number;
+        bytesRemaining: () => number;
+        leb128: () => number;
+        removeBytesRead: (force: boolean) => number | undefined;
+        discard: (length: number) => void;
+        getEightByteNumber: (littleEndian?: boolean) => number;
+        getFourByteNumber: () => number;
+        getSlice: (amount: number) => Uint8Array;
+        getAtom: () => string;
+        detectFileType: () => import("../file-types/detect-file-type").FileType;
+        getPaddedFourByteNumber: () => number;
+        getMatroskaSegmentId: () => string | null;
+        getVint: () => number | null;
+        getUint8: () => number;
+        getEBML: () => number;
+        getInt8: () => number;
+        getUint16: () => number;
+        getUint16Le: () => number;
+        getUint24: () => number;
+        getInt24: () => number;
+        getInt16: () => number;
+        getUint32: () => number;
+        getUint64: (littleEndian?: boolean) => bigint;
+        getInt64: (littleEndian?: boolean) => bigint;
+        getFixedPointUnsigned1616Number: () => number;
+        getFixedPointSigned1616Number: () => number;
+        getFixedPointSigned230Number: () => number;
+        getPascalString: () => number[];
+        getUint(length: number): number;
+        getByteString(length: number, trimTrailingZeroes: boolean): string;
+        planBytes: (size: number) => {
+            discardRest: () => Uint8Array;
+        };
+        getFloat64: () => number;
+        readUntilNullTerminator: () => string;
+        getFloat32: () => number;
+        getUint32Le: () => number;
+        getInt32Le: () => number;
+        getInt32: () => number;
+        destroy: () => void;
+        startBox: (size: number) => {
+            discardRest: () => void;
+            expectNoMoreBytes: () => void;
+        };
+        readExpGolomb: () => number;
+        startCheckpoint: () => {
+            returnToCheckpoint: () => void;
+        };
+        getFlacCodecNumber: () => number;
+    };
 };
 export type ParserState = ReturnType<typeof makeParserState>;

package/dist/state/parser-state.js

@@ -1,16 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeParserState = void 0;
+const aac_state_1 = require("./aac-state");
 const emitted_fields_1 = require("./emitted-fields");
+const flac_state_1 = require("./flac-state");
 const images_1 = require("./images");
+const iso_state_1 = require("./iso-base-media/iso-state");
 const keyframes_1 = require("./keyframes");
 const mp3_1 = require("./mp3");
 const riff_1 = require("./riff");
 const sample_callbacks_1 = require("./sample-callbacks");
 const slow_duration_fps_1 = require("./slow-duration-fps");
 const structure_1 = require("./structure");
+const transport_stream_1 = require("./transport-stream");
+const video_section_1 = require("./video-section");
 const webm_1 = require("./webm");
-const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, }) => {
+const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, iterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }) => {
     let skippedBytes = 0;
     const increaseSkippedBytes = (bytes) => {
         skippedBytes += bytes;
@@ -23,6 +28,12 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
     const images = (0, images_1.imagesState)();
     return {
         riff: (0, riff_1.riffSpecificState)(),
+        transportStream: (0, transport_stream_1.transportStreamState)(),
+        webm: (0, webm_1.webmState)(),
+        iso: (0, iso_state_1.isoBaseMediaState)(),
+        mp3Info,
+        aac: (0, aac_state_1.aacState)(),
+        flac: (0, flac_state_1.flacState)(),
         callbacks: (0, sample_callbacks_1.sampleCallback)({
             signal,
             hasAudioTrackHandlers,
@@ -31,12 +42,13 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
             keyframes,
             emittedFields,
             slowDurationAndFpsState: slowDurationAndFps,
+            structure,
         }),
         getInternalStats: () => {
-            var _a, _b;
+            var _a;
             return ({
                 skippedBytes,
-                finalCursorOffset: (_b = (_a = getIterator()) === null || _a === void 0 ? void 0 : _a.counter.getOffset()) !== null && _b !== void 0 ? _b : 0,
+                finalCursorOffset: (_a = iterator.counter.getOffset()) !== null && _a !== void 0 ? _a : 0,
             });
         },
         getSkipBytes: () => skippedBytes,
@@ -46,13 +58,14 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
         onAudioTrack,
         onVideoTrack,
         supportsContentRange,
-        webm: (0, webm_1.webmState)(),
         emittedFields,
         fields,
         slowDurationAndFps,
-        mp3Info,
         contentLength,
         images,
+        videoSection: (0, video_section_1.videoSectionState)(),
+        logLevel,
+        iterator,
     };
 };
 exports.makeParserState = makeParserState;

package/dist/state/sample-callbacks.d.ts

@@ -2,7 +2,8 @@ import type { AllOptions, Options, ParseMediaFields } from '../options';
 import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
 import { type KeyframesState } from './keyframes';
 import type { SlowDurationAndFpsState } from './slow-duration-fps';
-export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, }: {
+import type { StructureState } from './structure';
+export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, }: {
     signal: AbortSignal | undefined;
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
@@ -10,6 +11,7 @@ export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoT
     keyframes: KeyframesState;
     emittedFields: AllOptions<ParseMediaFields>;
     slowDurationAndFpsState: SlowDurationAndFpsState;
+    structure: StructureState;
 }) => {
     registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
     onAudioSample: (trackId: number, audioSample: AudioOrVideoSample) => Promise<void>;
@@ -24,8 +26,10 @@ export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoT
         setIsDone: () => void;
         addTrack: (track: import("..").Track) => void;
         getTracks: () => import("..").Track[];
-        ensureHasTracksAtEnd: () => void;
+        ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;
     };
     audioSampleCallbacks: Record<number, OnAudioSample>;
     videoSampleCallbacks: Record<number, OnVideoSample>;
+    hasAudioTrackHandlers: boolean;
+    hasVideoTrackHandlers: boolean;
 };

package/dist/state/sample-callbacks.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sampleCallback = void 0;
-const need_samples_for_fields_1 = require("../may-skip-video-data/need-samples-for-fields");
 const can_skip_tracks_1 = require("./can-skip-tracks");
 const has_tracks_section_1 = require("./has-tracks-section");
-const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, }) => {
+const need_samples_for_fields_1 = require("./need-samples-for-fields");
+const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, }) => {
     const videoSampleCallbacks = {};
     const audioSampleCallbacks = {};
     const queuedAudioSamples = {};
@@ -13,6 +13,7 @@ const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers,
         hasAudioTrackHandlers,
         fields,
         hasVideoTrackHandlers,
+        structure,
     });
     const tracksState = (0, has_tracks_section_1.makeTracksSectionState)(canSkipTracksState);
     const samplesForTrack = {};
@@ -99,6 +100,8 @@ const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers,
         tracks: tracksState,
         audioSampleCallbacks,
         videoSampleCallbacks,
+        hasAudioTrackHandlers,
+        hasVideoTrackHandlers,
     };
 };
 exports.sampleCallback = sampleCallback;

package/dist/state/slow-duration-fps.d.ts

@@ -5,5 +5,7 @@ export declare const slowDurationAndFpsState: () => {
     getSlowDurationInSeconds: () => number;
     getFps: () => number;
     getSlowNumberOfFrames: () => number;
+    getAudioBitrate: () => number | null;
+    getVideoBitrate: () => number | null;
 };
 export type SlowDurationAndFpsState = ReturnType<typeof slowDurationAndFpsState>;

package/dist/state/slow-duration-fps.js

@@ -6,6 +6,8 @@ const slowDurationAndFpsState = () => {
     let largestVideoSample;
     let smallestAudioSample;
     let largestAudioSample;
+    let audioSizesInBytes = 0;
+    let videoSizeInBytes = 0;
     let videoSamples = 0;
     let audioSamples = 0;
     const getSlowVideoDurationInSeconds = () => {
@@ -42,6 +44,7 @@ const slowDurationAndFpsState = () => {
                 presentationTimeInSeconds < smallestVideoSample) {
                 smallestVideoSample = presentationTimeInSeconds;
             }
+            videoSizeInBytes += videoSample.data.byteLength;
         },
         addAudioSample: (audioSample) => {
             audioSamples++;
@@ -54,6 +57,7 @@ const slowDurationAndFpsState = () => {
                 presentationTimeInSeconds < smallestAudioSample) {
                 smallestAudioSample = presentationTimeInSeconds;
             }
+            audioSizesInBytes += audioSample.data.byteLength;
         },
         getSlowDurationInSeconds,
         getFps: () => {
@@ -65,6 +69,20 @@ const slowDurationAndFpsState = () => {
             return videoSamples / videoDuration;
         },
         getSlowNumberOfFrames: () => videoSamples,
+        getAudioBitrate: () => {
+            const audioDuration = getSlowDurationInSeconds();
+            if (audioDuration === 0 || audioSizesInBytes === 0) {
+                return null;
+            }
+            return (audioSizesInBytes * 8) / audioDuration;
+        },
+        getVideoBitrate: () => {
+            const videoDuration = getSlowDurationInSeconds();
+            if (videoDuration === 0 || videoSizeInBytes === 0) {
+                return null;
+            }
+            return (videoSizeInBytes * 8) / videoDuration;
+        },
     };
 };
 exports.slowDurationAndFpsState = slowDurationAndFpsState;

package/dist/state/transport-stream.d.ts

@@ -0,0 +1,8 @@
+import type { TransportStreamPacketBuffer } from '../containers/transport-stream/process-stream-buffers';
+export declare const transportStreamState: () => {
+    nextPesHeaderStore: {
+        setNextPesHeader: (pesHeader: import("../containers/transport-stream/parse-pes").PacketPes) => void;
+        getNextPesHeader: () => import("../containers/transport-stream/parse-pes").PacketPes;
+    };
+    streamBuffers: Map<number, TransportStreamPacketBuffer>;
+};

package/dist/state/transport-stream.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transportStreamState = void 0;
+const next_pes_header_store_1 = require("../containers/transport-stream/next-pes-header-store");
+const transportStreamState = () => {
+    return {
+        nextPesHeaderStore: (0, next_pes_header_store_1.makeNextPesHeaderStore)(),
+        streamBuffers: new Map(),
+    };
+};
+exports.transportStreamState = transportStreamState;

package/dist/state/video-section.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Keeps track of in which section of the file the video is playing
+ * Usually this section is in a different format and it is the only section
+ * that can be read partially
+ */
+import type { BufferIterator } from '../buffer-iterator';
+type VideoSection = {
+    start: number;
+    size: number;
+};
+export declare const videoSectionState: () => {
+    setVideoSection: (section: VideoSection) => void;
+    getVideoSection: () => VideoSection;
+    isInVideoSectionState: (iterator: BufferIterator) => "no-section-defined" | "in-section" | "outside-section";
+};
+export {};

package/dist/state/video-section.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Keeps track of in which section of the file the video is playing
+ * Usually this section is in a different format and it is the only section
+ * that can be read partially
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.videoSectionState = void 0;
+const videoSectionState = () => {
+    let videoSection = null;
+    const setVideoSection = (section) => {
+        videoSection = section;
+    };
+    const getVideoSection = () => {
+        if (!videoSection) {
+            throw new Error('No video section defined');
+        }
+        return videoSection;
+    };
+    const isInVideoSectionState = (iterator) => {
+        if (!videoSection) {
+            return 'no-section-defined';
+        }
+        const offset = iterator.counter.getOffset();
+        if (offset >= videoSection.start &&
+            offset < videoSection.start + videoSection.size) {
+            return 'in-section';
+        }
+        return 'outside-section';
+    };
+    return {
+        setVideoSection,
+        getVideoSection,
+        isInVideoSectionState,
+    };
+};
+exports.videoSectionState = videoSectionState;

package/dist/state/webm.d.ts

@@ -1,5 +1,16 @@
-import type { OnTrackEntrySegment } from '../boxes/webm/segments';
-import type { TrackInfo } from '../boxes/webm/segments/track-entry';
+import type { BufferIterator } from '../buffer-iterator';
+import type { OnTrackEntrySegment } from '../containers/webm/segments';
+import type { TrackInfo } from '../containers/webm/segments/track-entry';
+export type SegmentSection = {
+    start: number;
+    size: number;
+    index: number;
+};
+export type ClusterSection = {
+    start: number;
+    size: number;
+    segment: number;
+};
 export declare const webmState: () => {
     onTrackEntrySegment: OnTrackEntrySegment;
     getTrackInfoByNumber: (id: number) => TrackInfo;
@@ -8,4 +19,8 @@ export declare const webmState: () => {
     timescale: null;
     getTimescale: () => number;
     setTimescale: (newTimescale: number) => void;
+    addSegment: (seg: Omit<SegmentSection, "index">) => void;
+    addCluster: (cluster: ClusterSection) => void;
+    isInsideSegment: (iterator: BufferIterator) => SegmentSection | null;
+    isInsideCluster: (iterator: BufferIterator) => ClusterSection | null;
 };

package/dist/state/webm.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webmState = void 0;
-const traversal_1 = require("../boxes/webm/traversal");
+const traversal_1 = require("../containers/webm/traversal");
 const webmState = () => {
     const trackEntries = {};
     const onTrackEntrySegment = (trackEntry) => {
@@ -54,6 +54,8 @@ const webmState = () => {
         }
         return timescale;
     };
+    const segments = [];
+    const clusters = [];
     return {
         onTrackEntrySegment,
         getTrackInfoByNumber: (id) => trackEntries[id],
@@ -62,6 +64,36 @@ const webmState = () => {
         timescale,
         getTimescale,
         setTimescale,
+        addSegment: (seg) => {
+            const segment = {
+                ...seg,
+                index: segments.length,
+            };
+            segments.push(segment);
+        },
+        addCluster: (cluster) => {
+            clusters.push(cluster);
+        },
+        isInsideSegment: (iterator) => {
+            var _a;
+            const offset = iterator.counter.getOffset();
+            const insideClusters = segments.filter((cluster) => {
+                return (offset >= cluster.start && offset <= cluster.start + cluster.size);
+            });
+            if (insideClusters.length > 1) {
+                throw new Error('Expected to only be inside 1 cluster');
+            }
+            return (_a = insideClusters[0]) !== null && _a !== void 0 ? _a : null;
+        },
+        isInsideCluster: (iterator) => {
+            for (const cluster of clusters) {
+                const offset = iterator.counter.getOffset();
+                if (offset >= cluster.start && offset <= cluster.start + cluster.size) {
+                    return cluster;
+                }
+            }
+            return null;
+        },
     };
 };
 exports.webmState = webmState;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.249";
+export declare const VERSION = "4.0.251";

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.249';
+exports.VERSION = '4.0.251';

package/dist/webcodec-sample-types.d.ts

@@ -1,14 +1,14 @@
 import type { AudioTrack, VideoTrack } from './get-tracks';
-import type { ParseMediaContainer } from './options';
+import type { MediaParserContainer } from './options';
 export type OnAudioSample = (sample: AudioOrVideoSample) => void | Promise<void>;
 export type OnVideoSample = (sample: AudioOrVideoSample) => void | Promise<void>;
 export type OnAudioTrack = (options: {
     track: AudioTrack;
-    container: ParseMediaContainer;
+    container: MediaParserContainer;
 }) => OnAudioSample | Promise<OnAudioSample | null> | null;
 export type OnVideoTrack = (options: {
     track: VideoTrack;
-    container: ParseMediaContainer;
+    container: MediaParserContainer;
 }) => OnVideoSample | Promise<OnVideoSample | null> | null;
 export type AudioOrVideoSample = {
     data: Uint8Array;

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