@remotion/media-parser 4.0.247 → 4.0.249

package/dist/boxes/iso-base-media/process-box.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseIsoBaseMediaBoxes = exports.processBox = exports.parseMdatPartially = void 0;
+exports.processBox = void 0;
 const get_tracks_1 = require("../../get-tracks");
-const has_all_info_1 = require("../../has-all-info");
 const may_skip_video_data_1 = require("../../may-skip-video-data/may-skip-video-data");
 const register_track_1 = require("../../register-track");
 const esds_1 = require("./esds/esds");
 const ftyp_1 = require("./ftyp");
+const get_children_1 = require("./get-children");
 const make_track_1 = require("./make-track");
 const mdat_1 = require("./mdat/mdat");
 const mdhd_1 = require("./mdhd");
@@ -14,6 +14,7 @@ const hdlr_1 = require("./meta/hdlr");
 const ilst_1 = require("./meta/ilst");
 const moov_1 = require("./moov/moov");
 const mvhd_1 = require("./mvhd");
+const parse_mdat_partially_1 = require("./parse-mdat-partially");
 const av1c_1 = require("./stsd/av1c");
 const avcc_1 = require("./stsd/avcc");
 const colr_1 = require("./stsd/colr");
@@ -32,85 +33,11 @@ const tfdt_1 = require("./tfdt");
 const tfhd_1 = require("./tfhd");
 const tkhd_1 = require("./tkhd");
 const trak_1 = require("./trak/trak");
-const traversal_1 = require("./traversal");
 const trun_1 = require("./trun");
-const getChildren = async ({ boxType, iterator, bytesRemainingInBox, state, signal, logLevel, fields, }) => {
-    const parseChildren = boxType === 'mdia' ||
-        boxType === 'minf' ||
-        boxType === 'stbl' ||
-        boxType === 'udta' ||
-        boxType === 'moof' ||
-        boxType === 'dims' ||
-        boxType === 'meta' ||
-        boxType === 'wave' ||
-        boxType === 'traf' ||
-        boxType === 'stsb';
-    if (parseChildren) {
-        const boxes = [];
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        const parsed = await (0, exports.parseIsoBaseMediaBoxes)({
-            iterator,
-            maxBytes: bytesRemainingInBox,
-            allowIncompleteBoxes: false,
-            initialBoxes: boxes,
-            state,
-            continueMdat: false,
-            signal,
-            logLevel,
-            fields,
-        });
-        if (parsed.status === 'incomplete') {
-            throw new Error('Incomplete boxes are not allowed');
-        }
-        return boxes;
-    }
-    if (bytesRemainingInBox < 0) {
-        throw new Error('Box size is too big ' + JSON.stringify({ boxType }));
-    }
-    iterator.discard(bytesRemainingInBox);
-    return [];
-};
-const parseMdatPartially = async ({ iterator, boxSize, fileOffset, parsedBoxes, state, signal, }) => {
-    const box = await (0, mdat_1.parseMdat)({
-        data: iterator,
-        size: boxSize,
-        fileOffset,
-        existingBoxes: parsedBoxes,
-        state,
-        signal,
-        maySkipSampleProcessing: state.supportsContentRange,
-    });
-    if ((box.status === 'samples-processed' || box.status === 'samples-buffered') &&
-        box.fileOffset + boxSize === iterator.counter.getOffset()) {
-        return {
-            type: 'complete',
-            box,
-            size: boxSize,
-            skipTo: null,
-        };
-    }
-    return {
-        type: 'partial-mdat-box',
-        boxSize,
-        fileOffset,
-    };
-};
-exports.parseMdatPartially = parseMdatPartially;
 const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state, signal, logLevel, fields, }) => {
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSizeRaw = iterator.getFourByteNumber();
-    // If `boxSize === 1`, the 8 bytes after the box type are the size of the box.
-    if ((boxSizeRaw === 1 && iterator.bytesRemaining() < 12) ||
-        iterator.bytesRemaining() < 4) {
-        iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
-        if (allowIncompleteBoxes) {
-            return {
-                type: 'incomplete',
-            };
-        }
-        throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSizeRaw}. Incomplete boxes are not allowed.`);
-    }
     if (boxSizeRaw === 0) {
         return {
             type: 'complete',
@@ -122,50 +49,61 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             skipTo: null,
         };
     }
+    // If `boxSize === 1`, the 8 bytes after the box type are the size of the box.
+    if ((boxSizeRaw === 1 && iterator.bytesRemaining() < 12) ||
+        iterator.bytesRemaining() < 4) {
+        iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
+        if (!allowIncompleteBoxes) {
+            throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSizeRaw}. Incomplete boxes are not allowed.`);
+        }
+        return {
+            type: 'incomplete',
+        };
+    }
     const boxType = iterator.getByteString(4, false);
     const boxSize = boxSizeRaw === 1 ? iterator.getEightByteNumber() : boxSizeRaw;
     if (bytesRemaining < boxSize) {
-        if (boxType === 'mdat') {
-            // Check if the moov atom is at the end
-            const shouldSkip = (0, may_skip_video_data_1.maySkipVideoData)({ state }) ||
-                (!(0, get_tracks_1.hasTracks)({ type: 'iso-base-media', boxes: parsedBoxes }, state) &&
-                    state.supportsContentRange);
-            if (shouldSkip) {
-                const skipTo = fileOffset + boxSize;
-                const bytesToSkip = skipTo - iterator.counter.getOffset();
-                // If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
-                if (bytesToSkip > 1000000) {
-                    return {
-                        type: 'complete',
-                        box: {
-                            type: 'mdat-box',
-                            boxSize,
-                            fileOffset,
-                            status: 'samples-skipped',
-                        },
-                        size: boxSize,
-                        skipTo: fileOffset + boxSize,
-                    };
-                }
-            }
-            else {
-                return (0, exports.parseMdatPartially)({
-                    iterator,
-                    boxSize,
-                    fileOffset,
-                    parsedBoxes,
-                    state,
-                    signal,
-                });
+        if (boxType !== 'mdat') {
+            iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
+            if (!allowIncompleteBoxes) {
+                throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSize}. Incomplete boxes are not allowed.`);
             }
-        }
-        iterator.counter.decrement(iterator.counter.getOffset() - fileOffset);
-        if (allowIncompleteBoxes) {
             return {
                 type: 'incomplete',
             };
         }
-        throw new Error(`Expected box size of ${bytesRemaining}, got ${boxSize}. Incomplete boxes are not allowed.`);
+        // Check if the moov atom is at the end
+        const shouldSkip = (0, may_skip_video_data_1.maySkipVideoData)({ state }) ||
+            (!(0, get_tracks_1.getHasTracks)({ type: 'iso-base-media', boxes: parsedBoxes }, state) &&
+                state.supportsContentRange);
+        if (shouldSkip) {
+            const skipTo = fileOffset + boxSize;
+            const bytesToSkip = skipTo - iterator.counter.getOffset();
+            // If there is a huge mdat chunk, we can skip it because we don't need it for the metadata
+            if (bytesToSkip > 1000000) {
+                return {
+                    type: 'complete',
+                    box: {
+                        type: 'mdat-box',
+                        boxSize,
+                        fileOffset,
+                        status: 'samples-skipped',
+                    },
+                    size: boxSize,
+                    skipTo: fileOffset + boxSize,
+                };
+            }
+        }
+        else {
+            return (0, parse_mdat_partially_1.parseMdatPartially)({
+                iterator,
+                boxSize,
+                fileOffset,
+                parsedBoxes,
+                state,
+                signal,
+            });
+        }
     }
     if (boxType === 'ftyp') {
         const box = (0, ftyp_1.parseFtyp)({ iterator, size: boxSize, offset: fileOffset });
@@ -508,8 +446,8 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
             signal,
             maySkipSampleProcessing: state.supportsContentRange,
         });
-        if (box === null) {
-            throw new Error('Unexpected null');
+        if (box.type === 'partial-mdat-box') {
+            return box;
         }
         return {
             type: 'complete',
@@ -519,7 +457,7 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
         };
     }
     const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-    const children = await getChildren({
+    const children = await (0, get_children_1.getChildren)({
         boxType,
         iterator,
         bytesRemainingInBox,
@@ -542,158 +480,3 @@ const processBox = async ({ iterator, allowIncompleteBoxes, parsedBoxes, state,
     };
 };
 exports.processBox = processBox;
-const parseIsoBaseMediaBoxes = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, continueMdat, signal, logLevel, fields, }) => {
-    var _a;
-    const initialOffset = iterator.counter.getOffset();
-    const alreadyHasMdat = (_a = state.structure
-        .getStructureOrNull()) === null || _a === void 0 ? void 0 : _a.boxes.find((b) => b.type === 'mdat-box');
-    while (iterator.bytesRemaining() > 0 &&
-        iterator.counter.getOffset() - initialOffset < maxBytes) {
-        const result = continueMdat
-            ? await (0, exports.parseMdatPartially)({
-                iterator,
-                boxSize: continueMdat.boxSize,
-                fileOffset: continueMdat.fileOffset,
-                parsedBoxes: initialBoxes,
-                state,
-                signal,
-            })
-            : await (0, exports.processBox)({
-                iterator,
-                allowIncompleteBoxes,
-                parsedBoxes: initialBoxes,
-                state,
-                signal,
-                logLevel,
-                fields,
-            });
-        if (result.type === 'incomplete') {
-            if (Number.isFinite(maxBytes)) {
-                throw new Error('maxBytes must be Infinity for top-level boxes');
-            }
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return (0, exports.parseIsoBaseMediaBoxes)({
-                        iterator,
-                        maxBytes,
-                        allowIncompleteBoxes,
-                        initialBoxes,
-                        state,
-                        continueMdat: false,
-                        signal,
-                        logLevel,
-                        fields,
-                    });
-                },
-                skipTo: null,
-            };
-        }
-        if (result.type === 'partial-mdat-box') {
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return Promise.resolve((0, exports.parseIsoBaseMediaBoxes)({
-                        iterator,
-                        maxBytes,
-                        allowIncompleteBoxes,
-                        initialBoxes,
-                        state,
-                        continueMdat: result,
-                        signal,
-                        logLevel,
-                        fields,
-                    }));
-                },
-                skipTo: null,
-            };
-        }
-        if (result.box.type === 'mdat-box' && alreadyHasMdat) {
-            initialBoxes = initialBoxes.filter((b) => b.type !== 'mdat-box');
-            initialBoxes.push(result.box);
-            iterator.allowDiscard();
-            break;
-        }
-        else {
-            initialBoxes.push(result.box);
-            if ((0, has_all_info_1.hasAllInfo)({ fields, state })) {
-                return {
-                    status: 'done',
-                };
-            }
-        }
-        if (result.skipTo !== null) {
-            if (!state.supportsContentRange) {
-                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
-            }
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return (0, exports.parseIsoBaseMediaBoxes)({
-                        iterator,
-                        maxBytes,
-                        allowIncompleteBoxes,
-                        initialBoxes,
-                        state,
-                        continueMdat: false,
-                        signal,
-                        logLevel,
-                        fields,
-                    });
-                },
-                skipTo: result.skipTo,
-            };
-        }
-        if (iterator.bytesRemaining() < 0) {
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return (0, exports.parseIsoBaseMediaBoxes)({
-                        iterator,
-                        maxBytes,
-                        allowIncompleteBoxes,
-                        initialBoxes,
-                        state,
-                        continueMdat: false,
-                        signal,
-                        logLevel,
-                        fields,
-                    });
-                },
-                skipTo: null,
-            };
-        }
-        iterator.removeBytesRead();
-    }
-    const mdatState = (0, traversal_1.getMdatBox)(initialBoxes);
-    const skipped = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-skipped' &&
-        !(0, may_skip_video_data_1.maySkipVideoData)({ state }) &&
-        state.supportsContentRange;
-    const buffered = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-buffered' && !(0, may_skip_video_data_1.maySkipVideoData)({ state });
-    if (skipped || buffered) {
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                if (buffered) {
-                    iterator.skipTo(mdatState.fileOffset, false);
-                }
-                return (0, exports.parseIsoBaseMediaBoxes)({
-                    iterator,
-                    maxBytes,
-                    allowIncompleteBoxes: false,
-                    initialBoxes,
-                    state,
-                    continueMdat: false,
-                    signal,
-                    logLevel,
-                    fields,
-                });
-            },
-            skipTo: skipped ? mdatState.fileOffset : null,
-        };
-    }
-    return {
-        status: 'done',
-    };
-};
-exports.parseIsoBaseMediaBoxes = parseIsoBaseMediaBoxes;

package/dist/boxes/iso-base-media/stsd/mebx.js

@@ -1,19 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMebx = void 0;
-const process_box_1 = require("../process-box");
+const parse_boxes_1 = require("../parse-boxes");
 const parseMebx = async ({ iterator, offset, size, state, signal, fields, }) => {
     // reserved, 6 bit
     iterator.discard(6);
     const dataReferenceIndex = iterator.getUint16();
     const boxes = [];
-    const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
+    const children = await (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
         iterator,
         maxBytes: iterator.counter.getOffset() - offset,
         allowIncompleteBoxes: false,
         initialBoxes: boxes,
         state,
-        continueMdat: false,
         signal,
         logLevel: 'info',
         fields,

package/dist/boxes/iso-base-media/stsd/samples.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseSamples = exports.processSample = void 0;
-const process_box_1 = require("../process-box");
+const parse_boxes_1 = require("../parse-boxes");
 // https://developer.apple.com/documentation/quicktime-file-format/video_sample_description
 const videoTags = [
     'cvid',
@@ -100,13 +100,12 @@ const processSample = async ({ iterator, state: options, signal, logLevel, field
             const sampleRate = iterator.getFixedPointUnsigned1616Number();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
             const initialBoxes = [];
-            const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
+            const children = await (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
                 initialBoxes,
                 state: options,
-                continueMdat: false,
                 signal,
                 logLevel,
                 fields,
@@ -149,13 +148,12 @@ const processSample = async ({ iterator, state: options, signal, logLevel, field
             const bytesPerSample = iterator.getUint32();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
             const initialBoxes = [];
-            const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
+            const children = await (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
                 initialBoxes,
                 state: options,
-                continueMdat: false,
                 signal,
                 logLevel,
                 fields,
@@ -201,13 +199,12 @@ const processSample = async ({ iterator, state: options, signal, logLevel, field
             const bytesPerFrame = iterator.getUint32();
             const samplesPerPacket = iterator.getUint32();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-            const children = await (0, process_box_1.parseIsoBaseMediaBoxes)({
+            const children = await (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
                 initialBoxes: [],
                 state: options,
-                continueMdat: false,
                 signal,
                 logLevel,
                 fields,
@@ -259,13 +256,12 @@ const processSample = async ({ iterator, state: options, signal, logLevel, field
         const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
         const initialBoxes = [];
         const children = bytesRemainingInBox > 8
-            ? await (0, process_box_1.parseIsoBaseMediaBoxes)({
+            ? await (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
                 initialBoxes,
                 state: options,
-                continueMdat: false,
                 signal,
                 logLevel,
                 fields,

package/dist/boxes/iso-base-media/trak/trak.js

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTrak = void 0;
-const process_box_1 = require("../process-box");
+const parse_boxes_1 = require("../parse-boxes");
 const parseTrak = async ({ data, size, offsetAtStart, state: options, signal, logLevel, fields, }) => {
     const initialBoxes = [];
-    const result = await (0, process_box_1.parseIsoBaseMediaBoxes)({
+    const result = await (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
         iterator: data,
         maxBytes: size - (data.counter.getOffset() - offsetAtStart),
         allowIncompleteBoxes: false,
         initialBoxes,
         state: options,
-        continueMdat: false,
         signal,
         logLevel,
         fields,

package/dist/boxes/mp3/get-duration.d.ts

@@ -0,0 +1,2 @@
+import type { ParserState } from '../../state/parser-state';
+export declare const getDurationFromMp3: (state: ParserState) => number | null;

package/dist/boxes/mp3/get-duration.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDurationFromMp3 = void 0;
+const get_frame_length_1 = require("./get-frame-length");
+const samples_per_mpeg_file_1 = require("./samples-per-mpeg-file");
+const getDurationFromMp3 = (state) => {
+    if (state.contentLength === null) {
+        return null;
+    }
+    const mp3Info = state.mp3Info.getMp3Info();
+    if (!mp3Info) {
+        throw new Error('No mp3 info');
+    }
+    const samplesPerFrame = (0, samples_per_mpeg_file_1.getSamplesPerMpegFrame)({
+        layer: mp3Info.layer,
+        mpegVersion: mp3Info.mpegVersion,
+    });
+    const frameLengthInBytes = (0, get_frame_length_1.getMpegFrameLength)({
+        bitrateKbit: mp3Info.bitrateKbit,
+        padding: false,
+        samplesPerFrame,
+        samplingFrequency: mp3Info.sampleRate,
+        layer: mp3Info.layer,
+    });
+    const frames = Math.floor((state.contentLength - mp3Info.startOfMpegStream) / frameLengthInBytes);
+    const samples = frames * samplesPerFrame;
+    const durationInSeconds = samples / mp3Info.sampleRate;
+    return durationInSeconds;
+};
+exports.getDurationFromMp3 = getDurationFromMp3;

package/dist/boxes/mp3/get-frame-length.d.ts

@@ -0,0 +1,13 @@
+export declare const getAverageMpegFrameLength: ({ samplesPerFrame, bitrateKbit, samplingFrequency, layer, }: {
+    samplesPerFrame: number;
+    bitrateKbit: number;
+    samplingFrequency: number;
+    layer: number;
+}) => number;
+export declare const getMpegFrameLength: ({ samplesPerFrame, bitrateKbit, samplingFrequency, padding, layer, }: {
+    samplesPerFrame: number;
+    bitrateKbit: number;
+    samplingFrequency: number;
+    padding: boolean;
+    layer: number;
+}) => number;

package/dist/boxes/mp3/get-frame-length.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMpegFrameLength = exports.getAverageMpegFrameLength = void 0;
+const getUnroundedMpegFrameLength = ({ samplesPerFrame, bitrateKbit, samplingFrequency, padding, layer, }) => {
+    if (layer === 1) {
+        throw new Error('MPEG Layer I is not supported');
+    }
+    return ((((samplesPerFrame / 8) * bitrateKbit) / samplingFrequency) * 1000 +
+        (padding ? (layer === 1 ? 4 : 1) : 0));
+};
+const getAverageMpegFrameLength = ({ samplesPerFrame, bitrateKbit, samplingFrequency, layer, }) => {
+    const withoutPadding = getUnroundedMpegFrameLength({
+        bitrateKbit,
+        layer,
+        padding: false,
+        samplesPerFrame,
+        samplingFrequency,
+    });
+    const rounded = Math.floor(withoutPadding);
+    const rest = withoutPadding % 1;
+    return rest * (rounded + 1) + (1 - rest) * rounded;
+};
+exports.getAverageMpegFrameLength = getAverageMpegFrameLength;
+const getMpegFrameLength = ({ samplesPerFrame, bitrateKbit, samplingFrequency, padding, layer, }) => {
+    return Math.floor(getUnroundedMpegFrameLength({
+        bitrateKbit,
+        layer,
+        padding,
+        samplesPerFrame,
+        samplingFrequency,
+    }));
+};
+exports.getMpegFrameLength = getMpegFrameLength;

package/dist/boxes/mp3/get-metadata-from-mp3.d.ts

@@ -0,0 +1,3 @@
+import type { MetadataEntry } from '../../metadata/get-metadata';
+import type { Mp3Structure } from '../../parse-result';
+export declare const getMetadataFromMp3: (mp3Structure: Mp3Structure) => MetadataEntry[] | null;

package/dist/boxes/mp3/get-metadata-from-mp3.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataFromMp3 = void 0;
+const getMetadataFromMp3 = (mp3Structure) => {
+    const findHeader = mp3Structure.boxes.find((b) => b.type === 'id3-header');
+    return findHeader ? findHeader.metatags : null;
+};
+exports.getMetadataFromMp3 = getMetadataFromMp3;

package/dist/boxes/mp3/get-tracks-from-mp3.d.ts

@@ -0,0 +1,4 @@
+import type { ParserState } from '../../state/parser-state';
+import type { AllTracks } from '../riff/get-tracks-from-avi';
+export declare const getTracksFromMp3: (parserState: ParserState) => AllTracks;
+export declare const hasAllTracksFromMp3: (parserState: ParserState) => boolean;

package/dist/boxes/mp3/get-tracks-from-mp3.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasAllTracksFromMp3 = exports.getTracksFromMp3 = void 0;
+const getTracksFromMp3 = (parserState) => {
+    const tracks = parserState.callbacks.tracks.getTracks();
+    if (tracks.length === 0) {
+        throw new Error('No tracks found');
+    }
+    return {
+        audioTracks: tracks.filter((t) => t.type === 'audio'),
+        otherTracks: [],
+        videoTracks: [],
+    };
+};
+exports.getTracksFromMp3 = getTracksFromMp3;
+const hasAllTracksFromMp3 = (parserState) => {
+    try {
+        (0, exports.getTracksFromMp3)(parserState);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.hasAllTracksFromMp3 = hasAllTracksFromMp3;

package/dist/boxes/mp3/id3-v1.d.ts

@@ -0,0 +1,2 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export declare const parseID3V1: (iterator: BufferIterator) => void;

package/dist/boxes/mp3/id3-v1.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseID3V1 = void 0;
+const parseID3V1 = (iterator) => {
+    if (iterator.bytesRemaining() < 128) {
+        return;
+    }
+    // we drop ID3v1 because usually there is also ID3v2 and ID3v3 which are superior.
+    // Better than have duplicated data.
+    iterator.discard(128);
+};
+exports.parseID3V1 = parseID3V1;

package/dist/boxes/mp3/id3-v2.js

@@ -0,0 +1 @@
+"use strict";

package/dist/boxes/mp3/id3.d.ts

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { Mp3Structure } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseId3: ({ iterator, structure, state, }: {
+    iterator: BufferIterator;
+    structure: Mp3Structure;
+    state: ParserState;
+}) => void;