@remotion/media-parser 4.0.249 → 4.0.251

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

@@ -1,61 +1,32 @@
 "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 (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,
-            state,
-            structure,
-        });
-        return Promise.resolve({
-            status: 'done',
-        });
-    }
-    const continueParsing = () => {
-        return (0, exports.parseTransportStream)({
-            iterator,
-            state,
-            streamBuffers,
-            fields,
-            nextPesHeaderStore,
-        });
-    };
-    if ((0, has_all_info_1.hasAllInfo)({
-        fields,
-        state,
-    })) {
-        return Promise.resolve({
-            status: 'done',
-        });
-    }
+    const { iterator } = state;
     if (iterator.bytesRemaining() < 188) {
         return Promise.resolve({
-            status: 'incomplete',
-            continueParsing,
             skipTo: null,
         });
     }
     const packet = await (0, parse_packet_1.parsePacket)({
-        iterator,
-        structure,
-        streamBuffers,
         parserState: state,
-        nextPesHeaderStore,
     });
     if (packet) {
         structure.boxes.push(packet);
     }
+    if (iterator.bytesRemaining() === 0) {
+        await (0, process_stream_buffers_1.processFinalStreamBuffers)({
+            state,
+            structure,
+        });
+    }
     return Promise.resolve({
-        status: 'incomplete',
-        continueParsing,
         skipTo: null,
     });
 };

package/dist/{boxes → containers}/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 → containers}/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/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>;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseData = void 0;
+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.structure.getStructure().boxes.push(box);
+    state.callbacks.tracks.setIsDone();
+    state.videoSection.setVideoSection({
+        size: ckSize,
+        start: iterator.counter.getOffset(),
+    });
+    if ((0, may_skip_video_data_1.maySkipVideoData)({ state })) {
+        return Promise.resolve({
+            skipTo: iterator.counter.getOffset() + ckSize,
+        });
+    }
+    return Promise.resolve({ skipTo: 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.structure.getStructure().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({ skipTo: 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.structure.getStructure().boxes.push(header);
+    return Promise.resolve({ skipTo: 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,17 @@
+"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.structure.getStructure().boxes.push(id3Box);
+    return Promise.resolve({
+        skipTo: 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.structure.getStructure().boxes.push(wavList);
+    box.expectNoMoreBytes();
+    return Promise.resolve({ skipTo: 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,37 @@
+"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.structure.getStructure();
+    if (structure.type !== 'wav') {
+        throw new Error('Expected wav structure');
+    }
+    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 { skipTo: 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,
@@ -109,6 +110,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/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/containers/webm/parse-webm-header.js

@@ -0,0 +1,53 @@
+"use strict";
+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 (state) => {
+    const structure = state.structure.getStructure();
+    if (structure.type !== 'matroska') {
+        throw new Error('Invalid structure type');
+    }
+    const { iterator } = state;
+    const isInsideSegment = state.webm.isInsideSegment(iterator);
+    const isInsideCluster = state.webm.isInsideCluster(iterator);
+    const results = await (0, segments_1.expectSegment)({
+        state,
+        isInsideSegment,
+    });
+    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/containers/webm/segments.d.ts

@@ -0,0 +1,9 @@
+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: ({ state, isInsideSegment, }: {
+    state: ParserState;
+    isInsideSegment: SegmentSection | null;
+}) => Promise<MatroskaSegment | null>;

package/dist/containers/webm/segments.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectSegment = void 0;
+/* eslint-disable @typescript-eslint/no-use-before-define */
+const log_1 = require("../../log");
+const parse_ebml_1 = require("./parse-ebml");
+const all_segments_1 = require("./segments/all-segments");
+const expectSegment = async ({ state, isInsideSegment, }) => {
+    var _a;
+    const { iterator } = state;
+    if (iterator.bytesRemaining() === 0) {
+        throw new Error('has no bytes');
+    }
+    const offset = iterator.counter.getOffset();
+    const { returnToCheckpoint } = iterator.startCheckpoint();
+    const segmentId = iterator.getMatroskaSegmentId();
+    if (segmentId === null) {
+        returnToCheckpoint();
+        return null;
+    }
+    const offsetBeforeVInt = iterator.counter.getOffset();
+    const size = iterator.getVint();
+    const offsetAfterVInt = iterator.counter.getOffset();
+    if (size === null) {
+        returnToCheckpoint();
+        return null;
+    }
+    const bytesRemainingNow = iterator.bytesRemaining();
+    log_1.Log.trace(state.logLevel, 'Segment ID:', (_a = all_segments_1.ebmlMap[segmentId]) === null || _a === void 0 ? void 0 : _a.name, 'Size:' + size, bytesRemainingNow);
+    if (segmentId === all_segments_1.matroskaElements.Segment) {
+        state.webm.addSegment({
+            start: offset,
+            size,
+        });
+        const newSegment = {
+            type: 'Segment',
+            minVintWidth: offsetAfterVInt - offsetBeforeVInt,
+            value: [],
+        };
+        return newSegment;
+    }
+    if (segmentId === all_segments_1.matroskaElements.Cluster) {
+        if (isInsideSegment === null) {
+            throw new Error('Expected to be inside segment');
+        }
+        state.webm.addCluster({
+            start: offset,
+            size,
+            segment: isInsideSegment.index,
+        });
+        const newSegment = {
+            type: 'Cluster',
+            minVintWidth: offsetAfterVInt - offsetBeforeVInt,
+            value: [],
+        };
+        return newSegment;
+    }
+    if (bytesRemainingNow < size) {
+        returnToCheckpoint();
+        return null;
+    }
+    const segment = await parseSegment({
+        segmentId,
+        length: size,
+        state,
+        headerReadSoFar: iterator.counter.getOffset() - offset,
+    });
+    return segment;
+};
+exports.expectSegment = expectSegment;
+const parseSegment = async ({ segmentId, length, state, headerReadSoFar, }) => {
+    if (length < 0) {
+        throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
+    }
+    state.iterator.counter.decrement(headerReadSoFar);
+    const offset = state.iterator.counter.getOffset();
+    const ebml = await (0, parse_ebml_1.parseEbml)(state);
+    const remapped = await (0, parse_ebml_1.postprocessEbml)({ offset, ebml, state });
+    return remapped;
+};