@remotion/media-parser 4.0.250 → 4.0.252

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/{boxes → containers}/transport-stream/adts-header.js

@@ -32,6 +32,7 @@ const readAdtsHeader = (buffer) => {
         audioObjectType,
         sampleRate,
         channelConfiguration,
+        codecPrivate: null,
     });
     iterator.getBits(1); // originality
     iterator.getBits(1); // home

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/get-tracks.js

@@ -4,7 +4,7 @@ exports.hasAllTracksFromTransportStream = exports.getTracksFromTransportStream =
 const truthy_1 = require("../../truthy");
 const traversal_1 = require("./traversal");
 const getTracksFromTransportStream = (parserState) => {
-    const structure = parserState.structure.getStructure();
+    const structure = parserState.getTsStructure();
     const programMapTable = (0, traversal_1.findProgramMapTableOrThrow)(structure);
     const parserTracks = parserState.callbacks.tracks.getTracks();
     const mapped = programMapTable.streams

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) {
@@ -45,7 +46,7 @@ const parsePacket = async ({ iterator, parserState, }) => {
     if (read === 188) {
         return Promise.resolve(null);
     }
-    const structure = parserState.structure.getStructure();
+    const structure = parserState.getTsStructure();
     const pat = structure.boxes.find((b) => b.type === 'transport-stream-pmt-box');
     const isPes = payloadUnitStartIndicator && (pat === null || pat === void 0 ? void 0 : pat.streams.find((e) => e.pid === programId));
     if (isPes) {
@@ -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,13 @@ 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 structure = state.structure.getStructure();
-    if (structure.type !== 'transport-stream') {
-        throw new Error('Invalid structure type');
-    }
-    const continueParsing = () => {
-        return (0, exports.parseTransportStream)({
-            iterator,
-            state,
-        });
-    };
+const parseTransportStream = async (state) => {
+    const structure = state.getTsStructure();
+    const { iterator } = state;
     if (iterator.bytesRemaining() < 188) {
-        return Promise.resolve({
-            status: 'incomplete',
-            continueParsing,
-            skipTo: null,
-        });
+        return Promise.resolve(null);
     }
     const packet = await (0, parse_packet_1.parsePacket)({
-        iterator,
         parserState: state,
     });
     if (packet) {
@@ -34,10 +21,6 @@ const parseTransportStream = async ({ iterator, state, }) => {
             structure,
         });
     }
-    return Promise.resolve({
-        status: 'incomplete',
-        continueParsing,
-        skipTo: null,
-    });
+    return Promise.resolve(null);
 };
 exports.parseTransportStream = parseTransportStream;

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

@@ -31,7 +31,7 @@ const processStreamBuffer = async ({ streamBuffer, state, programId, structure,
         const tracksRegistered = state.callbacks.tracks.getTracks().length;
         const { streams } = (0, traversal_1.findProgramMapTableOrThrow)(structure);
         if (streams.length === tracksRegistered) {
-            state.callbacks.tracks.setIsDone();
+            state.callbacks.tracks.setIsDone(state.logLevel);
         }
     }
 };

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,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasDurationFromWav = exports.getDurationFromWav = void 0;
+const getDurationFromWav = (state) => {
+    const structure = state.getWavStructure();
+    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>;

package/dist/containers/wav/parse-data.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseData = void 0;
+const skip_1 = require("../../skip");
+const may_skip_video_data_1 = require("../../state/may-skip-video-data");
+const parseData = ({ state, }) => {
+    const { iterator } = state;
+    const ckSize = iterator.getUint32Le(); // chunkSize
+    const box = {
+        type: 'wav-data',
+        dataSize: ckSize,
+    };
+    state.getWavStructure().boxes.push(box);
+    state.callbacks.tracks.setIsDone(state.logLevel);
+    state.videoSection.setVideoSection({
+        size: ckSize,
+        start: iterator.counter.getOffset(),
+    });
+    if ((0, may_skip_video_data_1.maySkipVideoData)({ state })) {
+        // Skipping only in query mode
+        return Promise.resolve((0, skip_1.makeSkip)(iterator.counter.getOffset() + ckSize));
+    }
+    return Promise.resolve(null);
+};
+exports.parseData = parseData;

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

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

package/dist/containers/wav/parse-fmt.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFmt = void 0;
+const register_track_1 = require("../../register-track");
+const parseFmt = async ({ state, }) => {
+    const { iterator } = state;
+    const ckSize = iterator.getUint32Le(); // chunkSize
+    const box = iterator.startBox(ckSize);
+    const audioFormat = iterator.getUint16Le();
+    if (audioFormat !== 1) {
+        throw new Error(`Only supporting WAVE with PCM audio format, but got ${audioFormat}`);
+    }
+    const numberOfChannels = iterator.getUint16Le();
+    const sampleRate = iterator.getUint32Le();
+    const byteRate = iterator.getUint32Le();
+    const blockAlign = iterator.getUint16Le();
+    const bitsPerSample = iterator.getUint16Le();
+    const format = bitsPerSample === 16
+        ? 'pcm-s16'
+        : bitsPerSample === 32
+            ? 'pcm-s32'
+            : bitsPerSample === 24
+                ? 'pcm-s24'
+                : null;
+    if (format === null) {
+        throw new Error(`Unsupported bits per sample: ${bitsPerSample}`);
+    }
+    const wavHeader = {
+        bitsPerSample,
+        blockAlign,
+        byteRate,
+        numberOfChannels,
+        sampleRate,
+        type: 'wav-fmt',
+    };
+    state.getWavStructure().boxes.push(wavHeader);
+    await (0, register_track_1.registerTrack)({
+        state,
+        track: {
+            type: 'audio',
+            codec: format,
+            codecPrivate: null,
+            description: undefined,
+            codecWithoutConfig: format,
+            numberOfChannels,
+            sampleRate,
+            timescale: 1000000,
+            trackId: 0,
+            trakBox: null,
+        },
+        container: 'wav',
+    });
+    box.expectNoMoreBytes();
+    return Promise.resolve(null);
+};
+exports.parseFmt = parseFmt;

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

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

package/dist/containers/wav/parse-header.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHeader = void 0;
+const parseHeader = ({ state, }) => {
+    const fileSize = state.iterator.getUint32Le();
+    const fileType = state.iterator.getByteString(4, false);
+    if (fileType !== 'WAVE') {
+        throw new Error(`Expected WAVE, got ${fileType}`);
+    }
+    const header = {
+        type: 'wav-header',
+        fileSize,
+    };
+    state.getWavStructure().boxes.push(header);
+    return Promise.resolve(null);
+};
+exports.parseHeader = parseHeader;

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

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

package/dist/containers/wav/parse-id3.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseId3 = void 0;
+// non-standard, we discard it in favor of LIST boxes
+const parseId3 = ({ state, }) => {
+    const { iterator } = state;
+    const id3Size = iterator.getUint32Le();
+    iterator.discard(id3Size);
+    const id3Box = {
+        type: 'wav-id3',
+    };
+    state.getWavStructure().boxes.push(id3Box);
+    return Promise.resolve(null);
+};
+exports.parseId3 = parseId3;

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

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

package/dist/containers/wav/parse-list.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseList = void 0;
+const parseList = ({ state, }) => {
+    const { iterator } = state;
+    const ckSize = iterator.getUint32Le(); // chunkSize
+    const box = iterator.startBox(ckSize);
+    const startOffset = iterator.counter.getOffset();
+    const type = iterator.getByteString(4, false);
+    if (type !== 'INFO') {
+        throw new Error(`Only supporting LIST INFO, but got ${type}`);
+    }
+    const metadata = [];
+    while (iterator.counter.getOffset() < startOffset + ckSize) {
+        const key = iterator.getByteString(4, false);
+        const size = iterator.getUint32Le();
+        const value = iterator.getByteString(size, true);
+        metadata.push({
+            key,
+            trackId: null,
+            value,
+        });
+    }
+    const wavList = {
+        type: 'wav-list',
+        metadata,
+    };
+    state.getWavStructure().boxes.push(wavList);
+    box.expectNoMoreBytes();
+    return Promise.resolve(null);
+};
+exports.parseList = parseList;

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

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

package/dist/containers/wav/parse-video-section.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVideoSection = void 0;
+const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
+const parseVideoSection = async ({ state, }) => {
+    const { iterator } = state;
+    const structure = state.getWavStructure();
+    const videoSection = state.videoSection.getVideoSection();
+    const maxOffset = videoSection.start + videoSection.size;
+    const maxRead = maxOffset - iterator.counter.getOffset();
+    const offset = iterator.counter.getOffset();
+    const fmtBox = structure.boxes.find((box) => box.type === 'wav-fmt');
+    if (!fmtBox) {
+        throw new Error('Expected fmt box');
+    }
+    const secondsToRead = 1;
+    const toRead = Math.min(maxRead, fmtBox.sampleRate * fmtBox.blockAlign * secondsToRead);
+    const duration = toRead / (fmtBox.sampleRate * fmtBox.blockAlign);
+    const timestamp = (offset - videoSection.start) / (fmtBox.sampleRate * fmtBox.blockAlign);
+    const data = iterator.getSlice(toRead);
+    await state.callbacks.onAudioSample(0, (0, convert_audio_or_video_sample_1.convertAudioOrVideoSampleToWebCodecsTimestamps)({
+        cts: timestamp,
+        dts: timestamp,
+        data,
+        duration,
+        timestamp,
+        trackId: 0,
+        type: 'key',
+        offset,
+        timescale: 1000000,
+    }, 1));
+    return null;
+};
+exports.parseVideoSection = parseVideoSection;

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

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

package/dist/containers/wav/parse-wav.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWav = void 0;
+const log_1 = require("../../log");
+const parse_data_1 = require("./parse-data");
+const parse_fmt_1 = require("./parse-fmt");
+const parse_header_1 = require("./parse-header");
+const parse_id3_1 = require("./parse-id3");
+const parse_list_1 = require("./parse-list");
+const parse_video_section_1 = require("./parse-video-section");
+const parseWav = (state) => {
+    const { iterator } = state;
+    const insideVideoSection = state.videoSection.isInVideoSectionState(iterator);
+    if (insideVideoSection === 'in-section') {
+        return (0, parse_video_section_1.parseVideoSection)({ state });
+    }
+    const type = iterator.getByteString(4, false);
+    log_1.Log.trace(state.logLevel, `Processing box type ${type}`);
+    if (type === 'RIFF') {
+        return (0, parse_header_1.parseHeader)({ state });
+    }
+    if (type === 'fmt') {
+        return (0, parse_fmt_1.parseFmt)({ state });
+    }
+    if (type === 'data') {
+        return (0, parse_data_1.parseData)({ state });
+    }
+    if (type === 'LIST') {
+        return (0, parse_list_1.parseList)({ state });
+    }
+    if (type === 'id3') {
+        return (0, parse_id3_1.parseId3)({ state });
+    }
+    throw new Error(`Unknown WAV box type ${type}`);
+};
+exports.parseWav = parseWav;

package/dist/containers/wav/types.d.ts

@@ -0,0 +1,30 @@
+import type { MetadataEntry } from '../../metadata/get-metadata';
+export type WavHeader = {
+    type: 'wav-header';
+    fileSize: number;
+};
+export type WavFmt = {
+    type: 'wav-fmt';
+    numberOfChannels: number;
+    sampleRate: number;
+    byteRate: number;
+    blockAlign: number;
+    bitsPerSample: number;
+};
+export type WavList = {
+    type: 'wav-list';
+    metadata: MetadataEntry[];
+};
+export type WavId3 = {
+    type: 'wav-id3';
+};
+export type WavData = {
+    type: 'wav-data';
+    dataSize: number;
+};
+type WavBox = WavHeader | WavFmt | WavList | WavId3 | WavData;
+export type WavStructure = {
+    type: 'wav';
+    boxes: WavBox[];
+};
+export {};

package/dist/containers/wav/types.js

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

package/dist/{boxes → containers}/webm/parse-ebml.d.ts

@@ -1,10 +1,9 @@
-import { type BufferIterator } from '../../buffer-iterator';
 import type { ParserState } from '../../state/parser-state';
 import type { PossibleEbml } from './segments/all-segments';
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
-export declare const parseEbml: (iterator: BufferIterator, state: ParserState) => Promise<Prettify<PossibleEbml>>;
+export declare const parseEbml: (state: ParserState) => Promise<Prettify<PossibleEbml>>;
 export declare const postprocessEbml: ({ offset, ebml, state, }: {
     offset: number;
     ebml: Prettify<PossibleEbml>;

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

@@ -5,7 +5,8 @@ const register_track_1 = require("../../register-track");
 const get_sample_from_block_1 = require("./get-sample-from-block");
 const make_track_1 = require("./make-track");
 const all_segments_1 = require("./segments/all-segments");
-const parseEbml = async (iterator, state) => {
+const parseEbml = async (state) => {
+    const { iterator } = state;
     const hex = iterator.getMatroskaSegmentId();
     if (hex === null) {
         throw new Error('Not enough bytes left to parse EBML - this should not happen');
@@ -83,7 +84,7 @@ const parseEbml = async (iterator, state) => {
                 break;
             }
             const offset = iterator.counter.getOffset();
-            const value = await (0, exports.parseEbml)(iterator, state);
+            const value = await (0, exports.parseEbml)(state);
             // eslint-disable-next-line @typescript-eslint/no-use-before-define
             const remapped = await (0, exports.postprocessEbml)({
                 offset,
@@ -110,7 +111,7 @@ const postprocessEbml = async ({ offset, ebml, state, }) => {
         state.webm.setTimescale(ebml.value.value);
     }
     if (ebml.type === 'Tracks') {
-        state.callbacks.tracks.setIsDone();
+        state.callbacks.tracks.setIsDone(state.logLevel);
     }
     if (ebml.type === 'TrackEntry') {
         state.webm.onTrackEntrySegment(ebml);

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

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

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

@@ -3,22 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWebm = void 0;
 const segments_1 = require("./segments");
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
-const parseWebm = async ({ iterator, state, }) => {
-    const structure = state.structure.getStructure();
-    if (structure.type !== 'matroska') {
-        throw new Error('Invalid structure type');
-    }
+const parseWebm = async (state) => {
+    const structure = state.getMatroskaStructure();
+    const { iterator } = state;
     const isInsideSegment = state.webm.isInsideSegment(iterator);
     const isInsideCluster = state.webm.isInsideCluster(iterator);
     const results = await (0, segments_1.expectSegment)({
-        iterator,
         state,
         isInsideSegment,
     });
     if (results === null) {
-        return {
-            skipTo: null,
-        };
+        return null;
     }
     if (isInsideCluster) {
         const segments = structure.boxes.filter((box) => box.type === 'Segment');
@@ -46,8 +41,6 @@ const parseWebm = async ({ iterator, state, }) => {
     else {
         structure.boxes.push(results);
     }
-    return {
-        skipTo: null,
-    };
+    return null;
 };
 exports.parseWebm = parseWebm;

package/dist/{boxes → containers}/webm/segments.d.ts

@@ -1,11 +1,9 @@
-import type { BufferIterator } from '../../buffer-iterator';
 import type { ParserState } from '../../state/parser-state';
 import type { SegmentSection } from '../../state/webm';
 import { type PossibleEbml, type TrackEntry } from './segments/all-segments';
 export type MatroskaSegment = PossibleEbml;
 export type OnTrackEntrySegment = (trackEntry: TrackEntry) => void;
-export declare const expectSegment: ({ iterator, state, isInsideSegment, }: {
-    iterator: BufferIterator;
+export declare const expectSegment: ({ state, isInsideSegment, }: {
     state: ParserState;
     isInsideSegment: SegmentSection | null;
 }) => Promise<MatroskaSegment | null>;