@remotion/media-parser 4.0.249 → 4.0.251

package/dist/get-tracks.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTracks = exports.getTracksFromIsoBaseMedia = exports.getHasTracks = exports.isoBaseMediaHasTracks = exports.getNumberOfTracks = void 0;
-const make_track_1 = require("./boxes/iso-base-media/make-track");
-const traversal_1 = require("./boxes/iso-base-media/traversal");
-const get_tracks_from_mp3_1 = require("./boxes/mp3/get-tracks-from-mp3");
-const get_tracks_from_avi_1 = require("./boxes/riff/get-tracks-from-avi");
-const get_tracks_1 = require("./boxes/transport-stream/get-tracks");
-const get_ready_tracks_1 = require("./boxes/webm/get-ready-tracks");
-const traversal_2 = require("./boxes/webm/traversal");
+const make_track_1 = require("./containers/iso-base-media/make-track");
+const traversal_1 = require("./containers/iso-base-media/traversal");
+const get_tracks_from_mp3_1 = require("./containers/mp3/get-tracks-from-mp3");
+const get_tracks_from_avi_1 = require("./containers/riff/get-tracks-from-avi");
+const get_tracks_1 = require("./containers/transport-stream/get-tracks");
+const get_ready_tracks_1 = require("./containers/webm/get-ready-tracks");
+const traversal_2 = require("./containers/webm/traversal");
 const getNumberOfTracks = (moovBox) => {
     const mvHdBox = (0, traversal_1.getMvhdBox)(moovBox);
     if (!mvHdBox) {
@@ -26,7 +26,8 @@ const isoBaseMediaHasTracks = (structure) => {
     return tracks.length === numberOfTracks;
 };
 exports.isoBaseMediaHasTracks = isoBaseMediaHasTracks;
-const getHasTracks = (structure, state) => {
+const getHasTracks = (state) => {
+    const structure = state.structure.getStructure();
     if (structure.type === 'matroska') {
         const mainSegment = (0, traversal_2.getMainSegment)(structure.boxes);
         if (!mainSegment) {
@@ -38,14 +39,23 @@ const getHasTracks = (structure, state) => {
         return (0, exports.isoBaseMediaHasTracks)(structure);
     }
     if (structure.type === 'riff') {
-        return (0, get_tracks_from_avi_1.hasAllTracksFromAvi)(structure, state);
+        return (0, get_tracks_from_avi_1.hasAllTracksFromAvi)(state);
     }
     if (structure.type === 'transport-stream') {
-        return (0, get_tracks_1.hasAllTracksFromTransportStream)(structure, state);
+        return (0, get_tracks_1.hasAllTracksFromTransportStream)(state);
     }
     if (structure.type === 'mp3') {
         return state.callbacks.tracks.getTracks().length > 0;
     }
+    if (structure.type === 'wav') {
+        return state.callbacks.tracks.hasAllTracks();
+    }
+    if (structure.type === 'aac') {
+        return state.callbacks.tracks.hasAllTracks();
+    }
+    if (structure.type === 'flac') {
+        return state.callbacks.tracks.hasAllTracks();
+    }
     throw new Error('Unknown container ' + structure);
 };
 exports.getHasTracks = getHasTracks;
@@ -110,22 +120,26 @@ const getTracksFromIsoBaseMedia = (segments) => {
     };
 };
 exports.getTracksFromIsoBaseMedia = getTracksFromIsoBaseMedia;
-const getTracks = (segments, state) => {
-    if (segments.type === 'matroska') {
-        return getTracksFromMa(segments.boxes, state);
+const getTracks = (state) => {
+    const structure = state.structure.getStructure();
+    if (structure.type === 'matroska') {
+        return getTracksFromMa(structure.boxes, state);
     }
-    if (segments.type === 'iso-base-media') {
-        return (0, exports.getTracksFromIsoBaseMedia)(segments.boxes);
+    if (structure.type === 'iso-base-media') {
+        return (0, exports.getTracksFromIsoBaseMedia)(structure.boxes);
     }
-    if (segments.type === 'riff') {
-        return (0, get_tracks_from_avi_1.getTracksFromAvi)(segments, state);
+    if (structure.type === 'riff') {
+        return (0, get_tracks_from_avi_1.getTracksFromAvi)(structure, state);
     }
-    if (segments.type === 'transport-stream') {
-        return (0, get_tracks_1.getTracksFromTransportStream)(segments, state);
+    if (structure.type === 'transport-stream') {
+        return (0, get_tracks_1.getTracksFromTransportStream)(state);
     }
-    if (segments.type === 'mp3') {
-        return (0, get_tracks_from_mp3_1.getTracksFromMp3)(state);
+    if (structure.type === 'mp3' ||
+        structure.type === 'wav' ||
+        structure.type === 'flac' ||
+        structure.type === 'aac') {
+        return (0, get_tracks_from_mp3_1.getTracksFromMp3OrWavOrAac)(state);
     }
-    throw new Error(`Unknown container${segments}`);
+    throw new Error(`Unknown container${structure}`);
 };
 exports.getTracks = getTracks;

package/dist/get-video-codec.d.ts

@@ -1,9 +1,8 @@
-import type { TrakBox } from './boxes/iso-base-media/trak/trak';
+import type { TrakBox } from './containers/iso-base-media/trak/trak';
 import { type MediaParserVideoCodec, type VideoTrackColorParams } from './get-tracks';
-import type { Structure } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const getVideoCodec: (boxes: Structure, state: ParserState) => MediaParserVideoCodec | null;
-export declare const hasVideoCodec: (boxes: Structure, state: ParserState) => boolean;
+export declare const getVideoCodec: (state: ParserState) => MediaParserVideoCodec | null;
+export declare const hasVideoCodec: (state: ParserState) => boolean;
 export declare const getVideoPrivateData: (trakBox: TrakBox) => Uint8Array | null;
 export declare const getIsoBmColrConfig: (trakBox: TrakBox) => VideoTrackColorParams | null;
 export declare const getVideoCodecString: (trakBox: TrakBox) => string | null;

package/dist/get-video-codec.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVideoCodecString = exports.getIsoBmColrConfig = exports.getVideoPrivateData = exports.hasVideoCodec = exports.getVideoCodec = void 0;
-const color_1 = require("./boxes/avc/color");
-const av1_codec_private_1 = require("./boxes/webm/av1-codec-private");
+const color_1 = require("./containers/avc/color");
+const av1_codec_private_1 = require("./containers/webm/av1-codec-private");
 const get_sample_aspect_ratio_1 = require("./get-sample-aspect-ratio");
 const get_tracks_1 = require("./get-tracks");
-const getVideoCodec = (boxes, state) => {
+const getVideoCodec = (state) => {
     var _a, _b;
-    const track = (0, get_tracks_1.getTracks)(boxes, state);
+    const track = (0, get_tracks_1.getTracks)(state);
     return (_b = (_a = track.videoTracks[0]) === null || _a === void 0 ? void 0 : _a.codecWithoutConfig) !== null && _b !== void 0 ? _b : null;
 };
 exports.getVideoCodec = getVideoCodec;
-const hasVideoCodec = (boxes, state) => {
-    return (0, get_tracks_1.getHasTracks)(boxes, state);
+const hasVideoCodec = (state) => {
+    return (0, get_tracks_1.getHasTracks)(state);
 };
 exports.hasVideoCodec = hasVideoCodec;
 const getVideoPrivateData = (trakBox) => {

package/dist/has-all-info.js

@@ -8,10 +8,12 @@ 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_keyframes_1 = require("./get-keyframes");
+const get_number_of_audio_channels_1 = require("./get-number-of-audio-channels");
+const get_sample_rate_1 = require("./get-sample-rate");
 const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
-const may_skip_video_data_1 = require("./may-skip-video-data/may-skip-video-data");
 const get_metadata_1 = require("./metadata/get-metadata");
+const may_skip_video_data_1 = require("./state/may-skip-video-data");
 const getAvailableInfo = ({ fieldsToFetch, state, }) => {
     const keys = Object.entries(fieldsToFetch).filter(([, value]) => value);
     const structure = state.structure.getStructureOrNull();
@@ -21,15 +23,15 @@ const getAvailableInfo = ({ fieldsToFetch, state, }) => {
             return false;
         }
         if (key === 'durationInSeconds') {
-            return Boolean(structure && (0, get_duration_1.hasDuration)(structure, state));
+            return Boolean(structure && (0, get_duration_1.hasDuration)(state));
         }
         if (key === 'slowDurationInSeconds') {
-            return Boolean(structure && (0, get_duration_1.hasSlowDuration)(structure, state));
+            return Boolean(structure && (0, get_duration_1.hasSlowDuration)(state));
         }
         if (key === 'dimensions' ||
             key === 'rotation' ||
             key === 'unrotatedDimensions') {
-            return Boolean(structure && (0, get_dimensions_1.hasDimensions)(structure, state));
+            return Boolean(structure && (0, get_dimensions_1.hasDimensions)(state));
         }
         if (key === 'fps') {
             return Boolean(structure && (0, get_fps_1.hasFps)(structure));
@@ -39,19 +41,19 @@ const getAvailableInfo = ({ fieldsToFetch, state, }) => {
             return Boolean(structure && (0, get_fps_1.hasFpsSuitedForSlowFps)(structure));
         }
         if (key === 'isHdr') {
-            return Boolean(structure && (0, get_is_hdr_1.hasHdr)(structure, state));
+            return Boolean(structure && (0, get_is_hdr_1.hasHdr)(state));
         }
         if (key === 'videoCodec') {
-            return Boolean(structure && (0, get_video_codec_1.hasVideoCodec)(structure, state));
+            return Boolean(structure && (0, get_video_codec_1.hasVideoCodec)(state));
         }
         if (key === 'audioCodec') {
-            return Boolean(structure && (0, get_audio_codec_1.hasAudioCodec)(structure, state));
+            return Boolean(structure && (0, get_audio_codec_1.hasAudioCodec)(state));
         }
         if (key === 'tracks') {
-            return Boolean(structure && (0, get_tracks_1.getHasTracks)(structure, state));
+            return Boolean(structure && (0, get_tracks_1.getHasTracks)(state));
         }
         if (key === 'keyframes') {
-            return Boolean(structure && (0, get_keyframes_1.hasKeyframes)(structure, state));
+            return Boolean(structure && (0, get_keyframes_1.hasKeyframes)(state));
         }
         if (key === 'internalStats') {
             return true;
@@ -71,11 +73,17 @@ const getAvailableInfo = ({ fieldsToFetch, state, }) => {
         if (key === 'metadata' || key === 'location' || key === 'images') {
             return Boolean(structure && (0, get_metadata_1.hasMetadata)(structure));
         }
-        if (key === 'slowKeyframes') {
+        if (key === 'slowKeyframes' ||
+            key === 'slowVideoBitrate' ||
+            key === 'slowAudioBitrate' ||
+            key === 'slowNumberOfFrames') {
             return false;
         }
-        if (key === 'slowNumberOfFrames') {
-            return false;
+        if (key === 'numberOfAudioChannels') {
+            return (0, get_number_of_audio_channels_1.hasNumberOfAudioChannels)(state);
+        }
+        if (key === 'sampleRate') {
+            return (0, get_sample_rate_1.hasSampleRate)(state);
         }
         throw new Error(`Unknown key: ${key}`);
     });
@@ -92,8 +100,11 @@ const hasAllInfo = ({ fields, state, }) => {
         fieldsToFetch: fields !== null && fields !== void 0 ? fields : {},
         state,
     });
-    return (Object.values(availableInfo).every(Boolean) &&
-        ((0, may_skip_video_data_1.maySkipVideoData)({ state }) ||
-            state.callbacks.canSkipTracksState.canSkipTracks()));
+    if (!Object.values(availableInfo).every(Boolean)) {
+        return false;
+    }
+    const canSkipSamples = (0, may_skip_video_data_1.maySkipVideoData)({ state }) ||
+        state.callbacks.canSkipTracksState.canSkipTracks();
+    return canSkipSamples;
 };
 exports.hasAllInfo = hasAllInfo;

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 import type { LogLevel } from './log';
-export { MatroskaSegment } from './boxes/webm/segments';
-export { MatroskaElement } from './boxes/webm/segments/all-segments';
+export { MatroskaSegment } from './containers/webm/segments';
+export { MatroskaElement } from './containers/webm/segments/all-segments';
 export { IsAGifError, IsAnImageError, IsAnUnsupportedAudioTypeError, IsAnUnsupportedFileTypeError, IsAPdfError, } from './errors';
 export type { SamplePosition } from './get-sample-positions';
 export { MetadataEntry } from './metadata/get-metadata';
 export { MediaParserKeyframe } from './options';
 export type { MediaParserEmbeddedImage } from './state/images';
 export { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, OtherTrack, Track, VideoTrack, VideoTrackColorParams, } from './get-tracks';
-export type { Options, ParseMediaContainer, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOnProgress, ParseMediaOptions, ParseMediaProgress, ParseMediaResult, TracksField, } from './options';
+export type { MediaParserContainer, Options, ParseMediaCallbacks, ParseMediaFields, ParseMediaOnProgress, ParseMediaOptions, ParseMediaProgress, ParseMediaResult, TracksField, } from './options';
 export { parseMedia } from './parse-media';
 export { AudioOrVideoSample, OnAudioSample, OnAudioTrack, OnVideoSample, OnVideoTrack, } from './webcodec-sample-types';
 export { Dimensions } from './get-dimensions';
@@ -655,20 +655,19 @@ export declare const MediaParserInternals: {
         iterator: import("./buffer-iterator").BufferIterator;
         offset: number;
         size: number;
-    }) => import("./boxes/iso-base-media/tkhd").TkhdBox;
+    }) => import("./containers/iso-base-media/tkhd").TkhdBox;
     getArrayBufferIterator: (initialData: Uint8Array, maxBytes: number | null) => {
         startReadingBits: () => void;
         stopReadingBits: () => void;
-        skipTo: (offset: number, reset: boolean) => 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;
-        byteLength: () => number;
         bytesRemaining: () => number;
         leb128: () => number;
-        removeBytesRead: () => void;
+        removeBytesRead: (force: boolean) => number | undefined;
         discard: (length: number) => void;
         getEightByteNumber: (littleEndian?: boolean) => number;
         getFourByteNumber: () => number;
@@ -705,8 +704,6 @@ export declare const MediaParserInternals: {
         getInt32Le: () => number;
         getInt32: () => number;
         destroy: () => void;
-        disallowDiscard: () => void;
-        allowDiscard: () => void;
         startBox: (size: number) => {
             discardRest: () => void;
             expectNoMoreBytes: () => void;
@@ -715,25 +712,24 @@ export declare const MediaParserInternals: {
         startCheckpoint: () => {
             returnToCheckpoint: () => void;
         };
+        getFlacCodecNumber: () => number;
     };
-    parseStsd: ({ iterator, offset, size, state, signal, fields, }: {
-        iterator: import("./buffer-iterator").BufferIterator;
+    parseStsd: ({ offset, size, state, }: {
         offset: number;
         size: number;
         state: import("./state/parser-state").ParserState;
-        signal: AbortSignal | null;
-        fields: import("./options").Options<import("./options").ParseMediaFields>;
-    }) => Promise<import("./boxes/iso-base-media/stsd/stsd").StsdBox>;
-    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, }: {
+    }) => Promise<import("./containers/iso-base-media/stsd/stsd").StsdBox>;
+    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, iterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }: {
         hasAudioTrackHandlers: boolean;
         hasVideoTrackHandlers: boolean;
         signal: AbortSignal | undefined;
-        getIterator: () => import("./buffer-iterator").BufferIterator | null;
+        iterator: import("./buffer-iterator").BufferIterator;
         fields: import("./options").Options<import("./options").ParseMediaFields>;
         supportsContentRange: boolean;
         onAudioTrack: import("./webcodec-sample-types").OnAudioTrack | null;
         onVideoTrack: import("./webcodec-sample-types").OnVideoTrack | null;
         contentLength: number | null;
+        logLevel: LogLevel;
     }) => {
         riff: {
             getAvcProfile: () => import("./state/parser-state").SpsAndPps | null;
@@ -742,6 +738,57 @@ export declare const MediaParserInternals: {
             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("./state/webm").SegmentSection, "index">) => void;
+            addCluster: (cluster: import("./state/webm").ClusterSection) => void;
+            isInsideSegment: (iterator: import("./buffer-iterator").BufferIterator) => import("./state/webm").SegmentSection | null;
+            isInsideCluster: (iterator: import("./buffer-iterator").BufferIterator) => import("./state/webm").ClusterSection | null;
+        };
+        iso: {
+            getShouldReturnToVideoSectionAfterEnd: () => boolean;
+            setShouldReturnToVideoSectionAfterEnd: (value: boolean) => void;
+            flatSamples: {
+                getSamples: () => import("./state/iso-base-media/cached-sample-positions").FlatSample[] | null;
+                setSamples: (samples: import("./state/iso-base-media/cached-sample-positions").FlatSample[]) => void;
+            };
+        };
+        mp3Info: {
+            getMp3Info: () => import("./state/mp3").Mp3Info | null;
+            setMp3Info: (info: import("./state/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>;
@@ -756,10 +803,12 @@ export declare const MediaParserInternals: {
                 setIsDone: () => void;
                 addTrack: (track: import("./get-tracks").Track) => void;
                 getTracks: () => import("./get-tracks").Track[];
-                ensureHasTracksAtEnd: () => void;
+                ensureHasTracksAtEnd: (fields: import("./options").Options<import("./options").ParseMediaFields>) => void;
             };
             audioSampleCallbacks: Record<number, import("./webcodec-sample-types").OnAudioSample>;
             videoSampleCallbacks: Record<number, import("./webcodec-sample-types").OnVideoSample>;
+            hasAudioTrackHandlers: boolean;
+            hasVideoTrackHandlers: boolean;
         };
         getInternalStats: () => import("./state/parser-state").InternalStats;
         getSkipBytes: () => number;
@@ -776,15 +825,6 @@ export declare const MediaParserInternals: {
         onAudioTrack: import("./webcodec-sample-types").OnAudioTrack | null;
         onVideoTrack: import("./webcodec-sample-types").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<import("./options").ParseMediaFields>;
         fields: Partial<import("./options").AllOptions<import("./options").ParseMediaFields>>;
         slowDurationAndFps: {
@@ -793,39 +833,103 @@ export declare const MediaParserInternals: {
             getSlowDurationInSeconds: () => number;
             getFps: () => number;
             getSlowNumberOfFrames: () => number;
-        };
-        mp3Info: {
-            getMp3Info: () => import("./state/mp3").Mp3Info | null;
-            setMp3Info: (info: import("./state/mp3").Mp3Info) => void;
+            getAudioBitrate: () => number | null;
+            getVideoBitrate: () => number | null;
         };
         contentLength: number | null;
         images: {
             images: import("./state/images").MediaParserEmbeddedImage[];
             addImage: (image: import("./state/images").MediaParserEmbeddedImage) => void;
         };
+        videoSection: {
+            setVideoSection: (section: {
+                start: number;
+                size: number;
+            }) => void;
+            getVideoSection: () => {
+                start: number;
+                size: number;
+            };
+            isInVideoSectionState: (iterator: import("./buffer-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;
+        };
     };
-    processSample: ({ iterator, state: options, signal, logLevel, fields, }: {
-        iterator: import("./buffer-iterator").BufferIterator;
+    processSample: ({ state, }: {
         state: import("./state/parser-state").ParserState;
-        signal: AbortSignal | null;
-        logLevel: LogLevel;
-        fields: import("./options").Options<import("./options").ParseMediaFields>;
     }) => Promise<{
-        sample: import("./boxes/iso-base-media/stsd/samples").Sample | null;
+        sample: import("./containers/iso-base-media/stsd/samples").Sample | null;
     }>;
     parseFtyp: ({ iterator, size, offset, }: {
         iterator: import("./buffer-iterator").BufferIterator;
         size: number;
         offset: number;
-    }) => import("./boxes/iso-base-media/ftyp").FtypBox;
-    parseEbml: (iterator: import("./buffer-iterator").BufferIterator, state: import("./state/parser-state").ParserState) => Promise<import("./boxes/webm/parse-ebml").Prettify<import("./boxes/webm/segments/all-segments").PossibleEbml>>;
+    }) => import("./containers/iso-base-media/ftyp").FtypBox;
+    parseEbml: (state: import("./state/parser-state").ParserState) => Promise<import("./containers/webm/parse-ebml").Prettify<import("./containers/webm/segments/all-segments").PossibleEbml>>;
     parseMvhd: ({ iterator, offset, size, }: {
         iterator: import("./buffer-iterator").BufferIterator;
         offset: number;
         size: number;
-    }) => import("./boxes/iso-base-media/mvhd").MvhdBox;
+    }) => import("./containers/iso-base-media/mvhd").MvhdBox;
 };
-export type { Prettify } from './boxes/webm/parse-ebml';
-export type { Ebml, EbmlValue, FloatWithSize, MainSegment, PossibleEbml, TrackEntry, UintWithSize, } from './boxes/webm/segments/all-segments';
+export type { Prettify } from './containers/webm/parse-ebml';
+export type { Ebml, EbmlValue, FloatWithSize, MainSegment, PossibleEbml, TrackEntry, UintWithSize, } from './containers/webm/segments/all-segments';
 export type { LogLevel };
 export { VERSION } from './version';

package/dist/index.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = exports.MediaParserInternals = exports.parseMedia = exports.IsAPdfError = exports.IsAnUnsupportedFileTypeError = exports.IsAnUnsupportedAudioTypeError = exports.IsAnImageError = exports.IsAGifError = void 0;
 const aac_codecprivate_1 = require("./aac-codecprivate");
-const ftyp_1 = require("./boxes/iso-base-media/ftyp");
-const mvhd_1 = require("./boxes/iso-base-media/mvhd");
-const samples_1 = require("./boxes/iso-base-media/stsd/samples");
-const stsd_1 = require("./boxes/iso-base-media/stsd/stsd");
-const tkhd_1 = require("./boxes/iso-base-media/tkhd");
-const parse_ebml_1 = require("./boxes/webm/parse-ebml");
-const all_segments_1 = require("./boxes/webm/segments/all-segments");
 const buffer_iterator_1 = require("./buffer-iterator");
+const ftyp_1 = require("./containers/iso-base-media/ftyp");
+const mvhd_1 = require("./containers/iso-base-media/mvhd");
+const samples_1 = require("./containers/iso-base-media/stsd/samples");
+const stsd_1 = require("./containers/iso-base-media/stsd/stsd");
+const tkhd_1 = require("./containers/iso-base-media/tkhd");
+const parse_ebml_1 = require("./containers/webm/parse-ebml");
+const all_segments_1 = require("./containers/webm/segments/all-segments");
 const log_1 = require("./log");
 const parser_state_1 = require("./state/parser-state");
 var errors_1 = require("./errors");
@@ -29,7 +29,7 @@ exports.MediaParserInternals = {
     getArrayBufferIterator: buffer_iterator_1.getArrayBufferIterator,
     parseStsd: stsd_1.parseStsd,
     makeParserState: parser_state_1.makeParserState,
-    processSample: samples_1.processSample,
+    processSample: samples_1.processIsoFormatBox,
     parseFtyp: ftyp_1.parseFtyp,
     parseEbml: parse_ebml_1.parseEbml,
     parseMvhd: mvhd_1.parseMvhd,

package/dist/init-video.d.ts

@@ -0,0 +1,7 @@
+import type { ParserState } from './state/parser-state';
+export declare const initVideo: ({ state, mimeType, name, contentLength, }: {
+    state: ParserState;
+    mimeType: string | null;
+    name: string | null;
+    contentLength: number | null;
+}) => Promise<never> | undefined;