@remotion/media-parser 4.0.248 → 4.0.250

package/dist/boxes/riff/parse-box.js

@@ -1,125 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseRiff = exports.parseRiffBody = void 0;
-const get_tracks_1 = require("../../get-tracks");
+exports.parseRiff = void 0;
 const has_all_info_1 = require("../../has-all-info");
-const register_track_1 = require("../../register-track");
-const expect_riff_box_1 = require("./expect-riff-box");
-const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
-const traversal_1 = require("./traversal");
-const continueAfterRiffBoxResult = ({ result, structure, iterator, maxOffset, state: options, }) => {
-    if (result.type === 'incomplete') {
-        return Promise.resolve({
-            status: 'incomplete',
-            async continueParsing() {
-                return Promise.resolve(continueAfterRiffBoxResult({
-                    result: await result.continueParsing(),
-                    structure,
-                    iterator,
-                    maxOffset,
-                    state: options,
-                }));
-            },
-            segments: structure,
-            skipTo: null,
-        });
-    }
-    if (result.type === 'complete' && result.box) {
-        structure.boxes.push(result.box);
-    }
-    return (0, exports.parseRiffBody)({ iterator, maxOffset, state: options, structure });
-};
-const parseRiffBody = async ({ iterator, structure, maxOffset, state, }) => {
-    while (iterator.bytesRemaining() > 0 &&
-        iterator.counter.getOffset() < maxOffset) {
-        const result = await (0, expect_riff_box_1.expectRiffBox)({
-            iterator,
-            state,
-            structure,
-        });
-        if (result.type === 'complete' && result.skipTo !== null) {
-            return {
-                status: 'incomplete',
-                skipTo: result.skipTo,
-                continueParsing() {
-                    return Promise.resolve(continueAfterRiffBoxResult({
-                        iterator,
-                        maxOffset,
-                        state,
-                        result,
-                        structure,
-                    }));
-                },
-            };
-        }
-        if (result.type === 'incomplete') {
-            return {
-                status: 'incomplete',
-                async continueParsing() {
-                    return Promise.resolve(continueAfterRiffBoxResult({
-                        iterator,
-                        maxOffset,
-                        state,
-                        result: await result.continueParsing(),
-                        structure,
-                    }));
-                },
-                skipTo: null,
-            };
-        }
-        if (result.box === null) {
-            continue;
-        }
-        structure.boxes.push(result.box);
-        // When parsing an AVI
-        if (result.box.type === 'list-box' && result.box.listType === 'hdrl') {
-            const tracks = (0, get_tracks_1.getTracks)(structure, state);
-            if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER)) {
-                state.callbacks.tracks.setIsDone();
-            }
-        }
-        // When parsing a WAV
-        if (result.box.type === 'wave-format-box') {
-            state.callbacks.tracks.setIsDone();
-        }
-        if (result.box.type === 'strf-box-video' ||
-            result.box.type === 'strf-box-audio') {
-            const strh = (0, traversal_1.getStrhBox)(structure.boxes);
-            const strf = (0, traversal_1.getStrfBox)(structure.boxes);
-            if (!strh || !strf) {
-                throw new Error('strh or strf box missing');
-            }
-            if (strf.type === 'strf-box-audio' && state.onAudioTrack) {
-                const audioTrack = (0, get_tracks_from_avi_1.makeAviAudioTrack)({
-                    index: state.riff.getNextTrackIndex(),
-                    strf,
-                });
-                await (0, register_track_1.registerTrack)({
-                    state,
-                    track: audioTrack,
-                    container: 'avi',
-                });
-            }
-            if (state.onVideoTrack && strf.type === 'strf-box-video') {
-                const videoTrack = (0, get_tracks_from_avi_1.makeAviVideoTrack)({
-                    strh,
-                    index: state.riff.getNextTrackIndex(),
-                    strf,
-                });
-                (0, register_track_1.registerVideoTrackWhenProfileIsAvailable)({
-                    state,
-                    track: videoTrack,
-                    container: 'avi',
-                });
-            }
-            state.riff.incrementNextTrackIndex();
-        }
-    }
-    return {
-        status: 'done',
-    };
-};
-exports.parseRiffBody = parseRiffBody;
+const parse_riff_body_1 = require("./parse-riff-body");
 const parseRiff = ({ iterator, state, fields, }) => {
     const riff = iterator.getByteString(4, false);
     if (riff !== 'RIFF') {
@@ -141,11 +24,12 @@ const parseRiff = ({ iterator, state, fields, }) => {
             segments: structure,
         });
     }
-    return (0, exports.parseRiffBody)({
+    return (0, parse_riff_body_1.parseRiffBody)({
         iterator,
         maxOffset: Infinity,
         state,
         structure,
+        fields,
     });
 };
 exports.parseRiff = parseRiff;

package/dist/boxes/riff/parse-fmt-box.d.ts

@@ -1,7 +1,8 @@
 import type { BufferIterator } from '../../buffer-iterator';
+import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
-export declare const parseFmtBox: ({ iterator, boxes, size, }: {
+export declare const parseFmtBox: ({ iterator, size, state, }: {
     iterator: BufferIterator;
-    boxes: RiffBox[];
     size: number;
+    state: ParserState;
 }) => RiffBox;

package/dist/boxes/riff/parse-fmt-box.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFmtBox = void 0;
-const parseFmtBox = ({ iterator, boxes, size, }) => {
+const parseFmtBox = ({ iterator, size, state, }) => {
     const box = iterator.startBox(size);
-    const header = boxes.find((b) => b.type === 'riff-header');
-    if (!header) {
-        throw new Error('Expected RIFF header');
+    const structure = state.structure.getStructure();
+    const riffHeader = structure.boxes.find((b) => b.type === 'riff-header');
+    if (!riffHeader) {
+        throw new Error('Expected RIFF header to be parsed before fmt');
     }
-    if (header.fileType !== 'WAVE') {
+    // TODO: Can we delete this?
+    if (riffHeader.fileType !== 'WAVE') {
         throw new Error('Only supporting WAVE type');
     }
     const wFormatTag = iterator.getUint16Le();

package/dist/boxes/riff/parse-list-box.js

@@ -1,30 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseListBox = void 0;
-const parse_box_1 = require("./parse-box");
+const expect_riff_box_1 = require("./expect-riff-box");
 const parseListBox = async ({ iterator, size, state, }) => {
     const counter = iterator.counter.getOffset();
     const listType = iterator.getByteString(4, false);
     if (listType === 'movi') {
         throw new Error('should not be handled here');
     }
-    const structure = {
-        type: 'riff',
-        boxes: [],
-    };
-    const result = await (0, parse_box_1.parseRiffBody)({
-        structure,
-        iterator,
-        maxOffset: counter + size,
-        state,
-    });
-    if (result.status === 'incomplete') {
-        throw new Error(`Should only parse complete boxes (${listType})`);
+    const boxes = [];
+    const maxOffset = counter + size;
+    while (iterator.counter.getOffset() < maxOffset) {
+        const result = await (0, expect_riff_box_1.expectRiffBox)({
+            iterator,
+            state,
+        });
+        if (result.box !== null) {
+            boxes.push(result.box);
+        }
+        else {
+            throw new Error('Unexpected result');
+        }
     }
     return {
         type: 'list-box',
         listType,
-        children: structure.boxes,
+        children: boxes,
     };
 };
 exports.parseListBox = parseListBox;

package/dist/boxes/riff/parse-movi.d.ts

@@ -1,17 +1,14 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { RiffStructure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffResult } from './expect-riff-box';
-export declare const handleChunk: ({ iterator, state, structure, ckId, ckSize, }: {
+export declare const handleChunk: ({ iterator, state, ckId, ckSize, }: {
     iterator: BufferIterator;
     state: ParserState;
-    structure: RiffStructure;
     ckId: string;
     ckSize: number;
 }) => Promise<void>;
-export declare const parseMovi: ({ iterator, maxOffset, state, structure, }: {
+export declare const parseMovi: ({ iterator, maxOffset, state, }: {
     iterator: BufferIterator;
     maxOffset: number;
     state: ParserState;
-    structure: RiffStructure;
 }) => Promise<RiffResult>;

package/dist/boxes/riff/parse-movi.js

@@ -18,12 +18,12 @@ const getStrhForIndex = (structure, trackId) => {
     }
     return strh;
 };
-const handleChunk = async ({ iterator, state, structure, ckId, ckSize, }) => {
+const handleChunk = async ({ iterator, state, ckId, ckSize, }) => {
     const offset = iterator.counter.getOffset();
     const videoChunk = ckId.match(/^([0-9]{2})dc$/);
     if (videoChunk) {
         const trackId = parseInt(videoChunk[1], 10);
-        const strh = getStrhForIndex(structure, trackId);
+        const strh = getStrhForIndex(state.structure.getStructure(), trackId);
         const samplesPerSecond = strh.rate / strh.scale;
         const nthSample = state.callbacks.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
@@ -56,7 +56,7 @@ const handleChunk = async ({ iterator, state, structure, ckId, ckSize, }) => {
     const audioChunk = ckId.match(/^([0-9]{2})wb$/);
     if (audioChunk) {
         const trackId = parseInt(audioChunk[1], 10);
-        const strh = getStrhForIndex(structure, trackId);
+        const strh = getStrhForIndex(state.structure.getStructure(), trackId);
         const samplesPerSecond = strh.rate / strh.scale;
         const nthSample = state.callbacks.getSamplesForTrack(trackId);
         const timeInSec = nthSample / samplesPerSecond;
@@ -81,66 +81,44 @@ const handleChunk = async ({ iterator, state, structure, ckId, ckSize, }) => {
     }
 };
 exports.handleChunk = handleChunk;
-const parseMovi = async ({ iterator, maxOffset, state, structure, }) => {
-    while (iterator.counter.getOffset() < maxOffset) {
-        if (iterator.bytesRemaining() < 8) {
-            return {
-                type: 'incomplete',
-                continueParsing: () => {
-                    return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, state, structure }));
-                },
-            };
-        }
-        const ckId = iterator.getByteString(4, false);
-        const ckSize = iterator.getUint32Le();
-        if ((0, may_skip_video_data_1.maySkipVideoData)({
-            state,
-        }) &&
-            state.riff.getAvcProfile()) {
-            return {
-                type: 'complete',
-                box: {
-                    type: 'movi-box',
-                },
-                skipTo: maxOffset,
-            };
-        }
-        if (iterator.bytesRemaining() < ckSize) {
-            iterator.counter.decrement(8);
-            return {
-                type: 'incomplete',
-                continueParsing: () => {
-                    return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, state, structure }));
-                },
-            };
-        }
-        await (0, exports.handleChunk)({ iterator, state, structure, ckId, ckSize });
-        // Discard added zeroes
-        while (iterator.counter.getOffset() < maxOffset &&
-            iterator.bytesRemaining() > 0) {
-            if (iterator.getUint8() !== 0) {
-                iterator.counter.decrement(1);
-                break;
-            }
-        }
+const parseMovi = async ({ iterator, maxOffset, state, }) => {
+    if ((0, may_skip_video_data_1.maySkipVideoData)({
+        state,
+    }) &&
+        state.riff.getAvcProfile()) {
+        return {
+            box: null,
+            skipTo: maxOffset,
+        };
     }
-    if (iterator.counter.getOffset() === maxOffset) {
+    if (iterator.bytesRemaining() < 8) {
         return {
-            type: 'complete',
-            box: {
-                type: 'movi-box',
-            },
+            box: null,
             skipTo: null,
         };
     }
-    if (iterator.counter.getOffset() > maxOffset) {
-        throw new Error('Oops, this should not happen!');
+    const checkpoint = iterator.startCheckpoint();
+    const ckId = iterator.getByteString(4, false);
+    const ckSize = iterator.getUint32Le();
+    if (iterator.bytesRemaining() < ckSize) {
+        checkpoint.returnToCheckpoint();
+        return {
+            box: null,
+            skipTo: null,
+        };
+    }
+    await (0, exports.handleChunk)({ iterator, state, ckId, ckSize });
+    // Discard added zeroes
+    while (iterator.counter.getOffset() < maxOffset &&
+        iterator.bytesRemaining() > 0) {
+        if (iterator.getUint8() !== 0) {
+            iterator.counter.decrement(1);
+            break;
+        }
     }
     return {
-        type: 'incomplete',
-        continueParsing: () => {
-            return Promise.resolve((0, exports.parseMovi)({ iterator, maxOffset, state, structure }));
-        },
+        box: null,
+        skipTo: null,
     };
 };
 exports.parseMovi = parseMovi;

package/dist/boxes/riff/parse-riff-body.d.ts

@@ -0,0 +1,7 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseRiffBody: ({ iterator, state, }: {
+    iterator: BufferIterator;
+    state: ParserState;
+}) => Promise<ParseResult>;

package/dist/boxes/riff/parse-riff-body.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiffBody = void 0;
+const expect_riff_box_1 = require("./expect-riff-box");
+const parse_video_section_1 = require("./parse-video-section");
+const parseRiffBody = async ({ iterator, state, }) => {
+    if (state.videoSection.isInVideoSectionState(iterator) === 'in-section') {
+        const videoSec = await (0, parse_video_section_1.parseVideoSection)({ state, iterator });
+        return {
+            skipTo: videoSec.skipTo,
+        };
+    }
+    const result = await (0, expect_riff_box_1.expectRiffBox)({
+        iterator,
+        state,
+    });
+    if (result.box !== null) {
+        const structure = state.structure.getStructure();
+        structure.boxes.push(result.box);
+    }
+    return {
+        skipTo: result.skipTo,
+    };
+};
+exports.parseRiffBody = parseRiffBody;

package/dist/boxes/riff/parse-riff-box.d.ts

@@ -1,10 +1,9 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
-export declare const parseRiffBox: ({ iterator, size, id, boxes, state, }: {
+export declare const parseRiffBox: ({ iterator, size, id, state, }: {
     iterator: BufferIterator;
     size: number;
     id: string;
-    boxes: RiffBox[];
     state: ParserState;
 }) => Promise<RiffBox>;

package/dist/boxes/riff/parse-riff-box.js

@@ -5,11 +5,10 @@ const parse_avih_1 = require("./parse-avih");
 const parse_fmt_box_1 = require("./parse-fmt-box");
 const parse_isft_1 = require("./parse-isft");
 const parse_list_box_1 = require("./parse-list-box");
-const parse_strf_1 = require("./parse-strf");
 const parse_strh_1 = require("./parse-strh");
-const parseRiffBox = ({ iterator, size, id, boxes, state, }) => {
+const parseRiffBox = ({ iterator, size, id, state, }) => {
     if (id === 'fmt') {
-        return Promise.resolve((0, parse_fmt_box_1.parseFmtBox)({ iterator, boxes, size }));
+        return Promise.resolve((0, parse_fmt_box_1.parseFmtBox)({ iterator, size, state }));
     }
     if (id === 'LIST') {
         return (0, parse_list_box_1.parseListBox)({ iterator, size, state });
@@ -23,9 +22,6 @@ const parseRiffBox = ({ iterator, size, id, boxes, state, }) => {
     if (id === 'strh') {
         return Promise.resolve((0, parse_strh_1.parseStrh)({ iterator, size }));
     }
-    if (id === 'strf') {
-        return Promise.resolve((0, parse_strf_1.parseStrf)({ iterator, size, boxes }));
-    }
     iterator.discard(size);
     const box = {
         type: 'riff-box',

package/dist/boxes/riff/parse-riff-header.d.ts

@@ -0,0 +1,7 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseRiffHeader: ({ iterator, state, }: {
+    iterator: BufferIterator;
+    state: ParserState;
+}) => ParseResult;

package/dist/boxes/riff/parse-riff-header.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiffHeader = void 0;
+const parseRiffHeader = ({ iterator, state, }) => {
+    const riff = iterator.getByteString(4, false);
+    if (riff !== 'RIFF') {
+        throw new Error('Not a RIFF file');
+    }
+    const structure = state.structure.getStructure();
+    if (structure.type !== 'riff') {
+        throw new Error('Structure is not a RIFF structure');
+    }
+    const size = iterator.getUint32Le();
+    const fileType = iterator.getByteString(4, false);
+    if (fileType !== 'WAVE' && fileType !== 'AVI') {
+        throw new Error(`File type ${fileType} not supported`);
+    }
+    structure.boxes.push({ type: 'riff-header', fileSize: size, fileType });
+    return {
+        skipTo: null,
+    };
+};
+exports.parseRiffHeader = parseRiffHeader;

package/dist/boxes/riff/parse-riff.d.ts

@@ -0,0 +1,7 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseRiff: ({ iterator, state, }: {
+    iterator: BufferIterator;
+    state: ParserState;
+}) => Promise<ParseResult>;

package/dist/boxes/riff/parse-riff.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRiff = void 0;
+const parse_riff_body_1 = require("./parse-riff-body");
+const parse_riff_header_1 = require("./parse-riff-header");
+const parseRiff = ({ iterator, state, }) => {
+    if (iterator.counter.getOffset() === 0) {
+        return Promise.resolve((0, parse_riff_header_1.parseRiffHeader)({ iterator, state }));
+    }
+    return (0, parse_riff_body_1.parseRiffBody)({
+        iterator,
+        state,
+    });
+};
+exports.parseRiff = parseRiff;

package/dist/boxes/riff/parse-strf.d.ts

@@ -1,7 +1,7 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { RiffBox } from './riff-box';
-export declare const parseStrf: ({ iterator, size, boxes, }: {
+import type { FccType, StrfBoxAudio, StrfBoxVideo } from './riff-box';
+export declare const parseStrf: ({ iterator, size, fccType, }: {
     iterator: BufferIterator;
     size: number;
-    boxes: RiffBox[];
-}) => RiffBox;
+    fccType: FccType;
+}) => StrfBoxAudio | StrfBoxVideo;

package/dist/boxes/riff/parse-strf.js

@@ -51,17 +51,13 @@ const parseStrfVideo = ({ iterator, size, }) => {
         yPelsPerMeter,
     };
 };
-const parseStrf = ({ iterator, size, boxes, }) => {
-    const strh = boxes.find((b) => b.type === 'strh-box');
-    if (!strh) {
-        throw new Error('strh box not found');
-    }
-    if (strh.fccType === 'vids') {
+const parseStrf = ({ iterator, size, fccType, }) => {
+    if (fccType === 'vids') {
         return parseStrfVideo({ iterator, size });
     }
-    if (strh.fccType === 'auds') {
+    if (fccType === 'auds') {
         return parseStrfAudio({ iterator, size });
     }
-    throw new Error(`Unsupported fccType: ${strh.fccType}`);
+    throw new Error(`Unsupported fccType: ${fccType}`);
 };
 exports.parseStrf = parseStrf;

package/dist/boxes/riff/parse-strh.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStrh = void 0;
+const parse_strf_1 = require("./parse-strf");
 const parseStrh = ({ iterator, size, }) => {
     const box = iterator.startBox(size);
     const fccType = iterator.getByteString(4, false);
@@ -28,6 +29,15 @@ const parseStrh = ({ iterator, size, }) => {
     const quality = iterator.getUint32Le();
     const sampleSize = iterator.getUint32Le();
     box.discardRest();
+    const ckId = iterator.getByteString(4, false);
+    const ckSize = iterator.getUint32Le();
+    if (ckId !== 'strf') {
+        throw new Error(`Expected strf, got ${JSON.stringify(ckId)}`);
+    }
+    if (iterator.bytesRemaining() < ckSize) {
+        throw new Error('Expected strf to be complete');
+    }
+    const strf = (0, parse_strf_1.parseStrf)({ iterator, size: ckSize, fccType });
     return {
         type: 'strh-box',
         fccType,
@@ -43,6 +53,7 @@ const parseStrh = ({ iterator, size, }) => {
         start,
         suggestedBufferSize,
         language,
+        strf,
     };
 };
 exports.parseStrh = parseStrh;

package/dist/boxes/riff/parse-video-section.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseVideoSection: ({ state, iterator, }: {
+    state: ParserState;
+    iterator: BufferIterator;
+}) => Promise<import("./expect-riff-box").RiffResult>;

package/dist/boxes/riff/parse-video-section.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVideoSection = void 0;
+const get_tracks_1 = require("../../get-tracks");
+const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
+const parse_movi_1 = require("./parse-movi");
+const parseVideoSection = ({ state, iterator, }) => {
+    const videoSection = state.videoSection.getVideoSection();
+    const movi = (0, parse_movi_1.parseMovi)({
+        iterator,
+        maxOffset: videoSection.start + videoSection.size,
+        state,
+    });
+    const tracks = (0, get_tracks_1.getTracks)(state);
+    if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER)) {
+        state.callbacks.tracks.setIsDone();
+    }
+    return movi;
+};
+exports.parseVideoSection = parseVideoSection;

package/dist/boxes/riff/riff-box.d.ts

@@ -30,9 +30,10 @@ export type AvihBox = {
     width: number;
     height: number;
 };
+export type FccType = 'vids' | 'auds';
 export type StrhBox = {
     type: 'strh-box';
-    fccType: 'vids' | 'auds';
+    fccType: FccType;
     handler: 'H264' | number;
     flags: number;
     priority: number;
@@ -45,6 +46,7 @@ export type StrhBox = {
     quality: number;
     sampleSize: number;
     language: number;
+    strf: StrfBoxVideo | StrfBoxAudio;
 };
 export type StrfBoxVideo = {
     type: 'strf-box-video';
@@ -75,11 +77,8 @@ export type RiffHeader = {
     fileSize: number;
     fileType: string;
 };
-export type MoviBox = {
-    type: 'movi-box';
-};
 export type IsftBox = {
     type: 'isft-box';
     software: string;
 };
-export type RiffBox = RiffRegularBox | WaveFormatBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | MoviBox | IsftBox;
+export type RiffBox = RiffRegularBox | WaveFormatBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | IsftBox;

package/dist/boxes/riff/traversal.d.ts

@@ -1,8 +1,7 @@
 import type { RiffStructure } from '../../parse-result';
-import type { AvihBox, ListBox, RiffBox, StrfBoxAudio, StrfBoxVideo, StrhBox } from './riff-box';
+import type { AvihBox, ListBox, RiffBox, StrhBox } from './riff-box';
 export declare const isRiffAvi: (structure: RiffStructure) => boolean;
 export declare const getHdlrBox: (structure: RiffStructure) => ListBox | null;
 export declare const getAvihBox: (structure: RiffStructure) => AvihBox | null;
 export declare const getStrlBoxes: (structure: RiffStructure) => ListBox[];
 export declare const getStrhBox: (strlBoxChildren: RiffBox[]) => StrhBox | null;
-export declare const getStrfBox: (strlBoxChildren: RiffBox[]) => StrfBoxAudio | StrfBoxVideo | null;

package/dist/boxes/riff/traversal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStrfBox = exports.getStrhBox = exports.getStrlBoxes = exports.getAvihBox = exports.getHdlrBox = exports.isRiffAvi = void 0;
+exports.getStrhBox = exports.getStrlBoxes = exports.getAvihBox = exports.getHdlrBox = exports.isRiffAvi = void 0;
 const isRiffAvi = (structure) => {
     return structure.boxes.some((box) => box.type === 'riff-header' && box.fileType === 'AVI');
 };
@@ -29,8 +29,3 @@ const getStrhBox = (strlBoxChildren) => {
     return strlBoxChildren.find((box) => box.type === 'strh-box');
 };
 exports.getStrhBox = getStrhBox;
-const getStrfBox = (strlBoxChildren) => {
-    var _a;
-    return ((_a = strlBoxChildren.find((box) => box.type === 'strf-box-audio' || box.type === 'strf-box-video')) !== null && _a !== void 0 ? _a : null);
-};
-exports.getStrfBox = getStrfBox;