@remotion/media-parser 4.0.234 → 4.0.236

package/dist/boxes/riff/parse-box.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRiff = exports.parseRiffBody = void 0;
+const get_tracks_1 = require("../../get-tracks");
+const has_all_info_1 = require("../../has-all-info");
 const register_track_1 = require("../../register-track");
 const expect_riff_box_1 = require("./expect-riff-box");
 const get_tracks_from_avi_1 = require("./get-tracks-from-avi");
@@ -22,10 +24,8 @@ const continueAfterRiffBoxResult = ({ result, structure, iterator, maxOffset, op
             skipTo: null,
         });
     }
-    if (result.type === 'complete') {
-        if (result.box) {
-            structure.boxes.push(result.box);
-        }
+    if (result.type === 'complete' && result.box) {
+        structure.boxes.push(result.box);
     }
     return (0, exports.parseRiffBody)({ iterator, maxOffset, options, structure });
 };
@@ -37,6 +37,22 @@ const parseRiffBody = async ({ iterator, structure, maxOffset, options, }) => {
             options,
             structure,
         });
+        if (result.type === 'complete' && result.skipTo !== null) {
+            return {
+                status: 'incomplete',
+                skipTo: result.skipTo,
+                segments: structure,
+                continueParsing() {
+                    return Promise.resolve(continueAfterRiffBoxResult({
+                        iterator,
+                        maxOffset,
+                        options,
+                        result,
+                        structure,
+                    }));
+                },
+            };
+        }
         if (result.type === 'incomplete') {
             return {
                 status: 'incomplete',
@@ -57,6 +73,17 @@ const parseRiffBody = async ({ iterator, structure, maxOffset, options, }) => {
             continue;
         }
         structure.boxes.push(result.box);
+        // When parsing an AVI
+        if (result.box.type === 'list-box' && result.box.listType === 'hdrl') {
+            const tracks = (0, get_tracks_1.getTracks)(structure, options.parserState);
+            if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER)) {
+                options.parserState.tracks.setIsDone();
+            }
+        }
+        // When parsing a WAV
+        if (result.box.type === 'wave-format-box') {
+            options.parserState.tracks.setIsDone();
+        }
         if (result.box.type === 'strf-box-video' ||
             result.box.type === 'strf-box-audio') {
             const strh = (0, traversal_1.getStrhBox)(structure.boxes);
@@ -96,7 +123,7 @@ const parseRiffBody = async ({ iterator, structure, maxOffset, options, }) => {
     };
 };
 exports.parseRiffBody = parseRiffBody;
-const parseRiff = ({ iterator, options, }) => {
+const parseRiff = ({ iterator, options, fields, }) => {
     const structure = { type: 'riff', boxes: [] };
     const riff = iterator.getByteString(4);
     if (riff !== 'RIFF') {
@@ -108,6 +135,12 @@ const parseRiff = ({ iterator, options, }) => {
         throw new Error(`File type ${fileType} not supported`);
     }
     structure.boxes.push({ type: 'riff-header', fileSize: size, fileType });
+    if ((0, has_all_info_1.hasAllInfo)({ fields, structure, state: options.parserState })) {
+        return Promise.resolve({
+            status: 'done',
+            segments: structure,
+        });
+    }
     return (0, exports.parseRiffBody)({ iterator, structure, maxOffset: Infinity, options });
 };
 exports.parseRiff = parseRiff;

package/dist/boxes/riff/parse-isft.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { IsftBox } from './riff-box';
+export declare const parseIsft: ({ iterator, size, }: {
+    iterator: BufferIterator;
+    size: number;
+}) => IsftBox;

package/dist/boxes/riff/parse-isft.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIsft = void 0;
+const parseIsft = ({ iterator, size, }) => {
+    const { expectNoMoreBytes } = iterator.startBox(size);
+    const software = iterator.getByteString(size - 1);
+    const last = iterator.getUint8();
+    if (last !== 0) {
+        throw new Error(`Expected 0 byte, got ${last}`);
+    }
+    expectNoMoreBytes();
+    return {
+        type: 'isft-box',
+        software,
+    };
+};
+exports.parseIsft = parseIsft;

package/dist/boxes/riff/parse-movi.js

@@ -36,6 +36,7 @@ const handleChunk = async ({ iterator, options, structure, ckId, ckSize, }) => {
         const ppsProfile = infos.find((i) => i.type === 'avc-pps');
         if (avcProfile && ppsProfile) {
             await options.parserState.onProfile({ pps: ppsProfile, sps: avcProfile });
+            options.parserState.tracks.setIsDone();
         }
         await options.parserState.onVideoSample(trackId, {
             cts: timestamp,
@@ -46,27 +47,26 @@ const handleChunk = async ({ iterator, options, structure, ckId, ckSize, }) => {
             trackId,
             type: keyOrDelta.type === 'keyframe' ? 'key' : 'delta',
         });
+        return;
     }
-    else {
-        const audioChunk = ckId.match(/^([0-9]{2})wb$/);
-        if (audioChunk) {
-            const trackId = parseInt(audioChunk[1], 10);
-            const strh = getStrhForIndex(structure, trackId);
-            const samplesPerSecond = strh.rate / strh.scale;
-            const nthSample = options.parserState.getSamplesForTrack(trackId);
-            const timeInSec = nthSample / samplesPerSecond;
-            const timestamp = timeInSec * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE;
-            const duration = (1 / samplesPerSecond) * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE;
-            await options.parserState.onAudioSample(trackId, {
-                cts: timestamp,
-                dts: timestamp,
-                data: iterator.getSlice(ckSize),
-                duration,
-                timestamp,
-                trackId,
-                type: 'key',
-            });
-        }
+    const audioChunk = ckId.match(/^([0-9]{2})wb$/);
+    if (audioChunk) {
+        const trackId = parseInt(audioChunk[1], 10);
+        const strh = getStrhForIndex(structure, trackId);
+        const samplesPerSecond = strh.rate / strh.scale;
+        const nthSample = options.parserState.getSamplesForTrack(trackId);
+        const timeInSec = nthSample / samplesPerSecond;
+        const timestamp = timeInSec * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE;
+        const duration = (1 / samplesPerSecond) * timescale_1.MEDIA_PARSER_RIFF_TIMESCALE;
+        await options.parserState.onAudioSample(trackId, {
+            cts: timestamp,
+            dts: timestamp,
+            data: iterator.getSlice(ckSize),
+            duration,
+            timestamp,
+            trackId,
+            type: 'key',
+        });
     }
 };
 exports.handleChunk = handleChunk;
@@ -82,6 +82,16 @@ const parseMovi = async ({ iterator, maxOffset, options, structure, }) => {
         }
         const ckId = iterator.getByteString(4);
         const ckSize = iterator.getUint32Le();
+        if (options.parserState.maySkipVideoData() &&
+            options.parserState.getAvcProfile()) {
+            return {
+                type: 'complete',
+                box: {
+                    type: 'movi-box',
+                },
+                skipTo: maxOffset,
+            };
+        }
         if (iterator.bytesRemaining() < ckSize) {
             iterator.counter.decrement(8);
             return {
@@ -107,6 +117,7 @@ const parseMovi = async ({ iterator, maxOffset, options, structure, }) => {
             box: {
                 type: 'movi-box',
             },
+            skipTo: null,
         };
     }
     if (iterator.counter.getOffset() > maxOffset) {

package/dist/boxes/riff/parse-riff-box.js

@@ -3,6 +3,7 @@ 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_strf_1 = require("./parse-strf");
 const parse_strh_1 = require("./parse-strh");
@@ -13,6 +14,9 @@ const parseRiffBox = ({ iterator, size, id, boxes, options, }) => {
     if (id === 'LIST') {
         return (0, parse_list_box_1.parseListBox)({ iterator, size, options });
     }
+    if (id === 'ISFT') {
+        return Promise.resolve((0, parse_isft_1.parseIsft)({ iterator, size }));
+    }
     if (id === 'avih') {
         return Promise.resolve((0, parse_avih_1.parseAvih)({ iterator, size }));
     }

package/dist/boxes/riff/riff-box.d.ts

@@ -78,4 +78,8 @@ export type RiffHeader = {
 export type MoviBox = {
     type: 'movi-box';
 };
-export type RiffBox = RiffRegularBox | WaveFormatBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | MoviBox;
+export type IsftBox = {
+    type: 'isft-box';
+    software: string;
+};
+export type RiffBox = RiffRegularBox | WaveFormatBox | RiffHeader | ListBox | AvihBox | StrhBox | StrfBoxVideo | StrfBoxAudio | MoviBox | IsftBox;

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

@@ -63,7 +63,8 @@ const parseEbml = async (iterator, parserContext) => {
             value: '0x' +
                 [...iterator.getSlice(size)]
                     .map((b) => b.toString(16).padStart(2, '0'))
-                    .join(''),
+                    .join('')
+                    .replace(new RegExp('^' + hex), ''),
             minVintWidth,
         };
     }

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

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

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

@@ -20,7 +20,7 @@ const continueAfterMatroskaResult = (result, structure) => {
     };
 };
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
-const parseWebm = async (counter, parserContext) => {
+const parseWebm = async ({ counter, parserContext, fields, }) => {
     const structure = { type: 'matroska', boxes: [] };
     const results = await (0, parse_children_1.expectChildren)({
         iterator: counter,
@@ -28,6 +28,8 @@ const parseWebm = async (counter, parserContext) => {
         children: structure.boxes,
         parserContext,
         startOffset: counter.counter.getOffset(),
+        fields,
+        topLevelStructure: structure,
     });
     return continueAfterMatroskaResult(results, structure);
 };

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

@@ -404,6 +404,10 @@ export declare const titleType: {
     readonly name: "Title";
     readonly type: "string";
 };
+export declare const tagTrackUidType: {
+    readonly name: "TagTrackUID";
+    readonly type: "hex-string";
+};
 export declare const samplingFrequency: {
     readonly name: "SamplingFrequency";
     readonly type: "float";
@@ -438,7 +442,7 @@ export declare const flagLacing: {
 };
 export declare const tagSegment: {
     readonly name: "Tag";
-    readonly type: "uint8array";
+    readonly type: "children";
 };
 export declare const tags: {
     readonly name: "Tags";
@@ -560,6 +564,22 @@ export declare const cluster: {
     readonly name: "Cluster";
     readonly type: "children";
 };
+export declare const targetsType: {
+    readonly name: "Targets";
+    readonly type: "children";
+};
+export declare const simpleTagType: {
+    readonly name: "SimpleTag";
+    readonly type: "children";
+};
+export declare const tagNameType: {
+    readonly name: "TagName";
+    readonly type: "string";
+};
+export declare const tagStringType: {
+    readonly name: "TagString";
+    readonly type: "string";
+};
 export type CodecIdSegment = EbmlParsed<typeof codecID>;
 export type ColourSegment = EbmlParsed<typeof color>;
 export type TransferCharacteristicsSegment = EbmlParsed<typeof transferCharacteristics>;
@@ -611,6 +631,22 @@ export declare const ebmlMap: {
         name: "DocType";
         type: "string";
     };
+    readonly "0x63c0": {
+        readonly name: "Targets";
+        readonly type: "children";
+    };
+    readonly "0x67c8": {
+        readonly name: "SimpleTag";
+        readonly type: "children";
+    };
+    readonly "0x45a3": {
+        readonly name: "TagName";
+        readonly type: "string";
+    };
+    readonly "0x4487": {
+        readonly name: "TagString";
+        readonly type: "string";
+    };
     readonly "0x4287": {
         name: "DocTypeVersion";
         type: "uint";
@@ -707,6 +743,10 @@ export declare const ebmlMap: {
         readonly name: "SliceDuration";
         readonly type: "uint8array";
     };
+    readonly "0x63c5": {
+        readonly name: "TagTrackUID";
+        readonly type: "hex-string";
+    };
     readonly "0x114d9b74": {
         readonly name: "SeekHead";
         readonly type: "children";
@@ -809,7 +849,7 @@ export declare const ebmlMap: {
     };
     readonly "0x7373": {
         readonly name: "Tag";
-        readonly type: "uint8array";
+        readonly type: "children";
     };
     readonly "0xd7": {
         readonly name: "TrackNumber";

package/dist/boxes/webm/segments/all-segments.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultDuration = exports.language = exports.ChromaSitingVert = exports.ChromaSitingHorz = exports.range = exports.primaries = exports.matrixCoefficients = exports.transferCharacteristics = exports.color = exports.trackUID = exports.trackNumber = exports.tags = exports.tagSegment = exports.flagLacing = exports.displayHeight = exports.displayWidth = exports.bitDepth = exports.interlaced = exports.alphaMode = exports.channels = exports.samplingFrequency = exports.titleType = exports.infoType = exports.writingApp = exports.timestampScale = exports.duration = exports.muxingApp = exports.heightType = exports.widthType = exports.trackType = exports.codecID = exports.voidHeader = exports.seekHead = exports.seek = exports.seekPosition = exports.seekId = exports.matroskaHeader = exports.docTypeReadVersion = exports.docTypeVersion = exports.docType = exports.ebmlMaxSizeLength = exports.ebmlMaxIdLength = exports.ebmlReadVersion = exports.ebmlVersion = exports.getIdForName = exports.getSegmentName = exports.knownIdsWithThreeLength = exports.knownIdsWithTwoLength = exports.knownIdsWithOneLength = exports.matroskaElements = void 0;
-exports.incrementOffsetAndChildren = exports.ebmlMap = exports.cluster = exports.segment = exports.blockGroup = exports.simpleBlock = exports.block = exports.timestampEntry = exports.tracks = exports.trackEntry = exports.trackTimestampScale = exports.codecName = exports.blockElement = exports.referenceBlock = exports.flagDefault = exports.videoSegment = exports.audioSegment = exports.maxBlockAdditionIdSegment = exports.blockAdditionsSegment = exports.codecPrivate = void 0;
+exports.language = exports.ChromaSitingVert = exports.ChromaSitingHorz = exports.range = exports.primaries = exports.matrixCoefficients = exports.transferCharacteristics = exports.color = exports.trackUID = exports.trackNumber = exports.tags = exports.tagSegment = exports.flagLacing = exports.displayHeight = exports.displayWidth = exports.bitDepth = exports.interlaced = exports.alphaMode = exports.channels = exports.samplingFrequency = exports.tagTrackUidType = exports.titleType = exports.infoType = exports.writingApp = exports.timestampScale = exports.duration = exports.muxingApp = exports.heightType = exports.widthType = exports.trackType = exports.codecID = exports.voidHeader = exports.seekHead = exports.seek = exports.seekPosition = exports.seekId = exports.matroskaHeader = exports.docTypeReadVersion = exports.docTypeVersion = exports.docType = exports.ebmlMaxSizeLength = exports.ebmlMaxIdLength = exports.ebmlReadVersion = exports.ebmlVersion = exports.getIdForName = exports.getSegmentName = exports.knownIdsWithThreeLength = exports.knownIdsWithTwoLength = exports.knownIdsWithOneLength = exports.matroskaElements = void 0;
+exports.incrementOffsetAndChildren = exports.ebmlMap = exports.tagStringType = exports.tagNameType = exports.simpleTagType = exports.targetsType = exports.cluster = exports.segment = exports.blockGroup = exports.simpleBlock = exports.block = exports.timestampEntry = exports.tracks = exports.trackEntry = exports.trackTimestampScale = exports.codecName = exports.blockElement = exports.referenceBlock = exports.flagDefault = exports.videoSegment = exports.audioSegment = exports.maxBlockAdditionIdSegment = exports.blockAdditionsSegment = exports.codecPrivate = exports.defaultDuration = void 0;
 exports.matroskaElements = {
     Header: '0x1a45dfa3',
     EBMLMaxIDLength: '0x42f2',
@@ -387,6 +387,10 @@ exports.titleType = {
     name: 'Title',
     type: 'string',
 };
+exports.tagTrackUidType = {
+    name: 'TagTrackUID',
+    type: 'hex-string',
+};
 exports.samplingFrequency = {
     name: 'SamplingFrequency',
     type: 'float',
@@ -421,7 +425,7 @@ exports.flagLacing = {
 };
 exports.tagSegment = {
     name: 'Tag',
-    type: 'uint8array',
+    type: 'children',
 };
 exports.tags = {
     name: 'Tags',
@@ -543,9 +547,29 @@ exports.cluster = {
     name: 'Cluster',
     type: 'children',
 };
+exports.targetsType = {
+    name: 'Targets',
+    type: 'children',
+};
+exports.simpleTagType = {
+    name: 'SimpleTag',
+    type: 'children',
+};
+exports.tagNameType = {
+    name: 'TagName',
+    type: 'string',
+};
+exports.tagStringType = {
+    name: 'TagString',
+    type: 'string',
+};
 exports.ebmlMap = {
     [exports.matroskaElements.Header]: exports.matroskaHeader,
     [exports.matroskaElements.DocType]: exports.docType,
+    [exports.matroskaElements.Targets]: exports.targetsType,
+    [exports.matroskaElements.SimpleTag]: exports.simpleTagType,
+    [exports.matroskaElements.TagName]: exports.tagNameType,
+    [exports.matroskaElements.TagString]: exports.tagStringType,
     [exports.matroskaElements.DocTypeVersion]: exports.docTypeVersion,
     [exports.matroskaElements.DocTypeReadVersion]: exports.docTypeReadVersion,
     [exports.matroskaElements.EBMLVersion]: exports.ebmlVersion,
@@ -615,6 +639,7 @@ exports.ebmlMap = {
         name: 'SliceDuration',
         type: 'uint8array',
     },
+    [exports.matroskaElements.TagTrackUID]: exports.tagTrackUidType,
     [exports.matroskaElements.SeekHead]: exports.seekHead,
     [exports.matroskaElements.Seek]: exports.seek,
     [exports.matroskaElements.SeekID]: exports.seekId,

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

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

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

@@ -1,10 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectChildren = exports.expectAndProcessSegment = void 0;
+const has_all_info_1 = require("../../../has-all-info");
 const segments_1 = require("../segments");
-const processParseResult = ({ parseResult, children, }) => {
+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, structure: topLevelStructure })) {
+            return {
+                status: 'done',
+                segment: parseResult.segment,
+            };
+        }
+        if (parseResult.segment.type === 'Tracks') {
+            state.tracks.setIsDone();
+        }
     }
     if (parseResult.status === 'incomplete') {
         // No need to decrement because expectSegment already does it
@@ -16,6 +26,9 @@ const processParseResult = ({ parseResult, children, }) => {
                 return processParseResult({
                     children,
                     parseResult: newParseResult,
+                    state,
+                    fields,
+                    topLevelStructure,
                 });
             },
         };
@@ -25,20 +38,25 @@ const processParseResult = ({ parseResult, children, }) => {
         segment: parseResult.segment,
     };
 };
-const expectAndProcessSegment = async ({ iterator, parserContext, offset, children, }) => {
+const expectAndProcessSegment = async ({ iterator, parserContext, offset, children, fields, topLevelStructure, }) => {
     const segment = await (0, segments_1.expectSegment)({
         iterator,
         parserContext,
         offset,
         children,
+        fields,
+        topLevelStructure,
     });
     return processParseResult({
         children,
         parseResult: segment,
+        state: parserContext.parserState,
+        fields,
+        topLevelStructure,
     });
 };
 exports.expectAndProcessSegment = expectAndProcessSegment;
-const continueAfterSegmentResult = async ({ result, length, children, parserContext, iterator, startOffset, }) => {
+const continueAfterSegmentResult = async ({ result, length, children, parserContext, iterator, startOffset, fields, topLevelStructure, }) => {
     if (result.status === 'done') {
         throw new Error('Should not continue after done');
     }
@@ -54,6 +72,8 @@ const continueAfterSegmentResult = async ({ result, length, children, parserCont
                     length,
                     parserContext,
                     startOffset,
+                    fields,
+                    topLevelStructure,
                 });
             },
             skipTo: null,
@@ -69,12 +89,14 @@ const continueAfterSegmentResult = async ({ result, length, children, parserCont
                 length,
                 parserContext,
                 startOffset,
+                fields,
+                topLevelStructure,
             });
         },
         skipTo: null,
     };
 };
-const expectChildren = async ({ iterator, length, children, parserContext, startOffset, }) => {
+const expectChildren = async ({ iterator, length, children, parserContext, startOffset, fields, topLevelStructure, }) => {
     while (iterator.counter.getOffset() < startOffset + length) {
         if (iterator.bytesRemaining() === 0) {
             break;
@@ -85,7 +107,18 @@ const expectChildren = async ({ iterator, length, children, parserContext, start
             parserContext,
             offset: currentOffset,
             children,
+            fields,
+            topLevelStructure,
         });
+        if ((0, has_all_info_1.hasAllInfo)({
+            fields,
+            state: parserContext.parserState,
+            structure: topLevelStructure,
+        })) {
+            return {
+                status: 'done',
+            };
+        }
         if (child.status === 'incomplete') {
             return {
                 status: 'incomplete',
@@ -97,6 +130,8 @@ const expectChildren = async ({ iterator, length, children, parserContext, start
                         length: length - (currentOffset - startOffset),
                         parserContext,
                         startOffset: currentOffset,
+                        fields,
+                        topLevelStructure,
                     });
                 },
                 skipTo: null,

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

@@ -1,12 +1,15 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { ExpectSegmentParseResult } from '../../parse-result';
+import type { Options, ParseMediaFields } from '../../options';
+import type { ExpectSegmentParseResult, MatroskaStructure } from '../../parse-result';
 import type { ParserContext } from '../../parser-context';
 import { type PossibleEbml, type TrackEntry } from './segments/all-segments';
 export type MatroskaSegment = PossibleEbml;
 export type OnTrackEntrySegment = (trackEntry: TrackEntry) => void;
-export declare const expectSegment: ({ iterator, parserContext, offset, children, }: {
+export declare const expectSegment: ({ iterator, parserContext, offset, children, fields, topLevelStructure, }: {
     iterator: BufferIterator;
     parserContext: ParserContext;
     offset: number;
     children: PossibleEbml[];
+    fields: Options<ParseMediaFields>;
+    topLevelStructure: MatroskaStructure;
 }) => Promise<ExpectSegmentParseResult>;

package/dist/boxes/webm/segments.js

@@ -27,7 +27,7 @@ const continueAfterMatroskaParseResult = async ({ result, iterator, parserContex
         status: 'incomplete',
     };
 };
-const expectSegment = async ({ iterator, parserContext, offset, children, }) => {
+const expectSegment = async ({ iterator, parserContext, offset, children, fields, topLevelStructure, }) => {
     iterator.counter.decrement(iterator.counter.getOffset() - offset);
     if (iterator.bytesRemaining() === 0) {
         return {
@@ -38,6 +38,8 @@ const expectSegment = async ({ iterator, parserContext, offset, children, }) =>
                     parserContext,
                     offset,
                     children,
+                    fields,
+                    topLevelStructure,
                 });
             },
             segment: null,
@@ -54,6 +56,8 @@ const expectSegment = async ({ iterator, parserContext, offset, children, }) =>
                     parserContext,
                     offset,
                     children,
+                    fields,
+                    topLevelStructure,
                 });
             },
             segment: null,
@@ -67,7 +71,14 @@ const expectSegment = async ({ iterator, parserContext, offset, children, }) =>
         return {
             status: 'incomplete',
             continueParsing: () => {
-                return (0, exports.expectSegment)({ iterator, parserContext, offset, children });
+                return (0, exports.expectSegment)({
+                    iterator,
+                    parserContext,
+                    offset,
+                    children,
+                    fields,
+                    topLevelStructure,
+                });
             },
             segment: null,
         };
@@ -85,6 +96,8 @@ const expectSegment = async ({ iterator, parserContext, offset, children, }) =>
             children: newSegment.value,
             parserContext,
             startOffset: iterator.counter.getOffset(),
+            fields,
+            topLevelStructure,
         });
         if (main.status === 'incomplete') {
             return {
@@ -112,7 +125,14 @@ const expectSegment = async ({ iterator, parserContext, offset, children, }) =>
             status: 'incomplete',
             segment: null,
             continueParsing: () => {
-                return (0, exports.expectSegment)({ iterator, parserContext, offset, children });
+                return (0, exports.expectSegment)({
+                    iterator,
+                    parserContext,
+                    offset,
+                    children,
+                    fields,
+                    topLevelStructure,
+                });
             },
         };
     }

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

@@ -22,6 +22,7 @@ export declare const getTracksSegment: (segment: MainSegment) => {
     value: import("./segments/all-segments").PossibleEbml[];
     minVintWidth: number | null;
 } | null;
+export declare const getTrackWithUid: (segment: MainSegment, trackUid: string) => number | null;
 export declare const getTimescaleSegment: (segment: MainSegment) => TimestampScaleSegment | null;
 export declare const getVideoSegment: (track: TrackEntry) => VideoSegment | null;
 export declare const getAudioSegment: (track: TrackEntry) => AudioSegment | null;