@remotion/media-parser 4.0.249 → 4.0.250

package/dist/readers/from-node.js

@@ -2,11 +2,10 @@
 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) => {
+    read: (src, range, signal) => {
         if (typeof src !== 'string') {
             throw new Error('src must be a string when using `nodeReader`');
         }
@@ -23,14 +22,14 @@ exports.nodeReader = {
         signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', () => {
             controller.abort();
         }, { once: true });
-        const stats = await (0, promises_1.stat)(src);
+        const stats = (0, fs_1.statSync)(src);
         const reader = stream_1.Readable.toWeb(stream).getReader();
         if (signal) {
             signal.addEventListener('abort', () => {
                 reader.cancel().catch(() => { });
             }, { once: true });
         }
-        return {
+        return Promise.resolve({
             reader: {
                 reader,
                 abort: () => {
@@ -41,13 +40,13 @@ exports.nodeReader = {
             contentType: null,
             name: src.split(path_1.sep).pop(),
             supportsContentRange: true,
-        };
+        });
     },
-    getLength: async (src) => {
+    getLength: (src) => {
         if (typeof src !== 'string') {
             throw new Error('src must be a string when using `nodeReader`');
         }
-        const stats = await (0, promises_1.stat)(src);
-        return stats.size;
+        const stats = (0, fs_1.statSync)(src);
+        return Promise.resolve(stats.size);
     },
 };

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

@@ -1,8 +1,15 @@
 import type { Options, ParseMediaFields } from '../options';
-export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, }: {
+import type { Structure } from '../parse-result';
+import type { StructureState } from './structure';
+export declare const needsTracksForField: ({ field, structure, }: {
+    field: keyof Options<ParseMediaFields>;
+    structure: Structure;
+}) => boolean;
+export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     fields: Options<ParseMediaFields>;
+    structure: StructureState;
 }) => {
     canSkipTracks: () => boolean;
 };

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

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

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

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

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachedSamplePositionsState = exports.calculateFlatSamples = void 0;
+const get_sample_positions_from_track_1 = require("../../boxes/iso-base-media/get-sample-positions-from-track");
+const traversal_1 = require("../../boxes/iso-base-media/traversal");
+const get_tracks_1 = require("../../get-tracks");
+const calculateFlatSamples = (state) => {
+    const tracks = (0, get_tracks_1.getTracks)(state);
+    const allTracks = [
+        ...tracks.videoTracks,
+        ...tracks.audioTracks,
+        ...tracks.otherTracks,
+    ];
+    const flatSamples = allTracks
+        .map((track) => {
+        const samplePositions = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)(track.trakBox, (0, traversal_1.getMoofBox)(state.structure.getStructure().boxes));
+        if (!samplePositions) {
+            throw new Error('No sample positions');
+        }
+        return samplePositions.map((samplePosition) => {
+            return {
+                track,
+                samplePosition,
+            };
+        });
+    })
+        .flat(1);
+    return flatSamples;
+};
+exports.calculateFlatSamples = calculateFlatSamples;
+const cachedSamplePositionsState = () => {
+    let cached = null;
+    return {
+        getSamples: () => {
+            return cached;
+        },
+        setSamples: (samples) => {
+            cached = samples;
+        },
+    };
+};
+exports.cachedSamplePositionsState = cachedSamplePositionsState;

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

@@ -0,0 +1,8 @@
+export declare const isoBaseMediaState: () => {
+    getShouldReturnToVideoSectionAfterEnd: () => boolean;
+    setShouldReturnToVideoSectionAfterEnd: (value: boolean) => void;
+    flatSamples: {
+        getSamples: () => import("./cached-sample-positions").FlatSample[] | null;
+        setSamples: (samples: import("./cached-sample-positions").FlatSample[]) => void;
+    };
+};

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isoBaseMediaState = void 0;
+const cached_sample_positions_1 = require("./cached-sample-positions");
+const isoBaseMediaState = () => {
+    let shouldReturnToVideoSectionAfterEnd = false;
+    return {
+        getShouldReturnToVideoSectionAfterEnd: () => shouldReturnToVideoSectionAfterEnd,
+        setShouldReturnToVideoSectionAfterEnd: (value) => {
+            shouldReturnToVideoSectionAfterEnd = value;
+        },
+        flatSamples: (0, cached_sample_positions_1.cachedSamplePositionsState)(),
+    };
+};
+exports.isoBaseMediaState = isoBaseMediaState;

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

@@ -0,0 +1,4 @@
+export declare const isoBaseMediaState: () => {
+    getShouldReturnToVideoSectionAfterEnd: () => boolean;
+    setShouldReturnToVideoSectionAfterEnd: (value: boolean) => void;
+};

package/dist/state/iso-state.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isoBaseMediaState = void 0;
+const isoBaseMediaState = () => {
+    let shouldReturnToVideoSectionAfterEnd = false;
+    return {
+        getShouldReturnToVideoSectionAfterEnd: () => shouldReturnToVideoSectionAfterEnd,
+        setShouldReturnToVideoSectionAfterEnd: (value) => {
+            shouldReturnToVideoSectionAfterEnd = value;
+        },
+    };
+};
+exports.isoBaseMediaState = isoBaseMediaState;

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 { LogLevel } from '../log';
 import type { Options, ParseMediaFields } from '../options';
 import type { OnAudioTrack, OnVideoTrack } from '../webcodec-sample-types';
 export type InternalStats = {
@@ -10,7 +11,7 @@ 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, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     signal: AbortSignal | undefined;
@@ -20,6 +21,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;
     contentLength: number | null;
+    logLevel: LogLevel;
 }) => {
     riff: {
         getAvcProfile: () => SpsAndPps | null;
@@ -28,6 +30,38 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         getNextTrackIndex: () => number;
         incrementNextTrackIndex: () => void;
     };
+    transportStream: {
+        nextPesHeaderStore: {
+            setNextPesHeader: (pesHeader: import("../boxes/transport-stream/parse-pes").PacketPes) => void;
+            getNextPesHeader: () => import("../boxes/transport-stream/parse-pes").PacketPes;
+        };
+        streamBuffers: Map<number, import("../boxes/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
+    };
+    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;
+        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;
+    };
     callbacks: {
         registerVideoSampleCallback: (id: number, callback: import("../webcodec-sample-types").OnVideoSample | null) => Promise<void>;
         onAudioSample: (trackId: number, audioSample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;
@@ -46,6 +80,8 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         };
         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 +98,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: {
@@ -80,14 +107,22 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         getFps: () => number;
         getSlowNumberOfFrames: () => number;
     };
-    mp3Info: {
-        getMp3Info: () => import("./mp3").Mp3Info | null;
-        setMp3Info: (info: import("./mp3").Mp3Info) => void;
-    };
     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";
 };
 export type ParserState = ReturnType<typeof makeParserState>;

package/dist/state/parser-state.js

@@ -3,14 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeParserState = void 0;
 const emitted_fields_1 = require("./emitted-fields");
 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, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }) => {
     let skippedBytes = 0;
     const increaseSkippedBytes = (bytes) => {
         skippedBytes += bytes;
@@ -23,6 +26,10 @@ 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,
         callbacks: (0, sample_callbacks_1.sampleCallback)({
             signal,
             hasAudioTrackHandlers,
@@ -31,6 +38,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal,
             keyframes,
             emittedFields,
             slowDurationAndFpsState: slowDurationAndFps,
+            structure,
         }),
         getInternalStats: () => {
             var _a, _b;
@@ -46,13 +54,13 @@ 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,
     };
 };
 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>;
@@ -28,4 +30,6 @@ export declare const sampleCallback: ({ signal, hasAudioTrackHandlers, hasVideoT
     };
     audioSampleCallbacks: Record<number, OnAudioSample>;
     videoSampleCallbacks: Record<number, OnVideoSample>;
+    hasAudioTrackHandlers: boolean;
+    hasVideoTrackHandlers: boolean;
 };

package/dist/state/sample-callbacks.js

@@ -4,7 +4,7 @@ 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 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/transport-stream.d.ts

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

@@ -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.250";

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.250';

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.250",
   "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/eslint-config-internal": "4.0.250",
+    "@remotion/example-videos": "4.0.250"
   },
   "publishConfig": {
     "access": "public"