@remotion/media-parser 4.0.248 → 4.0.250

package/dist/boxes/transport-stream/get-tracks.d.ts

@@ -1,5 +1,4 @@
-import type { TransportStreamStructure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
 import type { AllTracks } from '../riff/get-tracks-from-avi';
-export declare const getTracksFromTransportStream: (structure: TransportStreamStructure, parserState: ParserState) => AllTracks;
-export declare const hasAllTracksFromTransportStream: (structure: TransportStreamStructure, parserState: ParserState) => boolean;
+export declare const getTracksFromTransportStream: (parserState: ParserState) => AllTracks;
+export declare const hasAllTracksFromTransportStream: (parserState: ParserState) => boolean;

package/dist/boxes/transport-stream/get-tracks.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasAllTracksFromTransportStream = exports.getTracksFromTransportStream = void 0;
 const truthy_1 = require("../../truthy");
 const traversal_1 = require("./traversal");
-const getTracksFromTransportStream = (structure, parserState) => {
+const getTracksFromTransportStream = (parserState) => {
+    const structure = parserState.structure.getStructure();
     const programMapTable = (0, traversal_1.findProgramMapTableOrThrow)(structure);
     const parserTracks = parserState.callbacks.tracks.getTracks();
     const mapped = programMapTable.streams
@@ -21,9 +22,9 @@ const getTracksFromTransportStream = (structure, parserState) => {
     };
 };
 exports.getTracksFromTransportStream = getTracksFromTransportStream;
-const hasAllTracksFromTransportStream = (structure, parserState) => {
+const hasAllTracksFromTransportStream = (parserState) => {
     try {
-        (0, exports.getTracksFromTransportStream)(structure, parserState);
+        (0, exports.getTracksFromTransportStream)(parserState);
         return true;
     }
     catch (_a) {

package/dist/boxes/transport-stream/parse-packet.d.ts

@@ -1,13 +1,7 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { TransportStreamStructure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
 import type { TransportStreamBox } from './boxes';
-import type { NextPesHeaderStore } from './next-pes-header-store';
-import { type StreamBufferMap } from './process-stream-buffers';
-export declare const parsePacket: ({ iterator, structure, streamBuffers, parserState, nextPesHeaderStore, }: {
+export declare const parsePacket: ({ iterator, parserState, }: {
     iterator: BufferIterator;
-    structure: TransportStreamStructure;
-    streamBuffers: StreamBufferMap;
     parserState: ParserState;
-    nextPesHeaderStore: NextPesHeaderStore;
 }) => Promise<TransportStreamBox | null>;

package/dist/boxes/transport-stream/parse-packet.js

@@ -6,7 +6,7 @@ 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, structure, streamBuffers, parserState, nextPesHeaderStore, }) => {
+const parsePacket = async ({ iterator, parserState, }) => {
     const offset = iterator.counter.getOffset();
     const syncByte = iterator.getUint8();
     if (syncByte !== 0x47) {
@@ -45,11 +45,12 @@ const parsePacket = async ({ iterator, structure, streamBuffers, parserState, ne
     if (read === 188) {
         return Promise.resolve(null);
     }
+    const structure = parserState.structure.getStructure();
     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) {
         const packetPes = (0, parse_pes_1.parsePes)(iterator);
-        nextPesHeaderStore.setNextPesHeader(packetPes);
+        parserState.transportStream.nextPesHeaderStore.setNextPesHeader(packetPes);
     }
     else if (payloadUnitStartIndicator === 1) {
         iterator.getUint8(); // pointerField
@@ -67,8 +68,6 @@ const parsePacket = async ({ iterator, structure, streamBuffers, parserState, ne
         await (0, parse_stream_packet_1.parseStream)({
             iterator,
             transportStreamEntry: stream,
-            streamBuffers,
-            nextPesHeader: nextPesHeaderStore.getNextPesHeader(),
             state: parserState,
             programId,
             structure,

package/dist/boxes/transport-stream/parse-stream-packet.d.ts

@@ -1,15 +1,11 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { TransportStreamStructure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
-import type { PacketPes } from './parse-pes';
 import type { TransportStreamEntry } from './parse-pmt';
-import { type StreamBufferMap } from './process-stream-buffers';
-export declare const parseStream: ({ iterator, transportStreamEntry, streamBuffers, state, programId, structure, nextPesHeader, }: {
+export declare const parseStream: ({ iterator, transportStreamEntry, state, programId, structure, }: {
     iterator: BufferIterator;
     transportStreamEntry: TransportStreamEntry;
-    streamBuffers: StreamBufferMap;
     state: ParserState;
     programId: number;
     structure: TransportStreamStructure;
-    nextPesHeader: PacketPes;
 }) => Promise<void>;

package/dist/boxes/transport-stream/parse-stream-packet.js

@@ -6,13 +6,14 @@ const adts_header_1 = require("./adts-header");
 const discard_rest_of_packet_1 = require("./discard-rest-of-packet");
 const find_separator_1 = require("./find-separator");
 const process_stream_buffers_1 = require("./process-stream-buffers");
-const parseAdtsStream = async ({ restOfPacket, transportStreamEntry, streamBuffers, nextPesHeader, state, structure, offset, }) => {
+const parseAdtsStream = async ({ restOfPacket, transportStreamEntry, state, structure, offset, }) => {
     var _a, _b;
+    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
     const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
     if (!streamBuffer) {
         streamBuffers.set(transportStreamEntry.pid, {
             buffer: restOfPacket,
-            pesHeader: nextPesHeader,
+            pesHeader: nextPesHeader.getNextPesHeader(),
             offset,
         });
         return;
@@ -35,13 +36,14 @@ const parseAdtsStream = async ({ restOfPacket, transportStreamEntry, streamBuffe
         const rest = restOfPacket.slice(bytesToTake);
         streamBuffers.set(transportStreamEntry.pid, {
             buffer: rest,
-            pesHeader: nextPesHeader,
+            pesHeader: nextPesHeader.getNextPesHeader(),
             offset,
         });
     }
 };
-const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffers, nextPesHeader, programId, state, structure, offset, }) => {
+const parseAvcStream = async ({ restOfPacket, transportStreamEntry, programId, state, structure, offset, }) => {
     const indexOfSeparator = (0, find_separator_1.findNextSeparator)(restOfPacket, transportStreamEntry);
+    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
     const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
     if (indexOfSeparator === -1) {
         if (streamBuffer) {
@@ -52,7 +54,7 @@ const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffer
             return;
         }
         streamBuffers.set(programId, {
-            pesHeader: nextPesHeader,
+            pesHeader: nextPesHeader.getNextPesHeader(),
             buffer: restOfPacket,
             offset,
         });
@@ -69,7 +71,7 @@ const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffer
         });
         const rest = restOfPacket.slice(indexOfSeparator);
         streamBuffers.set(programId, {
-            pesHeader: nextPesHeader,
+            pesHeader: nextPesHeader.getNextPesHeader(),
             buffer: rest,
             offset,
         });
@@ -79,19 +81,17 @@ const parseAvcStream = async ({ restOfPacket, transportStreamEntry, streamBuffer
         throw new Error('No stream buffer found but new separator is not at the beginning');
     }
     streamBuffers.set(programId, {
-        pesHeader: nextPesHeader,
+        pesHeader: nextPesHeader.getNextPesHeader(),
         buffer: restOfPacket.slice(indexOfSeparator),
         offset,
     });
 };
-const parseStream = ({ iterator, transportStreamEntry, streamBuffers, state, programId, structure, nextPesHeader, }) => {
+const parseStream = ({ iterator, transportStreamEntry, state, programId, structure, }) => {
     const restOfPacket = (0, discard_rest_of_packet_1.getRestOfPacket)(iterator);
     if (transportStreamEntry.streamType === 27) {
         return parseAvcStream({
             restOfPacket,
             transportStreamEntry,
-            streamBuffers,
-            nextPesHeader,
             state,
             programId,
             structure,
@@ -102,8 +102,6 @@ const parseStream = ({ iterator, transportStreamEntry, streamBuffers, state, pro
         return parseAdtsStream({
             restOfPacket,
             transportStreamEntry,
-            streamBuffers,
-            nextPesHeader,
             state,
             structure,
             offset: iterator.counter.getOffset(),

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

@@ -1,13 +1,7 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
 import type { ParseResult } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
-import type { NextPesHeaderStore } from './next-pes-header-store';
-import { type StreamBufferMap } from './process-stream-buffers';
-export declare const parseTransportStream: ({ iterator, state, streamBuffers, fields, nextPesHeaderStore, }: {
+export declare const parseTransportStream: ({ iterator, state, }: {
     iterator: BufferIterator;
     state: ParserState;
-    streamBuffers: StreamBufferMap;
-    fields: Options<ParseMediaFields>;
-    nextPesHeaderStore: NextPesHeaderStore;
 }) => Promise<ParseResult>;

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

@@ -1,72 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTransportStream = void 0;
-const has_all_info_1 = require("../../has-all-info");
 const parse_packet_1 = require("./parse-packet");
 const process_stream_buffers_1 = require("./process-stream-buffers");
-const parseTransportStream = async ({ iterator, state, streamBuffers, fields, nextPesHeaderStore, }) => {
+const parseTransportStream = async ({ iterator, state, }) => {
     const structure = state.structure.getStructure();
     if (structure.type !== 'transport-stream') {
         throw new Error('Invalid structure type');
     }
-    if (iterator.bytesRemaining() === 0) {
-        await (0, process_stream_buffers_1.processFinalStreamBuffers)({
-            streamBufferMap: streamBuffers,
+    const continueParsing = () => {
+        return (0, exports.parseTransportStream)({
+            iterator,
             state,
-            structure,
         });
+    };
+    if (iterator.bytesRemaining() < 188) {
         return Promise.resolve({
-            status: 'done',
-            segments: structure,
+            status: 'incomplete',
+            continueParsing,
+            skipTo: null,
         });
     }
-    while (true) {
-        if ((0, has_all_info_1.hasAllInfo)({
-            fields,
+    const packet = await (0, parse_packet_1.parsePacket)({
+        iterator,
+        parserState: state,
+    });
+    if (packet) {
+        structure.boxes.push(packet);
+    }
+    if (iterator.bytesRemaining() === 0) {
+        await (0, process_stream_buffers_1.processFinalStreamBuffers)({
             state,
-        })) {
-            break;
-        }
-        if (iterator.bytesRemaining() < 188) {
-            return Promise.resolve({
-                status: 'incomplete',
-                segments: structure,
-                skipTo: null,
-                continueParsing: () => {
-                    return (0, exports.parseTransportStream)({
-                        iterator,
-                        state,
-                        streamBuffers,
-                        fields,
-                        nextPesHeaderStore,
-                    });
-                },
-            });
-        }
-        const packet = await (0, parse_packet_1.parsePacket)({
-            iterator,
             structure,
-            streamBuffers,
-            parserState: state,
-            nextPesHeaderStore,
         });
-        if (packet) {
-            structure.boxes.push(packet);
-            break;
-        }
     }
     return Promise.resolve({
-        segments: structure,
         status: 'incomplete',
-        continueParsing() {
-            return (0, exports.parseTransportStream)({
-                iterator,
-                state,
-                streamBuffers,
-                fields,
-                nextPesHeaderStore,
-            });
-        },
+        continueParsing,
         skipTo: null,
     });
 };

package/dist/boxes/transport-stream/process-stream-buffers.d.ts

@@ -13,8 +13,7 @@ export declare const processStreamBuffer: ({ streamBuffer, state, programId, str
     programId: number;
     structure: TransportStreamStructure;
 }) => Promise<void>;
-export declare const processFinalStreamBuffers: ({ streamBufferMap, state, structure, }: {
-    streamBufferMap: StreamBufferMap;
+export declare const processFinalStreamBuffers: ({ state, structure, }: {
     state: ParserState;
     structure: TransportStreamStructure;
 }) => Promise<void>;

package/dist/boxes/transport-stream/process-stream-buffers.js

@@ -36,8 +36,8 @@ const processStreamBuffer = async ({ streamBuffer, state, programId, structure,
     }
 };
 exports.processStreamBuffer = processStreamBuffer;
-const processFinalStreamBuffers = async ({ streamBufferMap, state, structure, }) => {
-    for (const [programId, buffer] of streamBufferMap) {
+const processFinalStreamBuffers = async ({ state, structure, }) => {
+    for (const [programId, buffer] of state.transportStream.streamBuffers) {
         if (buffer.buffer.byteLength > 0) {
             await (0, exports.processStreamBuffer)({
                 streamBuffer: buffer,
@@ -45,7 +45,7 @@ const processFinalStreamBuffers = async ({ streamBufferMap, state, structure, })
                 programId,
                 structure,
             });
-            streamBufferMap.delete(programId);
+            state.transportStream.streamBuffers.delete(programId);
         }
     }
 };

package/dist/boxes/webm/parse-ebml.js

@@ -109,6 +109,9 @@ const postprocessEbml = async ({ offset, ebml, state, }) => {
     if (ebml.type === 'TimestampScale') {
         state.webm.setTimescale(ebml.value.value);
     }
+    if (ebml.type === 'Tracks') {
+        state.callbacks.tracks.setIsDone();
+    }
     if (ebml.type === 'TrackEntry') {
         state.webm.onTrackEntrySegment(ebml);
         const track = (0, make_track_1.getTrack)({

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

@@ -1,9 +1,7 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
 import type { ParseResult } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
-export declare const parseWebm: ({ counter, state, fields, }: {
-    counter: BufferIterator;
+export declare const parseWebm: ({ iterator, state, }: {
+    iterator: BufferIterator;
     state: ParserState;
-    fields: Options<ParseMediaFields>;
 }) => Promise<ParseResult>;

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

@@ -1,37 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWebm = void 0;
-const parse_children_1 = require("./segments/parse-children");
-const continueAfterMatroskaResult = (result, structure) => {
-    if (result.status === 'done') {
-        return {
-            status: 'done',
-        };
-    }
-    return {
-        status: 'incomplete',
-        continueParsing: async () => {
-            const newResult = await result.continueParsing();
-            return continueAfterMatroskaResult(newResult, structure);
-        },
-        skipTo: null,
-    };
-};
+const segments_1 = require("./segments");
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
-const parseWebm = async ({ counter, state, fields, }) => {
+const parseWebm = async ({ iterator, state, }) => {
     const structure = state.structure.getStructure();
     if (structure.type !== 'matroska') {
         throw new Error('Invalid structure type');
     }
-    const results = await (0, parse_children_1.expectChildren)({
-        iterator: counter,
-        length: Infinity,
-        children: structure.boxes,
+    const isInsideSegment = state.webm.isInsideSegment(iterator);
+    const isInsideCluster = state.webm.isInsideCluster(iterator);
+    const results = await (0, segments_1.expectSegment)({
+        iterator,
         state,
-        startOffset: counter.counter.getOffset(),
-        fields,
-        topLevelStructure: structure,
+        isInsideSegment,
     });
-    return continueAfterMatroskaResult(results, structure);
+    if (results === null) {
+        return {
+            skipTo: null,
+        };
+    }
+    if (isInsideCluster) {
+        const segments = structure.boxes.filter((box) => box.type === 'Segment');
+        const segment = segments[isInsideCluster.segment];
+        if (!segment) {
+            throw new Error('Expected segment');
+        }
+        const clusters = segment.value.find((box) => box.type === 'Cluster');
+        if (!clusters) {
+            throw new Error('Expected cluster');
+        }
+        // let's not add it to the cluster
+        if (results.type !== 'Block' && results.type !== 'SimpleBlock') {
+            clusters.value.push(results);
+        }
+    }
+    else if (isInsideSegment) {
+        const segments = structure.boxes.filter((box) => box.type === 'Segment');
+        const segment = segments[isInsideSegment.index];
+        if (!segment) {
+            throw new Error('Expected segment');
+        }
+        segment.value.push(results);
+    }
+    else {
+        structure.boxes.push(results);
+    }
+    return {
+        skipTo: null,
+    };
 };
 exports.parseWebm = parseWebm;

package/dist/boxes/webm/segments/parse-children.d.ts

@@ -1,23 +1,9 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../../options';
-import type { ExpectSegmentParseResult, MatroskaParseResult, MatroskaStructure } from '../../../parse-result';
 import type { ParserState } from '../../../state/parser-state';
-import type { MatroskaSegment } from '../segments';
 import type { PossibleEbml } from './all-segments';
-export declare const expectAndProcessSegment: ({ iterator, state, offset, children, fields, topLevelStructure, }: {
-    iterator: BufferIterator;
-    state: ParserState;
-    offset: number;
-    children: PossibleEbml[];
-    fields: Options<ParseMediaFields>;
-    topLevelStructure: MatroskaStructure;
-}) => Promise<ExpectSegmentParseResult>;
-export declare const expectChildren: ({ iterator, length, children, state, startOffset, fields, topLevelStructure, }: {
+export declare const expectChildren: ({ iterator, length, state, startOffset, }: {
     iterator: BufferIterator;
     length: number;
-    children: MatroskaSegment[];
     state: ParserState;
     startOffset: number;
-    fields: Options<ParseMediaFields>;
-    topLevelStructure: MatroskaStructure;
-}) => Promise<MatroskaParseResult>;
+}) => Promise<PossibleEbml[]>;

package/dist/boxes/webm/segments/parse-children.js

@@ -1,144 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expectChildren = exports.expectAndProcessSegment = void 0;
-const has_all_info_1 = require("../../../has-all-info");
+exports.expectChildren = void 0;
 const segments_1 = require("../segments");
-const processParseResult = ({ parseResult, children, state, fields, topLevelStructure, }) => {
-    if (parseResult.segment && !children.includes(parseResult.segment)) {
-        children.push(parseResult.segment);
-        if ((0, has_all_info_1.hasAllInfo)({ fields, state })) {
-            return {
-                status: 'done',
-                segment: parseResult.segment,
-            };
-        }
-        if (parseResult.segment.type === 'Tracks') {
-            state.callbacks.tracks.setIsDone();
-        }
-    }
-    if (parseResult.status === 'incomplete') {
-        // No need to decrement because expectSegment already does it
-        return {
-            status: 'incomplete',
-            segment: parseResult.segment,
-            continueParsing: async () => {
-                const newParseResult = await parseResult.continueParsing();
-                return processParseResult({
-                    children,
-                    parseResult: newParseResult,
-                    state,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-        };
-    }
-    return {
-        status: 'done',
-        segment: parseResult.segment,
-    };
-};
-const expectAndProcessSegment = async ({ iterator, state, offset, children, fields, topLevelStructure, }) => {
-    const segment = await (0, segments_1.expectSegment)({
-        iterator,
-        state,
-        offset,
-        children,
-        fields,
-        topLevelStructure,
-    });
-    return processParseResult({
-        children,
-        parseResult: segment,
-        state,
-        fields,
-        topLevelStructure,
-    });
-};
-exports.expectAndProcessSegment = expectAndProcessSegment;
-const continueAfterSegmentResult = async ({ result, length, children, state, iterator, startOffset, fields, topLevelStructure, }) => {
-    if (result.status === 'done') {
-        throw new Error('Should not continue after done');
-    }
-    const segmentResult = await result.continueParsing();
-    if (segmentResult.status === 'done') {
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                // eslint-disable-next-line @typescript-eslint/no-use-before-define
-                return (0, exports.expectChildren)({
-                    children,
-                    iterator,
-                    length,
-                    state,
-                    startOffset,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            skipTo: null,
-        };
-    }
-    return {
-        status: 'incomplete',
-        continueParsing: () => {
-            return continueAfterSegmentResult({
-                result: segmentResult,
-                children,
-                iterator,
-                length,
-                state,
-                startOffset,
-                fields,
-                topLevelStructure,
-            });
-        },
-        skipTo: null,
-    };
-};
-const expectChildren = async ({ iterator, length, children, state, startOffset, fields, topLevelStructure, }) => {
+const expectChildren = async ({ iterator, length, state, startOffset, }) => {
+    const children = [];
     while (iterator.counter.getOffset() < startOffset + length) {
         if (iterator.bytesRemaining() === 0) {
             break;
         }
-        const currentOffset = iterator.counter.getOffset();
-        const child = await (0, exports.expectAndProcessSegment)({
+        const child = await (0, segments_1.expectSegment)({
             iterator,
             state,
-            offset: currentOffset,
-            children,
-            fields,
-            topLevelStructure,
         });
-        if ((0, has_all_info_1.hasAllInfo)({
-            fields,
-            state,
-        })) {
-            return {
-                status: 'done',
-            };
-        }
-        if (child.status === 'incomplete') {
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return continueAfterSegmentResult({
-                        result: child,
-                        children,
-                        iterator,
-                        length: length - (currentOffset - startOffset),
-                        state,
-                        startOffset: currentOffset,
-                        fields,
-                        topLevelStructure,
-                    });
-                },
-                skipTo: null,
-            };
+        if (child) {
+            children.push(child);
         }
     }
-    return {
-        status: 'done',
-    };
+    return children;
 };
 exports.expectChildren = expectChildren;

package/dist/boxes/webm/segments.d.ts

@@ -1,15 +1,11 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { Options, ParseMediaFields } from '../../options';
-import type { ExpectSegmentParseResult, MatroskaStructure } from '../../parse-result';
 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, offset, children, fields, topLevelStructure, }: {
+export declare const expectSegment: ({ iterator, state, isInsideSegment, }: {
     iterator: BufferIterator;
     state: ParserState;
-    offset: number;
-    children: PossibleEbml[];
-    fields: Options<ParseMediaFields>;
-    topLevelStructure: MatroskaStructure;
-}) => Promise<ExpectSegmentParseResult>;
+    isInsideSegment: SegmentSection | null;
+}) => Promise<MatroskaSegment | null>;