@remotion/media-parser 4.0.250 → 4.0.252

package/dist/index.d.ts

@@ -1,18 +1,20 @@
 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 { MediaParserKeyframe, ParseMediaSrc } 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 { downloadAndParseMedia } from './download-and-parse-media';
+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';
 export { MediaParserLocation } from './get-location';
 export type { ReaderInterface } from './readers/reader';
+export type { CreateContent, Writer, WriterInterface } from './writers/writer';
 export declare const MediaParserInternals: {
     Log: {
         trace: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
@@ -21,10 +23,11 @@ export declare const MediaParserInternals: {
         warn: (logLevel: LogLevel, ...args: Parameters<typeof console.log>) => void;
         error: (...args: Parameters<typeof console.log>) => void;
     };
-    createAacCodecPrivate: ({ audioObjectType, sampleRate, channelConfiguration, }: {
+    createAacCodecPrivate: ({ audioObjectType, sampleRate, channelConfiguration, codecPrivate, }: {
         audioObjectType: number;
         sampleRate: number;
         channelConfiguration: number;
+        codecPrivate: Uint8Array | null;
     }) => Uint8Array;
     matroskaElements: {
         readonly Header: "0x1a45dfa3";
@@ -655,11 +658,11 @@ 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;
@@ -667,7 +670,10 @@ export declare const MediaParserInternals: {
         getBits: (bits: number) => number;
         bytesRemaining: () => number;
         leb128: () => number;
-        removeBytesRead: () => void;
+        removeBytesRead: (force: boolean, mode: import("./options").ParseMediaMode) => {
+            bytesRemoved: number;
+            removedData: Uint8Array | null;
+        };
         discard: (length: number) => void;
         getEightByteNumber: (littleEndian?: boolean) => number;
         getFourByteNumber: () => number;
@@ -712,25 +718,136 @@ export declare const MediaParserInternals: {
         startCheckpoint: () => {
             returnToCheckpoint: () => void;
         };
+        getFlacCodecNumber: () => number;
     };
-    parseStsd: ({ iterator, offset, size, state, }: {
-        iterator: import("./buffer-iterator").BufferIterator;
+    parseStsd: ({ offset, size, state, }: {
         offset: number;
         size: number;
         state: import("./state/parser-state").ParserState;
-    }) => Promise<import("./boxes/iso-base-media/stsd/stsd").StsdBox>;
-    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, getIterator, fields, onAudioTrack, onVideoTrack, supportsContentRange, contentLength, logLevel, }: {
+    }) => Promise<import("./containers/iso-base-media/stsd/stsd").StsdBox>;
+    makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, signal, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, }: {
         hasAudioTrackHandlers: boolean;
         hasVideoTrackHandlers: boolean;
         signal: AbortSignal | undefined;
-        getIterator: () => import("./buffer-iterator").BufferIterator | null;
         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;
+        contentLength: number;
         logLevel: LogLevel;
+        mode: import("./options").ParseMediaMode;
+        src: import("./options").ParseMediaSrc;
+        readerInterface: import("./readers/reader").ReaderInterface;
+        onDiscardedData: import("./options").OnDiscardedData | null;
     }) => {
+        onAudioTrack: import("./webcodec-sample-types").OnAudioTrack | null;
+        onVideoTrack: import("./webcodec-sample-types").OnVideoTrack | null;
+        emittedFields: import("./options").AllOptions<import("./options").ParseMediaFields>;
+        fields: Partial<import("./options").AllOptions<import("./options").ParseMediaFields>>;
+        slowDurationAndFps: {
+            addVideoSample: (videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
+            addAudioSample: (audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
+            getSlowDurationInSeconds: () => number;
+            getFps: () => number;
+            getSlowNumberOfFrames: () => number;
+            getAudioBitrate: () => number | null;
+            getVideoBitrate: () => number | null;
+        };
+        contentLength: number;
+        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, mode: import("./options").ParseMediaMode) => {
+                bytesRemoved: number;
+                removedData: Uint8Array | null;
+            };
+            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;
+        };
+        signal: AbortSignal | undefined;
+        mode: import("./options").ParseMediaMode;
+        eventLoop: {
+            eventLoopBreakIfNeeded: () => Promise<void>;
+        };
+        src: import("./options").ParseMediaSrc;
+        readerInterface: import("./readers/reader").ReaderInterface;
+        discardReadBytes: (force: boolean) => Promise<void>;
+        getStructureOrNull: () => import("./parse-result").Structure | null;
+        getStructure: () => import("./parse-result").Structure;
+        setStructure: (value: import("./parse-result").Structure) => void;
+        getFlacStructure: () => import("./containers/flac/types").FlacStructure;
+        getIsoStructure: () => import("./parse-result").IsoBaseMediaStructure;
+        getMp3Structure: () => import("./parse-result").Mp3Structure;
+        getRiffStructure: () => import("./containers/riff/riff-box").RiffStructure;
+        getTsStructure: () => import("./parse-result").TransportStreamStructure;
+        getWavStructure: () => import("./containers/wav/types").WavStructure;
+        getMatroskaStructure: () => import("./parse-result").MatroskaStructure;
         riff: {
             getAvcProfile: () => import("./state/parser-state").SpsAndPps | null;
             onProfile: (profile: import("./state/parser-state").SpsAndPps) => Promise<void>;
@@ -740,14 +857,14 @@ export declare const MediaParserInternals: {
         };
         transportStream: {
             nextPesHeaderStore: {
-                setNextPesHeader: (pesHeader: import("./boxes/transport-stream/parse-pes").PacketPes) => void;
-                getNextPesHeader: () => import("./boxes/transport-stream/parse-pes").PacketPes;
+                setNextPesHeader: (pesHeader: import("./containers/transport-stream/parse-pes").PacketPes) => void;
+                getNextPesHeader: () => import("./containers/transport-stream/parse-pes").PacketPes;
             };
-            streamBuffers: Map<number, import("./boxes/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
+            streamBuffers: Map<number, import("./containers/transport-stream/process-stream-buffers").TransportStreamPacketBuffer>;
         };
         webm: {
-            onTrackEntrySegment: import("./boxes/webm/segments").OnTrackEntrySegment;
-            getTrackInfoByNumber: (id: number) => import("./boxes/webm/segments/track-entry").TrackInfo;
+            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;
@@ -759,17 +876,38 @@ export declare const MediaParserInternals: {
             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;
             };
+            moov: {
+                setMoovBox: (moov: import("./containers/iso-base-media/moov/moov").MoovBox) => void;
+                getMoovBox: () => import("./containers/iso-base-media/moov/moov").MoovBox | null;
+            };
         };
         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>;
@@ -781,10 +919,11 @@ export declare const MediaParserInternals: {
             registerAudioSampleCallback: (id: number, callback: import("./webcodec-sample-types").OnAudioSample | null) => Promise<void>;
             tracks: {
                 hasAllTracks: () => boolean;
-                setIsDone: () => void;
+                getIsDone: () => boolean;
+                setIsDone: (logLevel: LogLevel) => 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>;
@@ -798,60 +937,25 @@ export declare const MediaParserInternals: {
             addKeyframe: (keyframe: import("./options").MediaParserKeyframe) => void;
             getKeyframes: () => import("./options").MediaParserKeyframe[];
         };
-        structure: {
-            getStructureOrNull: () => import("./parse-result").Structure | null;
-            getStructure: () => import("./parse-result").Structure;
-            setStructure: (value: import("./parse-result").Structure) => void;
-        };
-        onAudioTrack: import("./webcodec-sample-types").OnAudioTrack | null;
-        onVideoTrack: import("./webcodec-sample-types").OnVideoTrack | null;
-        supportsContentRange: boolean;
-        emittedFields: import("./options").AllOptions<import("./options").ParseMediaFields>;
-        fields: Partial<import("./options").AllOptions<import("./options").ParseMediaFields>>;
-        slowDurationAndFps: {
-            addVideoSample: (videoSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
-            addAudioSample: (audioSample: import("./webcodec-sample-types").AudioOrVideoSample) => void;
-            getSlowDurationInSeconds: () => number;
-            getFps: () => number;
-            getSlowNumberOfFrames: () => number;
-        };
-        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";
     };
-    processSample: ({ iterator, state, }: {
-        iterator: import("./buffer-iterator").BufferIterator;
+    processSample: ({ state, }: {
         state: import("./state/parser-state").ParserState;
     }) => 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

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = exports.MediaParserInternals = exports.parseMedia = exports.IsAPdfError = exports.IsAnUnsupportedFileTypeError = exports.IsAnUnsupportedAudioTypeError = exports.IsAnImageError = exports.IsAGifError = void 0;
+exports.VERSION = exports.MediaParserInternals = exports.parseMedia = exports.downloadAndParseMedia = 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");
@@ -18,6 +18,8 @@ Object.defineProperty(exports, "IsAnImageError", { enumerable: true, get: functi
 Object.defineProperty(exports, "IsAnUnsupportedAudioTypeError", { enumerable: true, get: function () { return errors_1.IsAnUnsupportedAudioTypeError; } });
 Object.defineProperty(exports, "IsAnUnsupportedFileTypeError", { enumerable: true, get: function () { return errors_1.IsAnUnsupportedFileTypeError; } });
 Object.defineProperty(exports, "IsAPdfError", { enumerable: true, get: function () { return errors_1.IsAPdfError; } });
+var download_and_parse_media_1 = require("./download-and-parse-media");
+Object.defineProperty(exports, "downloadAndParseMedia", { enumerable: true, get: function () { return download_and_parse_media_1.downloadAndParseMedia; } });
 var parse_media_1 = require("./parse-media");
 Object.defineProperty(exports, "parseMedia", { enumerable: true, get: function () { return parse_media_1.parseMedia; } });
 exports.MediaParserInternals = {

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;
+}) => Promise<never> | undefined;

package/dist/{parse-video.js → init-video.js}

@@ -1,18 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseVideo = void 0;
-const parse_boxes_1 = require("./boxes/iso-base-media/parse-boxes");
-const parse_mp3_1 = require("./boxes/mp3/parse-mp3");
-const parse_riff_1 = require("./boxes/riff/parse-riff");
-const parse_transport_stream_1 = require("./boxes/transport-stream/parse-transport-stream");
-const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
+exports.initVideo = void 0;
 const errors_1 = require("./errors");
 const log_1 = require("./log");
-const initVideo = ({ iterator, state, mimeType, name, contentLength, }) => {
-    const fileType = iterator.detectFileType();
+const initVideo = ({ state, mimeType, name, contentLength, }) => {
+    const fileType = state.iterator.detectFileType();
     if (fileType.type === 'riff') {
         log_1.Log.verbose(state.logLevel, 'Detected RIFF container');
-        state.structure.setStructure({
+        state.setStructure({
             type: 'riff',
             boxes: [],
         });
@@ -20,7 +15,7 @@ const initVideo = ({ iterator, state, mimeType, name, contentLength, }) => {
     }
     if (fileType.type === 'iso-base-media') {
         log_1.Log.verbose(state.logLevel, 'Detected ISO Base Media container');
-        state.structure.setStructure({
+        state.setStructure({
             type: 'iso-base-media',
             boxes: [],
         });
@@ -28,7 +23,7 @@ const initVideo = ({ iterator, state, mimeType, name, contentLength, }) => {
     }
     if (fileType.type === 'webm') {
         log_1.Log.verbose(state.logLevel, 'Detected Matroska container');
-        state.structure.setStructure({
+        state.setStructure({
             boxes: [],
             type: 'matroska',
         });
@@ -36,7 +31,7 @@ const initVideo = ({ iterator, state, mimeType, name, contentLength, }) => {
     }
     if (fileType.type === 'transport-stream') {
         log_1.Log.verbose(state.logLevel, 'Detected MPEG-2 Transport Stream');
-        state.structure.setStructure({
+        state.setStructure({
             boxes: [],
             type: 'transport-stream',
         });
@@ -48,26 +43,34 @@ const initVideo = ({ iterator, state, mimeType, name, contentLength, }) => {
             boxes: [],
             type: 'mp3',
         };
-        state.structure.setStructure(structure);
+        state.setStructure(structure);
         return;
     }
     if (fileType.type === 'wav') {
-        return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
-            message: 'WAV files are not yet supported',
-            mimeType,
-            sizeInBytes: contentLength,
-            fileName: name,
-            audioType: 'wav',
-        }));
+        log_1.Log.verbose(state.logLevel, 'Detected WAV');
+        const structure = {
+            boxes: [],
+            type: 'wav',
+        };
+        state.setStructure(structure);
+        return;
+    }
+    if (fileType.type === 'flac') {
+        log_1.Log.verbose(state.logLevel, 'Detected FLAC');
+        const structure = {
+            boxes: [],
+            type: 'flac',
+        };
+        state.setStructure(structure);
+        return;
     }
     if (fileType.type === 'aac') {
-        return Promise.reject(new errors_1.IsAnUnsupportedAudioTypeError({
-            message: 'AAC files are not yet supported',
-            mimeType,
-            sizeInBytes: contentLength,
-            fileName: name,
-            audioType: 'aac',
-        }));
+        log_1.Log.verbose(state.logLevel, 'Detected AAC');
+        state.setStructure({
+            type: 'aac',
+            boxes: [],
+        });
+        return;
     }
     if (fileType.type === 'gif') {
         return Promise.reject(new errors_1.IsAGifError({
@@ -108,36 +111,4 @@ const initVideo = ({ iterator, state, mimeType, name, contentLength, }) => {
     }
     return Promise.reject(new Error('Unknown video format ' + fileType));
 };
-const parseVideo = async ({ iterator, state, mimeType, contentLength, name, }) => {
-    if (iterator.bytesRemaining() === 0) {
-        return Promise.reject(new Error('no bytes'));
-    }
-    const structure = state.structure.getStructureOrNull();
-    if (structure === null) {
-        await initVideo({ iterator, state, mimeType, name, contentLength });
-        return { skipTo: null };
-    }
-    if (structure.type === 'riff') {
-        return (0, parse_riff_1.parseRiff)({ iterator, state });
-    }
-    if (structure.type === 'mp3') {
-        return (0, parse_mp3_1.parseMp3)({ iterator, state });
-    }
-    if (structure.type === 'iso-base-media') {
-        return (0, parse_boxes_1.parseIsoBaseMedia)({
-            iterator,
-            state,
-        });
-    }
-    if (structure.type === 'matroska') {
-        return (0, parse_webm_header_1.parseWebm)({ iterator, state });
-    }
-    if (structure.type === 'transport-stream') {
-        return (0, parse_transport_stream_1.parseTransportStream)({
-            iterator,
-            state,
-        });
-    }
-    return Promise.reject(new Error('Unknown video format ' + structure));
-};
-exports.parseVideo = parseVideo;
+exports.initVideo = initVideo;

package/dist/internal-parse-media.d.ts

@@ -0,0 +1,2 @@
+import type { InternalParseMedia } from './options';
+export declare const internalParseMedia: InternalParseMedia;