@remotion/media-parser 4.0.200 → 4.0.202

package/dist/boxes/iso-base-media/stsd/stco.d.ts

@@ -5,10 +5,11 @@ export interface StcoBox extends BaseBox {
     version: number;
     flags: number[];
     entryCount: number;
-    entries: number[];
+    entries: (number | bigint)[];
 }
-export declare const parseStco: ({ iterator, offset, size, }: {
+export declare const parseStco: ({ iterator, offset, size, mode64Bit, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
+    mode64Bit: boolean;
 }) => StcoBox;

package/dist/boxes/iso-base-media/stsd/stco.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStco = void 0;
-const parseStco = ({ iterator, offset, size, }) => {
+const parseStco = ({ iterator, offset, size, mode64Bit, }) => {
     const version = iterator.getUint8();
     if (version !== 0) {
         throw new Error(`Unsupported STSD version ${version}`);
@@ -14,7 +14,7 @@ const parseStco = ({ iterator, offset, size, }) => {
         if (bytesRemaining < 4) {
             break;
         }
-        entries.push(iterator.getUint32());
+        entries.push(mode64Bit ? iterator.getUint64() : iterator.getUint32());
     }
     iterator.discard(size - (iterator.counter.getOffset() - offset));
     return {

package/dist/boxes/iso-base-media/trak/trak.js

@@ -10,6 +10,7 @@ const parseTrak = async ({ data, size, offsetAtStart, options, }) => {
         initialBoxes: [],
         options,
         continueMdat: false,
+        littleEndian: false,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

package/dist/boxes/webm/av1-codec-private.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAv1PrivateData = void 0;
 const buffer_iterator_1 = require("../../buffer-iterator");
 const parseAv1PrivateData = (data, colrAtom) => {
-    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data);
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data, data.byteLength);
     iterator.startReadingBits();
     if (iterator.getBits(1) !== 1) {
         iterator.destroy();

package/dist/boxes/webm/bitstream/av1.js

@@ -50,6 +50,15 @@ const av1Bitstream = ({ stream, length, onVideoSample, trackNumber, context, tim
         : {
             type: 'av1-bitstream-unimplemented',
         };
+    if (segment.type === 'av1-bitstream-header') {
+        if (!size) {
+            throw new Error('Expected size');
+        }
+        const toSample = bytesReadSoFar + size;
+        stream.counter.decrement(stream.counter.getOffset() - address);
+        const header = stream.getSlice(toSample);
+        context.parserState.setAv1BitstreamHeaderSegment(segment, header);
+    }
     if (obuType === 6) {
         const head = context.parserState.getAv1BitstreamHeaderSegment();
         if (!head) {
@@ -80,7 +89,7 @@ const av1Bitstream = ({ stream, length, onVideoSample, trackNumber, context, tim
             }
         }
         onVideoSample(trackNumber, {
-            data: (0, combine_uint8array_1.combineUint8Arrays)(extraBytes, frame),
+            bytes: (0, combine_uint8array_1.combineUint8Arrays)(extraBytes, frame),
             timestamp: timecode + clusterTimestamp,
             duration: undefined,
             trackId: trackNumber,

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

@@ -1,2 +1,2 @@
-import type { TrackEntrySegment } from './segments/track-entry';
-export declare const getAudioDescription: (track: TrackEntrySegment) => undefined | Uint8Array;
+import type { TrackEntry } from './segments/all-segments';
+export declare const getAudioDescription: (track: TrackEntry) => undefined | Uint8Array;

package/dist/boxes/webm/description.js

@@ -5,7 +5,7 @@ const buffer_iterator_1 = require("../../buffer-iterator");
 const traversal_1 = require("../../traversal");
 const getAudioDescription = (track) => {
     const codec = (0, traversal_1.getCodecSegment)(track);
-    if (!codec || codec.codec !== 'A_VORBIS') {
+    if (!codec || codec.value !== 'A_VORBIS') {
         return undefined;
     }
     // how to parse vorbis private
@@ -44,7 +44,7 @@ const getAudioDescription = (track) => {
         throw new Error('Error parsing vorbis codec private');
     }
     const vorbisBooks = privateData.slice(offset);
-    const bufferIterator = (0, buffer_iterator_1.getArrayBufferIterator)(vorbisInfo.slice(0));
+    const bufferIterator = (0, buffer_iterator_1.getArrayBufferIterator)(vorbisInfo.slice(0), vorbisInfo.length);
     // type
     bufferIterator.getUint8();
     // vorbis

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

@@ -1,2 +1,2 @@
-export declare const measureEBMLVarInt: (value: number) => 1 | 2 | 3 | 4 | 5 | 6;
-export declare const getVariableInt: (value: number, width?: number) => Uint8Array;
+export declare const measureEBMLVarInt: (value: number) => 4 | 6 | 1 | 5 | 3 | 2;
+export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;

package/dist/boxes/webm/ebml.js

@@ -28,7 +28,8 @@ const measureEBMLVarInt = (value) => {
     throw new Error('EBML VINT size not supported ' + value);
 };
 exports.measureEBMLVarInt = measureEBMLVarInt;
-const getVariableInt = (value, width = (0, exports.measureEBMLVarInt)(value)) => {
+const getVariableInt = (value, minWidth) => {
+    const width = Math.max((0, exports.measureEBMLVarInt)(value), minWidth !== null && minWidth !== void 0 ? minWidth : 0);
     switch (width) {
         case 1:
             return new Uint8Array([(1 << 7) | value]);
@@ -65,6 +66,27 @@ const getVariableInt = (value, width = (0, exports.measureEBMLVarInt)(value)) =>
                 value >> 8,
                 value,
             ]);
+        case 7:
+            return new Uint8Array([
+                (1 << 1) | ((value / 2 ** 48) & 0x1),
+                (value / 2 ** 40) | 0,
+                (value / 2 ** 32) | 0,
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
+        case 8:
+            return new Uint8Array([
+                (1 << 0) | ((value / 2 ** 56) & 0x1),
+                (value / 2 ** 48) | 0,
+                (value / 2 ** 40) | 0,
+                (value / 2 ** 32) | 0,
+                value >> 24,
+                value >> 16,
+                value >> 8,
+                value,
+            ]);
         default:
             throw new Error('Bad EBML VINT size ' + width);
     }

package/dist/boxes/webm/get-ready-tracks.d.ts

@@ -1,3 +1,3 @@
 import type { Track } from '../../get-tracks';
-import type { MainSegment } from './segments/main';
+import type { MainSegment } from './segments/all-segments';
 export declare const getTracksFromMatroska: (segment: MainSegment, timescale: number) => Track[];

package/dist/boxes/webm/get-ready-tracks.js

@@ -9,11 +9,11 @@ const getTracksFromMatroska = (segment, timescale) => {
         throw new Error('No tracks segment');
     }
     const tracks = [];
-    for (const trackEntrySegment of tracksSegment.children) {
-        if (trackEntrySegment.type === 'crc32-segment') {
+    for (const trackEntrySegment of tracksSegment.value) {
+        if (trackEntrySegment.type === 'Crc32') {
             continue;
         }
-        if (trackEntrySegment.type !== 'track-entry-segment') {
+        if (trackEntrySegment.type !== 'TrackEntry') {
             throw new Error('Expected track entry segment');
         }
         const track = (0, get_track_1.getTrack)({

package/dist/boxes/webm/get-sample-from-block.d.ts

@@ -0,0 +1,17 @@
+import type { ParserContext } from '../../parser-context';
+import type { AudioSample, VideoSample } from '../../webcodec-sample-types';
+import type { BlockSegment, SimpleBlockSegment } from './segments/all-segments';
+type SampleResult = {
+    type: 'video-sample';
+    videoSample: VideoSample;
+} | {
+    type: 'audio-sample';
+    audioSample: AudioSample;
+} | {
+    type: 'partial-video-sample';
+    partialVideoSample: Omit<VideoSample, 'type'>;
+} | {
+    type: 'no-sample';
+};
+export declare const getSampleFromBlock: (ebml: BlockSegment | SimpleBlockSegment, parserContext: ParserContext, offset: number) => SampleResult;
+export {};

package/dist/boxes/webm/get-sample-from-block.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSampleFromBlock = void 0;
+const buffer_iterator_1 = require("../../buffer-iterator");
+const all_segments_1 = require("./segments/all-segments");
+const block_simple_block_flags_1 = require("./segments/block-simple-block-flags");
+const getSampleFromBlock = (ebml, parserContext, offset) => {
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(ebml.value, ebml.value.length);
+    const trackNumber = iterator.getVint();
+    if (trackNumber === null) {
+        throw new Error('Not enough data to get track number, should not happen');
+    }
+    const timecodeRelativeToCluster = iterator.getUint16();
+    const { keyframe } = (0, block_simple_block_flags_1.parseBlockFlags)(iterator, ebml.type === 'SimpleBlock'
+        ? all_segments_1.matroskaElements.SimpleBlock
+        : all_segments_1.matroskaElements.Block);
+    const { codec, trackTimescale } = parserContext.parserState.getTrackInfoByNumber(trackNumber);
+    const clusterOffset = parserContext.parserState.getTimestampOffsetForByteOffset(offset);
+    const timescale = parserContext.parserState.getTimescale();
+    if (clusterOffset === undefined) {
+        throw new Error('Could not find offset for byte offset ' + offset);
+    }
+    // https://github.com/hubblec4/Matroska-Chapters-Specs/blob/master/notes.md/#timestampscale
+    // The TimestampScale Element is used to calculate the Raw Timestamp of a Block. The timestamp is obtained by adding the Block's timestamp to the Cluster's Timestamp Element, and then multiplying that result by the TimestampScale. The result will be the Block's Raw Timestamp in nanoseconds.
+    const timecodeInNanoSeconds = (timecodeRelativeToCluster + clusterOffset) *
+        timescale *
+        (trackTimescale !== null && trackTimescale !== void 0 ? trackTimescale : 1);
+    // Timecode should be in microseconds
+    const timecodeInMicroseconds = timecodeInNanoSeconds / 1000;
+    if (!codec) {
+        throw new Error(`Could not find codec for track ${trackNumber}`);
+    }
+    const remainingNow = ebml.value.length - (iterator.counter.getOffset() - 0);
+    if (codec.startsWith('V_')) {
+        const partialVideoSample = {
+            data: iterator.getSlice(remainingNow),
+            cts: null,
+            dts: null,
+            duration: undefined,
+            trackId: trackNumber,
+            timestamp: timecodeInMicroseconds,
+        };
+        if (keyframe === null) {
+            iterator.destroy();
+            return {
+                type: 'partial-video-sample',
+                partialVideoSample,
+            };
+        }
+        const sample = {
+            ...partialVideoSample,
+            type: keyframe ? 'key' : 'delta',
+        };
+        iterator.destroy();
+        return {
+            type: 'video-sample',
+            videoSample: sample,
+        };
+    }
+    if (codec.startsWith('A_')) {
+        const audioSample = {
+            data: iterator.getSlice(remainingNow),
+            trackId: trackNumber,
+            timestamp: timecodeInMicroseconds,
+            type: 'key',
+        };
+        iterator.destroy();
+        return {
+            type: 'audio-sample',
+            audioSample,
+        };
+    }
+    iterator.destroy();
+    return {
+        type: 'no-sample',
+    };
+};
+exports.getSampleFromBlock = getSampleFromBlock;

package/dist/boxes/webm/get-track.d.ts

@@ -1,6 +1,6 @@
 import type { AudioTrack, VideoTrack } from '../../get-tracks';
-import type { TrackEntrySegment } from './segments/track-entry';
+import type { TrackEntry } from './segments/all-segments';
 export declare const getTrack: ({ timescale, track, }: {
     timescale: number;
-    track: TrackEntrySegment;
+    track: TrackEntry;
 }) => VideoTrack | AudioTrack | null;

package/dist/boxes/webm/get-track.js

@@ -6,12 +6,13 @@ const make_hvc1_codec_strings_1 = require("../../make-hvc1-codec-strings");
 const traversal_1 = require("../../traversal");
 const av1_codec_private_1 = require("./av1-codec-private");
 const description_1 = require("./description");
+const track_entry_1 = require("./segments/track-entry");
 const getDescription = (track) => {
     const codec = (0, traversal_1.getCodecSegment)(track);
     if (!codec) {
         return undefined;
     }
-    if (codec.codec === 'V_MPEG4/ISO/AVC' || codec.codec === 'V_MPEGH/ISO/HEVC') {
+    if (codec.value === 'V_MPEG4/ISO/AVC' || codec.value === 'V_MPEGH/ISO/HEVC') {
         const priv = (0, traversal_1.getPrivateData)(track);
         if (priv) {
             return priv;
@@ -20,49 +21,49 @@ const getDescription = (track) => {
     return undefined;
 };
 const getMatroskaVideoCodecString = ({ track, codecSegment: codec, }) => {
-    if (codec.codec === 'V_VP8') {
+    if (codec.value === 'V_VP8') {
         return 'vp8';
     }
-    if (codec.codec === 'V_VP9') {
+    if (codec.value === 'V_VP9') {
         const priv = (0, traversal_1.getPrivateData)(track);
         if (priv) {
             throw new Error('@remotion/media-parser cannot handle the private data for VP9. Do you have an example file you could send so we can implement it?');
         }
         return 'vp09.00.10.08';
     }
-    if (codec.codec === 'V_MPEG4/ISO/AVC') {
+    if (codec.value === 'V_MPEG4/ISO/AVC') {
         const priv = (0, traversal_1.getPrivateData)(track);
         if (priv) {
             return `avc1.${priv[1].toString(16).padStart(2, '0')}${priv[2].toString(16).padStart(2, '0')}${priv[3].toString(16).padStart(2, '0')}`;
         }
         throw new Error('Could not find a CodecPrivate field in TrackEntry');
     }
-    if (codec.codec === 'V_AV1') {
+    if (codec.value === 'V_AV1') {
         const priv = (0, traversal_1.getPrivateData)(track);
         if (!priv) {
             throw new Error('Expected private data in AV1 track');
         }
         return (0, av1_codec_private_1.parseAv1PrivateData)(priv, null);
     }
-    if (codec.codec === 'V_MPEGH/ISO/HEVC') {
+    if (codec.value === 'V_MPEGH/ISO/HEVC') {
         const priv = (0, traversal_1.getPrivateData)(track);
-        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv);
+        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv, priv.length);
         return 'hvc1.' + (0, make_hvc1_codec_strings_1.getHvc1CodecString)(iterator);
     }
-    throw new Error(`Unknown codec: ${codec.codec}`);
+    throw new Error(`Unknown codec: ${codec.value}`);
 };
 const getMatroskaAudioCodecString = (track) => {
     const codec = (0, traversal_1.getCodecSegment)(track);
     if (!codec) {
         throw new Error('Expected codec segment');
     }
-    if (codec.codec === 'A_OPUS') {
+    if (codec.value === 'A_OPUS') {
         return 'opus';
     }
-    if (codec.codec === 'A_VORBIS') {
+    if (codec.value === 'A_VORBIS') {
         return 'vorbis';
     }
-    if (codec.codec === 'A_PCM/INT/LIT') {
+    if (codec.value === 'A_PCM/INT/LIT') {
         // https://github.com/ietf-wg-cellar/matroska-specification/issues/142#issuecomment-330004950
         // Audio samples MUST be considered as signed values, except if the audio bit depth is 8 which MUST be interpreted as unsigned values.
         const bitDepth = (0, traversal_1.getBitDepth)(track);
@@ -74,9 +75,9 @@ const getMatroskaAudioCodecString = (track) => {
         }
         return 'pcm-s' + bitDepth;
     }
-    if (codec.codec === 'A_AAC') {
+    if (codec.value === 'A_AAC') {
         const priv = (0, traversal_1.getPrivateData)(track);
-        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv);
+        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv, priv.length);
         iterator.startReadingBits();
         /**
          * ChatGPT
@@ -104,10 +105,10 @@ const getMatroskaAudioCodecString = (track) => {
         iterator.destroy();
         return `mp4a.40.${profile.toString().padStart(2, '0')}`;
     }
-    if (codec.codec === 'A_MPEG/L3') {
+    if (codec.value === 'A_MPEG/L3') {
         return 'mp3';
     }
-    throw new Error(`Unknown codec: ${codec.codec}`);
+    throw new Error(`Unknown codec: ${codec.value}`);
 };
 const getTrack = ({ timescale, track, }) => {
     const trackType = (0, traversal_1.getTrackTypeSegment)(track);
@@ -115,7 +116,7 @@ const getTrack = ({ timescale, track, }) => {
         throw new Error('Expected track type segment');
     }
     const trackId = (0, traversal_1.getTrackId)(track);
-    if (trackType.trackType === 'video') {
+    if ((0, track_entry_1.trackTypeToString)(trackType.value.value) === 'video') {
         const width = (0, traversal_1.getWidthSegment)(track);
         if (width === null) {
             throw new Error('Expected width segment');
@@ -142,26 +143,26 @@ const getTrack = ({ timescale, track, }) => {
             trackId,
             codec: codecString,
             description: getDescription(track),
-            height: displayHeight ? displayHeight.displayHeight : height.height,
-            width: displayWidth ? displayWidth.displayWidth : width.width,
+            height: displayHeight ? displayHeight.value.value : height.value.value,
+            width: displayWidth ? displayWidth.value.value : width.value.value,
             sampleAspectRatio: {
                 numerator: 1,
                 denominator: 1,
             },
             timescale,
             samplePositions: [],
-            codedHeight: height.height,
-            codedWidth: width.width,
+            codedHeight: height.value.value,
+            codedWidth: width.value.value,
             displayAspectHeight: displayHeight
-                ? displayHeight.displayHeight
-                : height.height,
+                ? displayHeight.value.value
+                : height.value.value,
             displayAspectWidth: displayWidth
-                ? displayWidth.displayWidth
-                : width.width,
+                ? displayWidth.value.value
+                : width.value.value,
             rotation: 0,
         };
     }
-    if (trackType.trackType === 'audio') {
+    if ((0, track_entry_1.trackTypeToString)(trackType.value.value) === 'audio') {
         const sampleRate = (0, traversal_1.getSampleRate)(track);
         const numberOfChannels = (0, traversal_1.getNumberOfChannels)(track);
         if (sampleRate === null) {

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

@@ -1,2 +1,4 @@
+import type { PossibleEbmlOrUint8Array } from './segments/all-segments';
 export declare const webmPattern: Uint8Array;
-export declare const makeMatroskaHeader: () => Uint8Array;
+export declare const makeMatroskaBytes: (fields: PossibleEbmlOrUint8Array) => Uint8Array;
+export declare const combineUint8Arrays: (arrays: Uint8Array[]) => Uint8Array;

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

@@ -1,44 +1,102 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMatroskaHeader = exports.webmPattern = void 0;
+exports.combineUint8Arrays = exports.makeMatroskaBytes = exports.webmPattern = void 0;
 const ebml_1 = require("./ebml");
 const all_segments_1 = require("./segments/all-segments");
 exports.webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
 const matroskaToHex = (matrId) => {
-    const numbers = [];
+    const numbers = new Uint8Array((matrId.length - 2) / 2);
     for (let i = 2; i < matrId.length; i += 2) {
-        const hex = matrId.substr(i, 2);
-        numbers.push(parseInt(hex, 16));
+        const hex = matrId.substring(i, i + 2);
+        numbers[(i - 2) / 2] = parseInt(hex, 16);
     }
     return numbers;
 };
-const makeMatroskaHeader = () => {
-    const size = 0x23;
-    const array = new Uint8Array([
-        ...exports.webmPattern,
-        ...(0, ebml_1.getVariableInt)(size),
-        ...matroskaToHex(all_segments_1.matroskaElements.EBMLVersion),
-        ...(0, ebml_1.getVariableInt)(1),
-        1,
-        ...matroskaToHex(all_segments_1.matroskaElements.EBMLReadVersion),
-        ...(0, ebml_1.getVariableInt)(1),
-        1,
-        ...matroskaToHex(all_segments_1.matroskaElements.EBMLMaxIDLength),
-        ...(0, ebml_1.getVariableInt)(1),
-        4,
-        ...matroskaToHex(all_segments_1.matroskaElements.EBMLMaxSizeLength),
-        ...(0, ebml_1.getVariableInt)(1),
-        8,
-        ...matroskaToHex(all_segments_1.matroskaElements.DocType),
-        ...(0, ebml_1.getVariableInt)(8),
-        ...new TextEncoder().encode('matroska'),
-        ...matroskaToHex(all_segments_1.matroskaElements.DocTypeVersion),
-        ...(0, ebml_1.getVariableInt)(1),
-        4,
-        ...matroskaToHex(all_segments_1.matroskaElements.DocTypeReadVersion),
-        ...(0, ebml_1.getVariableInt)(1),
-        2,
+function putUintDynamic(number, minimumLength) {
+    if (number < 0) {
+        throw new Error('This function is designed for non-negative integers only.');
+    }
+    // Calculate the minimum number of bytes needed to store the integer
+    const length = Math.max(minimumLength !== null && minimumLength !== void 0 ? minimumLength : 0, Math.ceil(Math.log2(number + 1) / 8));
+    const bytes = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+        // Extract each byte from the number
+        bytes[length - 1 - i] = (number >> (8 * i)) & 0xff;
+    }
+    return bytes;
+}
+const makeFromHeaderStructure = (fields) => {
+    if (fields instanceof Uint8Array) {
+        return fields;
+    }
+    const arrays = [];
+    const struct = all_segments_1.ebmlMap[(0, all_segments_1.getIdForName)(fields.type)];
+    if (struct.type === 'uint8array') {
+        return fields.value;
+    }
+    if (struct.type === 'children') {
+        for (const item of fields.value) {
+            arrays.push((0, exports.makeMatroskaBytes)(item));
+        }
+        return (0, exports.combineUint8Arrays)(arrays);
+    }
+    if (struct.type === 'string') {
+        return new TextEncoder().encode(fields.value);
+    }
+    if (struct.type === 'uint') {
+        return putUintDynamic(fields.value.value, fields.value.byteLength);
+    }
+    if (struct.type === 'hex-string') {
+        const hex = fields.value.substring(2);
+        const arr = new Uint8Array(hex.length / 2);
+        for (let i = 0; i < hex.length; i += 2) {
+            const byte = parseInt(hex.substring(i, i + 2), 16);
+            arr[i / 2] = byte;
+        }
+        return arr;
+    }
+    if (struct.type === 'float') {
+        const value = fields.value;
+        if (value.size === '32') {
+            const dataView = new DataView(new ArrayBuffer(4));
+            dataView.setFloat32(0, value.value);
+            return new Uint8Array(dataView.buffer);
+        }
+        const dataView2 = new DataView(new ArrayBuffer(8));
+        dataView2.setFloat64(0, value.value);
+        return new Uint8Array(dataView2.buffer);
+    }
+    throw new Error('Unexpected type');
+};
+const makeMatroskaBytes = (fields) => {
+    if (fields instanceof Uint8Array) {
+        return fields;
+    }
+    const value = makeFromHeaderStructure(fields);
+    return (0, exports.combineUint8Arrays)([
+        matroskaToHex((0, all_segments_1.getIdForName)(fields.type)),
+        (0, ebml_1.getVariableInt)(value.length, fields.minVintWidth),
+        value,
     ]);
-    return array;
 };
-exports.makeMatroskaHeader = makeMatroskaHeader;
+exports.makeMatroskaBytes = makeMatroskaBytes;
+const combineUint8Arrays = (arrays) => {
+    if (arrays.length === 0) {
+        return new Uint8Array([]);
+    }
+    if (arrays.length === 1) {
+        return arrays[0];
+    }
+    let totalLength = 0;
+    for (const array of arrays) {
+        totalLength += array.length;
+    }
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const array of arrays) {
+        result.set(array, offset);
+        offset += array.length;
+    }
+    return result;
+};
+exports.combineUint8Arrays = combineUint8Arrays;

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

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