@remotion/media-parser 4.0.250 → 4.0.251

package/dist/{boxes → containers}/iso-base-media/traversal.d.ts

@@ -1,4 +1,5 @@
-import type { AnySegment, IsoBaseMediaBox, RegularBox } from '../../parse-result';
+import type { AnySegment } from '../../parse-result';
+import type { IsoBaseMediaBox, RegularBox } from './base-media-box';
 import type { FtypBox } from './ftyp';
 import type { MdhdBox } from './mdhd';
 import type { MoovBox } from './moov/moov';

package/dist/containers/iso-base-media/void-box.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/containers/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 getTracksFromMp3OrWavOrAac: (parserState: ParserState) => AllTracks;
+export declare const hasAllTracksFromMp3OrWavOrAac: (parserState: ParserState) => boolean;

package/dist/{boxes → containers}/mp3/get-tracks-from-mp3.js

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

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

@@ -0,0 +1,4 @@
+import type { ParserState } from '../../state/parser-state';
+export declare const parseId3: ({ state }: {
+    state: ParserState;
+}) => void;

package/dist/{boxes → containers}/mp3/id3.js

@@ -10,7 +10,8 @@ function combine28Bits(a, b, c, d) {
     // Combine all values using bitwise operations
     return (val1 << 21) | (val2 << 14) | (val3 << 7) | val4;
 }
-const parseId3 = ({ iterator, state, }) => {
+const parseId3 = ({ state }) => {
+    const { iterator } = state;
     if (iterator.bytesRemaining() < 9) {
         return;
     }

package/dist/containers/mp3/parse-mp3.d.ts

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

package/dist/{boxes → containers}/mp3/parse-mp3.js

@@ -4,7 +4,8 @@ exports.parseMp3 = void 0;
 const id3_1 = require("./id3");
 const id3_v1_1 = require("./id3-v1");
 const parse_mpeg_header_1 = require("./parse-mpeg-header");
-const parseMp3 = async ({ iterator, state, }) => {
+const parseMp3 = async (state) => {
+    const { iterator } = state;
     if (iterator.bytesRemaining() < 3) {
         return {
             skipTo: null,
@@ -22,14 +23,13 @@ const parseMp3 = async ({ iterator, state, }) => {
     }
     // ID3 v2 or v3
     if (bytes[0] === 0x49 && bytes[1] === 0x44 && bytes[2] === 0x33) {
-        (0, id3_1.parseId3)({ iterator, state });
+        (0, id3_1.parseId3)({ state });
         return {
             skipTo: null,
         };
     }
     if (bytes[0] === 0xff) {
         await (0, parse_mpeg_header_1.parseMpegHeader)({
-            iterator,
             state,
         });
         return {

package/dist/containers/mp3/parse-mpeg-header.d.ts

@@ -0,0 +1,4 @@
+import type { ParserState } from '../../state/parser-state';
+export declare const parseMpegHeader: ({ state, }: {
+    state: ParserState;
+}) => Promise<void>;

package/dist/{boxes → containers}/mp3/parse-mpeg-header.js

@@ -143,7 +143,8 @@ function getBitrateKB({ bits, mpegVersion, level, }) {
     // Return the corresponding bitrate
     return bitrateTable[bits][key];
 }
-const parseMpegHeader = async ({ iterator, state, }) => {
+const parseMpegHeader = async ({ state, }) => {
+    const { iterator } = state;
     const initialOffset = iterator.counter.getOffset();
     if (iterator.bytesRemaining() < 32) {
         return;

package/dist/containers/riff/expect-riff-box.d.ts

@@ -0,0 +1,7 @@
+import type { ParserState } from '../../state/parser-state';
+import type { RiffBox } from './riff-box';
+export type RiffResult = {
+    box: RiffBox | null;
+    skipTo: number | null;
+};
+export declare const expectRiffBox: (state: ParserState) => Promise<RiffResult>;

package/dist/{boxes → containers}/riff/expect-riff-box.js

@@ -6,9 +6,10 @@ const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
 const is_movi_1 = require("./is-movi");
 const parse_riff_box_1 = require("./parse-riff-box");
 const parse_video_section_1 = require("./parse-video-section");
-const expectRiffBox = async ({ iterator, state, }) => {
+const expectRiffBox = async (state) => {
+    const { iterator } = state;
     // Need at least 16 bytes to read LIST,size,movi,size
-    if (iterator.bytesRemaining() < 16) {
+    if (state.iterator.bytesRemaining() < 16) {
         return {
             box: null,
             skipTo: null,
@@ -23,7 +24,7 @@ const expectRiffBox = async ({ iterator, state, }) => {
             start: iterator.counter.getOffset(),
             size: ckSize - 4,
         });
-        return (0, parse_video_section_1.parseVideoSection)({ state, iterator });
+        return (0, parse_video_section_1.parseVideoSection)(state);
     }
     if (iterator.bytesRemaining() < ckSize) {
         checkpoint.returnToCheckpoint();
@@ -34,7 +35,6 @@ const expectRiffBox = async ({ iterator, state, }) => {
     }
     const box = await (0, parse_riff_box_1.parseRiffBox)({
         id: ckId,
-        iterator,
         size: ckSize,
         state,
     });

package/dist/containers/riff/get-duration.d.ts

@@ -0,0 +1,3 @@
+import type { RiffStructure } from './riff-box';
+export declare const getDurationFromAvi: (structure: RiffStructure) => number;
+export declare const getSampleRateFromAvi: (structure: RiffStructure) => number | null;

package/dist/containers/riff/get-duration.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSampleRateFromAvi = exports.getDurationFromAvi = void 0;
+const traversal_1 = require("./traversal");
+const getDurationFromAvi = (structure) => {
+    const strl = (0, traversal_1.getStrlBoxes)(structure);
+    const lengths = [];
+    for (const s of strl) {
+        const strh = (0, traversal_1.getStrhBox)(s.children);
+        if (!strh) {
+            throw new Error('No strh box');
+        }
+        const samplesPerSecond = strh.rate / strh.scale;
+        const streamLength = strh.length / samplesPerSecond;
+        lengths.push(streamLength);
+    }
+    return Math.max(...lengths);
+};
+exports.getDurationFromAvi = getDurationFromAvi;
+const getSampleRateFromAvi = (structure) => {
+    const strl = (0, traversal_1.getStrlBoxes)(structure);
+    for (const s of strl) {
+        const strh = (0, traversal_1.getStrhBox)(s.children);
+        if (!strh) {
+            throw new Error('No strh box');
+        }
+        if (strh.strf.type === 'strf-box-audio') {
+            return strh.strf.sampleRate;
+        }
+    }
+    return null;
+};
+exports.getSampleRateFromAvi = getSampleRateFromAvi;

package/dist/{boxes → containers}/riff/get-tracks-from-avi.d.ts

@@ -1,7 +1,6 @@
 import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
-import type { RiffStructure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
-import type { StrfBoxAudio, StrfBoxVideo, StrhBox } from './riff-box';
+import type { RiffStructure, StrfBoxAudio, StrfBoxVideo, StrhBox } from './riff-box';
 export type AllTracks = {
     videoTracks: VideoTrack[];
     audioTracks: AudioTrack[];

package/dist/{boxes → containers}/riff/parse-list-box.d.ts

@@ -1,8 +1,6 @@
-import type { BufferIterator } from '../../buffer-iterator';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffBox } from './riff-box';
-export declare const parseListBox: ({ iterator, size, state, }: {
-    iterator: BufferIterator;
+export declare const parseListBox: ({ size, state, }: {
     size: number;
     state: ParserState;
 }) => Promise<RiffBox>;

package/dist/{boxes → containers}/riff/parse-list-box.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseListBox = void 0;
 const expect_riff_box_1 = require("./expect-riff-box");
-const parseListBox = async ({ iterator, size, state, }) => {
+const parseListBox = async ({ size, state, }) => {
+    const { iterator } = state;
     const counter = iterator.counter.getOffset();
     const listType = iterator.getByteString(4, false);
     if (listType === 'movi') {
@@ -11,10 +12,7 @@ const parseListBox = async ({ iterator, size, state, }) => {
     const boxes = [];
     const maxOffset = counter + size;
     while (iterator.counter.getOffset() < maxOffset) {
-        const result = await (0, expect_riff_box_1.expectRiffBox)({
-            iterator,
-            state,
-        });
+        const result = await (0, expect_riff_box_1.expectRiffBox)(state);
         if (result.box !== null) {
             boxes.push(result.box);
         }

package/dist/{boxes → containers}/riff/parse-movi.d.ts

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

package/dist/{boxes → containers}/riff/parse-movi.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMovi = exports.handleChunk = void 0;
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
-const may_skip_video_data_1 = require("../../may-skip-video-data/may-skip-video-data");
+const may_skip_video_data_1 = require("../../state/may-skip-video-data");
 const key_1 = require("../avc/key");
 const parse_avc_1 = require("../avc/parse-avc");
 const traversal_1 = require("./traversal");
@@ -18,7 +18,8 @@ const getStrhForIndex = (structure, trackId) => {
     }
     return strh;
 };
-const handleChunk = async ({ iterator, state, ckId, ckSize, }) => {
+const handleChunk = async ({ state, ckId, ckSize, }) => {
+    const { iterator } = state;
     const offset = iterator.counter.getOffset();
     const videoChunk = ckId.match(/^([0-9]{2})dc$/);
     if (videoChunk) {
@@ -81,7 +82,7 @@ const handleChunk = async ({ iterator, state, ckId, ckSize, }) => {
     }
 };
 exports.handleChunk = handleChunk;
-const parseMovi = async ({ iterator, maxOffset, state, }) => {
+const parseMovi = async ({ maxOffset, state, }) => {
     if ((0, may_skip_video_data_1.maySkipVideoData)({
         state,
     }) &&
@@ -91,6 +92,7 @@ const parseMovi = async ({ iterator, maxOffset, state, }) => {
             skipTo: maxOffset,
         };
     }
+    const { iterator } = state;
     if (iterator.bytesRemaining() < 8) {
         return {
             box: null,
@@ -107,7 +109,7 @@ const parseMovi = async ({ iterator, maxOffset, state, }) => {
             skipTo: null,
         };
     }
-    await (0, exports.handleChunk)({ iterator, state, ckId, ckSize });
+    await (0, exports.handleChunk)({ state, ckId, ckSize });
     // Discard added zeroes
     while (iterator.counter.getOffset() < maxOffset &&
         iterator.bytesRemaining() > 0) {

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

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

package/dist/{boxes → containers}/riff/parse-riff-body.js

@@ -3,17 +3,14 @@ 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 });
+const parseRiffBody = async (state) => {
+    if (state.videoSection.isInVideoSectionState(state.iterator) === 'in-section') {
+        const videoSec = await (0, parse_video_section_1.parseVideoSection)(state);
         return {
             skipTo: videoSec.skipTo,
         };
     }
-    const result = await (0, expect_riff_box_1.expectRiffBox)({
-        iterator,
-        state,
-    });
+    const result = await (0, expect_riff_box_1.expectRiffBox)(state);
     if (result.box !== null) {
         const structure = state.structure.getStructure();
         structure.boxes.push(result.box);

package/dist/{boxes → containers}/riff/parse-riff-box.d.ts

@@ -1,8 +1,6 @@
-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, state, }: {
-    iterator: BufferIterator;
+export declare const parseRiffBox: ({ size, id, state, }: {
     size: number;
     id: string;
     state: ParserState;

package/dist/{boxes → containers}/riff/parse-riff-box.js

@@ -2,16 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRiffBox = void 0;
 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_strh_1 = require("./parse-strh");
-const parseRiffBox = ({ iterator, size, id, state, }) => {
-    if (id === 'fmt') {
-        return Promise.resolve((0, parse_fmt_box_1.parseFmtBox)({ iterator, size, state }));
-    }
+const parseRiffBox = ({ size, id, state, }) => {
+    const { iterator } = state;
     if (id === 'LIST') {
-        return (0, parse_list_box_1.parseListBox)({ iterator, size, state });
+        return (0, parse_list_box_1.parseListBox)({ size, state });
     }
     if (id === 'ISFT') {
         return Promise.resolve((0, parse_isft_1.parseIsft)({ iterator, size }));

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

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

package/dist/{boxes → containers}/riff/parse-riff-header.js

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

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

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

package/dist/{boxes → containers}/riff/parse-riff.js

@@ -3,13 +3,10 @@ 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 }));
+const parseRiff = (state) => {
+    if (state.iterator.counter.getOffset() === 0) {
+        return Promise.resolve((0, parse_riff_header_1.parseRiffHeader)(state));
     }
-    return (0, parse_riff_body_1.parseRiffBody)({
-        iterator,
-        state,
-    });
+    return (0, parse_riff_body_1.parseRiffBody)(state);
 };
 exports.parseRiff = parseRiff;

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

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

package/dist/{boxes → containers}/riff/parse-video-section.js

@@ -4,10 +4,9 @@ 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 parseVideoSection = (state) => {
     const videoSection = state.videoSection.getVideoSection();
     const movi = (0, parse_movi_1.parseMovi)({
-        iterator,
         maxOffset: videoSection.start + videoSection.size,
         state,
     });

package/dist/{boxes → containers}/riff/riff-box.d.ts

@@ -1,12 +1,3 @@
-export type WaveFormatBox = {
-    type: 'wave-format-box';
-    formatTag: 1;
-    numberOfChannels: number;
-    sampleRate: number;
-    blockAlign: number;
-    byteRate: number;
-    bitsPerSample: number;
-};
 export type ListBox = {
     type: 'list-box';
     listType: string;
@@ -81,4 +72,8 @@ export type IsftBox = {
     type: 'isft-box';
     software: string;
 };
-export type RiffBox = RiffRegularBox | WaveFormatBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | IsftBox;
+export type RiffBox = RiffRegularBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | IsftBox;
+export type RiffStructure = {
+    type: 'riff';
+    boxes: RiffBox[];
+};

package/dist/containers/riff/riff-box.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{boxes → containers}/riff/traversal.d.ts

@@ -1,5 +1,4 @@
-import type { RiffStructure } from '../../parse-result';
-import type { AvihBox, ListBox, RiffBox, StrhBox } from './riff-box';
+import type { AvihBox, ListBox, RiffBox, RiffStructure, 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;

package/dist/containers/transport-stream/boxes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{boxes → containers}/transport-stream/parse-packet.d.ts

@@ -1,7 +1,5 @@
-import type { BufferIterator } from '../../buffer-iterator';
 import type { ParserState } from '../../state/parser-state';
 import type { TransportStreamBox } from './boxes';
-export declare const parsePacket: ({ iterator, parserState, }: {
-    iterator: BufferIterator;
+export declare const parsePacket: ({ parserState, }: {
     parserState: ParserState;
 }) => Promise<TransportStreamBox | null>;

package/dist/{boxes → containers}/transport-stream/parse-packet.js

@@ -6,7 +6,8 @@ const parse_pes_1 = require("./parse-pes");
 const parse_pmt_1 = require("./parse-pmt");
 const parse_stream_packet_1 = require("./parse-stream-packet");
 const traversal_1 = require("./traversal");
-const parsePacket = async ({ iterator, parserState, }) => {
+const parsePacket = async ({ parserState, }) => {
+    const { iterator } = parserState;
     const offset = iterator.counter.getOffset();
     const syncByte = iterator.getUint8();
     if (syncByte !== 0x47) {
@@ -66,7 +67,6 @@ const parsePacket = async ({ iterator, parserState, }) => {
     const stream = (0, traversal_1.getStreamForId)(structure, programId);
     if (stream) {
         await (0, parse_stream_packet_1.parseStream)({
-            iterator,
             transportStreamEntry: stream,
             state: parserState,
             programId,

package/dist/{boxes → containers}/transport-stream/parse-stream-packet.d.ts

@@ -1,9 +1,7 @@
-import type { BufferIterator } from '../../buffer-iterator';
 import type { TransportStreamStructure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
 import type { TransportStreamEntry } from './parse-pmt';
-export declare const parseStream: ({ iterator, transportStreamEntry, state, programId, structure, }: {
-    iterator: BufferIterator;
+export declare const parseStream: ({ transportStreamEntry, state, programId, structure, }: {
     transportStreamEntry: TransportStreamEntry;
     state: ParserState;
     programId: number;

package/dist/{boxes → containers}/transport-stream/parse-stream-packet.js

@@ -86,7 +86,8 @@ const parseAvcStream = async ({ restOfPacket, transportStreamEntry, programId, s
         offset,
     });
 };
-const parseStream = ({ iterator, transportStreamEntry, state, programId, structure, }) => {
+const parseStream = ({ transportStreamEntry, state, programId, structure, }) => {
+    const { iterator } = state;
     const restOfPacket = (0, discard_rest_of_packet_1.getRestOfPacket)(iterator);
     if (transportStreamEntry.streamType === 27) {
         return parseAvcStream({

package/dist/containers/transport-stream/parse-transport-stream.d.ts

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

package/dist/{boxes → containers}/transport-stream/parse-transport-stream.js

@@ -3,26 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTransportStream = void 0;
 const parse_packet_1 = require("./parse-packet");
 const process_stream_buffers_1 = require("./process-stream-buffers");
-const parseTransportStream = async ({ iterator, state, }) => {
+const parseTransportStream = async (state) => {
     const structure = state.structure.getStructure();
     if (structure.type !== 'transport-stream') {
         throw new Error('Invalid structure type');
     }
-    const continueParsing = () => {
-        return (0, exports.parseTransportStream)({
-            iterator,
-            state,
-        });
-    };
+    const { iterator } = state;
     if (iterator.bytesRemaining() < 188) {
         return Promise.resolve({
-            status: 'incomplete',
-            continueParsing,
             skipTo: null,
         });
     }
     const packet = await (0, parse_packet_1.parsePacket)({
-        iterator,
         parserState: state,
     });
     if (packet) {
@@ -35,8 +27,6 @@ const parseTransportStream = async ({ iterator, state, }) => {
         });
     }
     return Promise.resolve({
-        status: 'incomplete',
-        continueParsing,
         skipTo: null,
     });
 };

package/dist/containers/wav/get-duration-from-wav.d.ts

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

package/dist/containers/wav/get-duration-from-wav.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDurationFromWav = exports.getDurationFromWav = void 0;
+const getDurationFromWav = (state) => {
+    const structure = state.structure.getStructure();
+    if (structure.type !== 'wav') {
+        throw new Error('Expected wav structure');
+    }
+    const fmt = structure.boxes.find((b) => b.type === 'wav-fmt');
+    if (!fmt) {
+        throw new Error('Expected fmt box');
+    }
+    const dataBox = structure.boxes.find((b) => b.type === 'wav-data');
+    if (!dataBox) {
+        throw new Error('Expected data box');
+    }
+    const durationInSeconds = dataBox.dataSize / (fmt.sampleRate * fmt.blockAlign);
+    return durationInSeconds;
+};
+exports.getDurationFromWav = getDurationFromWav;
+const hasDurationFromWav = (state) => {
+    try {
+        return (0, exports.getDurationFromWav)(state);
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.hasDurationFromWav = hasDurationFromWav;

package/dist/containers/wav/get-metadata-from-wav.d.ts

@@ -0,0 +1,3 @@
+import type { MetadataEntry } from '../../metadata/get-metadata';
+import type { WavStructure } from './types';
+export declare const getMetadataFromWav: (structure: WavStructure) => MetadataEntry[] | null;

package/dist/containers/wav/get-metadata-from-wav.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataFromWav = void 0;
+const getMetadataFromWav = (structure) => {
+    const list = structure.boxes.find((b) => b.type === 'wav-list');
+    if (!list) {
+        return null;
+    }
+    return list.metadata;
+};
+exports.getMetadataFromWav = getMetadataFromWav;

package/dist/containers/wav/parse-data.d.ts

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