@remotion/media-parser 4.0.207 → 4.0.209

package/dist/boxes/webm/segments/seek-position.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSeekPositionSegment = void 0;
+const parseSeekPositionSegment = (iterator, length) => {
+    const seekPosition = iterator.getUint(length);
+    return {
+        type: 'seek-position-segment',
+        seekPosition,
+    };
+};
+exports.parseSeekPositionSegment = parseSeekPositionSegment;

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

@@ -0,0 +1,13 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { ParserContext } from '../../../parser-context';
+import type { MatroskaSegment } from '../segments';
+export type SeekSegment = {
+    type: 'seek-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseSeekSegment: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<SeekSegment>;
+export type SeekIdSegment = {
+    type: 'seek-id-segment';
+    seekId: string;
+};
+export declare const parseSeekIdSegment: (iterator: BufferIterator, length: number) => SeekIdSegment;

package/dist/boxes/webm/segments/seek.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSeekIdSegment = exports.parseSeekSegment = void 0;
+const parse_children_1 = require("./parse-children");
+const parseSeekSegment = async (iterator, length, parserContext) => {
+    const children = await (0, parse_children_1.expectChildren)({
+        iterator,
+        length,
+        initialChildren: [],
+        wrap: null,
+        parserContext,
+    });
+    if (children.status === 'incomplete') {
+        throw new Error('Incomplete children');
+    }
+    return {
+        type: 'seek-segment',
+        children: children.segments,
+    };
+};
+exports.parseSeekSegment = parseSeekSegment;
+const parseSeekIdSegment = (iterator, length) => {
+    const seekId = '0x' +
+        [...iterator.getSlice(length)]
+            .map((b) => b.toString(16).padStart(2, '0'))
+            .join('');
+    if (seekId === null) {
+        throw new Error('Not enough bytes to parse seek id');
+    }
+    return {
+        type: 'seek-id-segment',
+        seekId,
+    };
+};
+exports.parseSeekIdSegment = parseSeekIdSegment;

package/dist/boxes/webm/segments/timestamp-scale.d.ts

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export type TimestampScaleSegment = {
+    type: 'timestamp-scale-segment';
+    timestampScale: number;
+};
+export declare const parseTimestampScaleSegment: (iterator: BufferIterator) => TimestampScaleSegment;

package/dist/boxes/webm/segments/timestamp-scale.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTimestampScaleSegment = void 0;
+const parseTimestampScaleSegment = (iterator) => {
+    const timestampScale = iterator.getUint(3);
+    return {
+        type: 'timestamp-scale-segment',
+        timestampScale,
+    };
+};
+exports.parseTimestampScaleSegment = parseTimestampScaleSegment;

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

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { ParserContext } from '../../../parser-context';
+import type { MatroskaSegment } from '../segments';
+export type TracksSegment = {
+    type: 'tracks-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseTracksSegment: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<TracksSegment>;

package/dist/boxes/webm/segments/tracks.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTracksSegment = void 0;
+const parse_children_1 = require("./parse-children");
+const parseTracksSegment = async (iterator, length, parserContext) => {
+    const children = await (0, parse_children_1.expectChildren)({
+        iterator,
+        length,
+        initialChildren: [],
+        wrap: null,
+        parserContext,
+    });
+    if (children.status === 'incomplete') {
+        throw new Error('Incomplete children');
+    }
+    return {
+        type: 'tracks-segment',
+        children: children.segments,
+    };
+};
+exports.parseTracksSegment = parseTracksSegment;

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

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export type UnknownSegment = {
+    id: string;
+    type: 'unknown-segment';
+};
+export declare const parseUnknownSegment: (iterator: BufferIterator, id: string, length: number) => UnknownSegment;

package/dist/boxes/webm/segments/unknown.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUnknownSegment = void 0;
+const parseUnknownSegment = (iterator, id, length) => {
+    iterator.discard(length);
+    return {
+        id,
+        type: 'unknown-segment',
+    };
+};
+exports.parseUnknownSegment = parseUnknownSegment;

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

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export type VoidSegment = {
+    type: 'void-segment';
+    length: number;
+};
+export declare const parseVoidSegment: (iterator: BufferIterator, length: number) => VoidSegment;

package/dist/boxes/webm/segments/void.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVoidSegment = void 0;
+const parseVoidSegment = (iterator, length) => {
+    iterator.discard(length);
+    return {
+        type: 'void-segment',
+        length,
+    };
+};
+exports.parseVoidSegment = parseVoidSegment;

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

@@ -0,0 +1,6 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export type WritingAppSegment = {
+    type: 'writing-app-segment';
+    value: string;
+};
+export declare const parseWritingSegment: (iterator: BufferIterator, length: number) => WritingAppSegment;

package/dist/boxes/webm/segments/writing.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWritingSegment = void 0;
+const parseWritingSegment = (iterator, length) => {
+    const value = iterator.getByteString(length);
+    return {
+        type: 'writing-app-segment',
+        value,
+    };
+};
+exports.parseWritingSegment = parseWritingSegment;

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

@@ -0,0 +1,8 @@
+import type { BufferIterator } from '../../buffer-iterator';
+import type { ParserContext } from '../../parser-context';
+import type { MatroskaSegment } from './segments';
+export type TracksSegment = {
+    type: 'tracks-segment';
+    children: MatroskaSegment[];
+};
+export declare const parseTracksSegment: (iterator: BufferIterator, length: number, parserContext: ParserContext) => Promise<TracksSegment>;

package/dist/boxes/webm/tracks.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTracksSegment = void 0;
+const parse_children_1 = require("./segments/parse-children");
+const parseTracksSegment = async (iterator, length, parserContext) => {
+    const children = await (0, parse_children_1.expectChildren)({
+        iterator,
+        length,
+        initialChildren: [],
+        wrap: null,
+        parserContext,
+    });
+    if (children.status === 'incomplete') {
+        throw new Error('Incomplete children');
+    }
+    return {
+        type: 'tracks-segment',
+        children: children.segments,
+    };
+};
+exports.parseTracksSegment = parseTracksSegment;

package/dist/buffer-iterator.js

@@ -370,6 +370,12 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             for (let i = 1; i < actualLength; i++) {
                 value = (value << 8) | d[i];
             }
+            // Livestreamed segments sometimes have a Cluster length of 0xFFFFFFFFFFFFFF
+            // which we parse as -1
+            // this should be treated as Infinity
+            if (value === -1) {
+                return Infinity;
+            }
             return value;
         },
         getUint8,

package/dist/combine-uint8array.d.ts

@@ -0,0 +1 @@
+export declare const combineUint8Arrays: (array1: Uint8Array | null, array2: Uint8Array) => Uint8Array;

package/dist/combine-uint8array.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineUint8Arrays = void 0;
+const combineUint8Arrays = (array1, array2) => {
+    if (!array1) {
+        return array2;
+    }
+    const combined = new Uint8Array(array1.length + array2.length);
+    combined.set(array1);
+    combined.set(array2, array1.length);
+    return combined;
+};
+exports.combineUint8Arrays = combineUint8Arrays;

package/dist/create/cluster-segment.d.ts

@@ -1,5 +1,5 @@
 export declare const CLUSTER_MIN_VINT_WIDTH = 8;
-export declare const createClusterSegment: () => import("../boxes/webm/segments/all-segments").BytesAndOffset;
+export declare const createClusterSegment: (timestamp: number) => import("../boxes/webm/segments/all-segments").BytesAndOffset;
 export declare const makeSimpleBlock: ({ bytes, trackNumber, timecodeRelativeToCluster, keyframe, invisible, lacing, }: {
     bytes: Uint8Array;
     trackNumber: number;

package/dist/create/cluster-segment.js

@@ -4,15 +4,15 @@ exports.makeSimpleBlock = exports.createClusterSegment = exports.CLUSTER_MIN_VIN
 const ebml_1 = require("../boxes/webm/ebml");
 const make_header_1 = require("../boxes/webm/make-header");
 exports.CLUSTER_MIN_VINT_WIDTH = 8;
-const createClusterSegment = () => {
+const createClusterSegment = (timestamp) => {
     return (0, make_header_1.makeMatroskaBytes)({
         type: 'Cluster',
         value: [
             {
                 type: 'Timestamp',
-                minVintWidth: 4,
+                minVintWidth: null,
                 value: {
-                    value: 0,
+                    value: timestamp,
                     byteLength: null,
                 },
             },

package/dist/create/cluster.d.ts

@@ -0,0 +1,5 @@
+import type { Writer } from '../writers/writer';
+export declare const makeCluster: (w: Writer, timestamp: number) => Promise<{
+    addSample: (chunk: EncodedVideoChunk, trackNumber: number) => Promise<void>;
+    shouldMakeNewCluster: (chunk: EncodedVideoChunk) => boolean;
+}>;

package/dist/create/cluster.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeCluster = void 0;
+const ebml_1 = require("../boxes/webm/ebml");
+const make_header_1 = require("../boxes/webm/make-header");
+const all_segments_1 = require("../boxes/webm/segments/all-segments");
+const cluster_segment_1 = require("./cluster-segment");
+const timescale_1 = require("./timescale");
+const maxClusterTimestamp = 2 ** 15;
+const timestampToClusterTimestamp = (timestamp) => {
+    return Math.round((timestamp / timescale_1.CREATE_TIME_SCALE) * 1000);
+};
+const makeCluster = async (w, timestamp) => {
+    const cluster = (0, cluster_segment_1.createClusterSegment)(timestampToClusterTimestamp(timestamp));
+    const clusterVIntPosition = w.getWrittenByteCount() +
+        cluster.offsets.offset +
+        (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Cluster).byteLength;
+    let clusterSize = cluster.bytes.byteLength;
+    await w.write(cluster.bytes);
+    const addSample = async (chunk, trackNumber) => {
+        const arr = new Uint8Array(chunk.byteLength);
+        chunk.copyTo(arr);
+        const timecodeRelativeToCluster = timestampToClusterTimestamp(chunk.timestamp) -
+            timestampToClusterTimestamp(timestamp);
+        if (timecodeRelativeToCluster > maxClusterTimestamp) {
+            throw new Error('timecodeRelativeToCluster is too big');
+        }
+        const keyframe = chunk.type === 'key';
+        const simpleBlock = (0, cluster_segment_1.makeSimpleBlock)({
+            bytes: arr,
+            invisible: false,
+            keyframe,
+            lacing: 0,
+            trackNumber,
+            timecodeRelativeToCluster,
+        });
+        clusterSize += simpleBlock.byteLength;
+        await w.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
+        await w.write(simpleBlock);
+    };
+    const shouldMakeNewCluster = (chunk) => {
+        const newTimestamp = timestampToClusterTimestamp(chunk.timestamp);
+        const oldTimestamp = timestampToClusterTimestamp(timestamp);
+        return newTimestamp - oldTimestamp >= 2000 && chunk.type === 'key';
+    };
+    return { addSample, shouldMakeNewCluster };
+};
+exports.makeCluster = makeCluster;

package/dist/create/create-media.js

@@ -1,23 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMedia = void 0;
-const ebml_1 = require("../boxes/webm/ebml");
 const make_header_1 = require("../boxes/webm/make-header");
-const all_segments_1 = require("../boxes/webm/segments/all-segments");
-const cluster_segment_1 = require("./cluster-segment");
+const cluster_1 = require("./cluster");
+const make_duration_with_padding_1 = require("./make-duration-with-padding");
 const matroska_header_1 = require("./matroska-header");
 const matroska_info_1 = require("./matroska-info");
 const matroska_segment_1 = require("./matroska-segment");
 const matroska_trackentry_1 = require("./matroska-trackentry");
+const timescale_1 = require("./timescale");
 const createMedia = async (writer) => {
     var _a, _b, _c, _d;
     const header = (0, matroska_header_1.makeMatroskaHeader)();
     const w = await writer.createContent();
     await w.write(header.bytes);
     const matroskaInfo = (0, matroska_info_1.makeMatroskaInfo)({
-        timescale: 1000000,
-        // TODO: Hardcoded
-        duration: 2658,
+        timescale: timescale_1.CREATE_TIME_SCALE,
     });
     const currentTracks = [];
     const matroskaTracks = (0, matroska_trackentry_1.makeMatroskaTracks)(currentTracks);
@@ -34,40 +32,20 @@ const createMedia = async (writer) => {
         throw new Error('could not get tracks offset');
     }
     await w.write(matroskaSegment.bytes);
-    const cluster = (0, cluster_segment_1.createClusterSegment)();
-    const clusterVIntPosition = w.getWrittenByteCount() +
-        cluster.offsets.offset +
-        (0, make_header_1.matroskaToHex)(all_segments_1.matroskaElements.Cluster).byteLength;
-    let clusterSize = cluster.bytes.byteLength;
-    await w.write(cluster.bytes);
+    let currentCluster = await (0, cluster_1.makeCluster)(w, 0);
+    const getClusterOrMakeNew = async (chunk) => {
+        if (!currentCluster.shouldMakeNewCluster(chunk)) {
+            return currentCluster;
+        }
+        currentCluster = await (0, cluster_1.makeCluster)(w, chunk.timestamp);
+        return currentCluster;
+    };
     const addSample = async (chunk, trackNumber) => {
-        const arr = new Uint8Array(chunk.byteLength);
-        chunk.copyTo(arr);
-        const simpleBlock = (0, cluster_segment_1.makeSimpleBlock)({
-            bytes: arr,
-            invisible: false,
-            keyframe: chunk.type === 'key',
-            lacing: 0,
-            trackNumber,
-            // TODO: Maybe this is bad, because it's in microseconds, but should be in timescale
-            // Maybe it only works by coincidence
-            timecodeRelativeToCluster: Math.round(chunk.timestamp / 1000),
-        });
-        clusterSize += simpleBlock.byteLength;
-        await w.updateDataAt(clusterVIntPosition, (0, ebml_1.getVariableInt)(clusterSize, cluster_segment_1.CLUSTER_MIN_VINT_WIDTH));
-        await w.write(simpleBlock);
+        const cluster = await getClusterOrMakeNew(chunk);
+        return cluster.addSample(chunk, trackNumber);
     };
     const updateDuration = async (newDuration) => {
-        const blocks = (0, make_header_1.padMatroskaBytes)({
-            type: 'Duration',
-            value: {
-                value: newDuration,
-                size: '64',
-            },
-            minVintWidth: null,
-        }, 
-        // TODO: That's too much padding
-        1000);
+        const blocks = (0, make_duration_with_padding_1.makeDurationWithPadding)(newDuration);
         await w.updateDataAt(durationOffset, (0, make_header_1.combineUint8Arrays)(blocks.map((b) => b.bytes)));
     };
     const addTrack = async (track) => {

package/dist/create/make-duration-with-padding.d.ts

@@ -0,0 +1 @@
+export declare const makeDurationWithPadding: (newDuration: number) => import("../boxes/webm/segments/all-segments").BytesAndOffset[];

package/dist/create/make-duration-with-padding.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDurationWithPadding = void 0;
+const make_header_1 = require("../boxes/webm/make-header");
+const makeDurationWithPadding = (newDuration) => {
+    return (0, make_header_1.padMatroskaBytes)({
+        type: 'Duration',
+        value: {
+            value: newDuration,
+            size: '64',
+        },
+        minVintWidth: null,
+    }, 100);
+};
+exports.makeDurationWithPadding = makeDurationWithPadding;

package/dist/create/matroska-info.d.ts

@@ -1,4 +1,3 @@
-export declare const makeMatroskaInfo: ({ timescale, duration, }: {
+export declare const makeMatroskaInfo: ({ timescale }: {
     timescale: number;
-    duration: number;
 }) => import("../boxes/webm/segments/all-segments").BytesAndOffset;

package/dist/create/matroska-info.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeMatroskaInfo = void 0;
 const make_header_1 = require("../boxes/webm/make-header");
-const makeMatroskaInfo = ({ timescale, duration, }) => {
+const make_duration_with_padding_1 = require("./make-duration-with-padding");
+const makeMatroskaInfo = ({ timescale }) => {
     return (0, make_header_1.makeMatroskaBytes)({
         type: 'Info',
         value: [
@@ -24,16 +25,7 @@ const makeMatroskaInfo = ({ timescale, duration, }) => {
                 value: '@remotion/media-parser',
                 minVintWidth: null,
             },
-            ...(0, make_header_1.padMatroskaBytes)({
-                type: 'Duration',
-                value: {
-                    value: duration,
-                    size: '64',
-                },
-                minVintWidth: null,
-            }, 
-            // TODO: That's too much padding
-            1000),
+            ...(0, make_duration_with_padding_1.makeDurationWithPadding)(0),
         ],
         minVintWidth: null,
     });

package/dist/create/timescale.d.ts

@@ -0,0 +1 @@
+export declare const CREATE_TIME_SCALE = 1000000;

package/dist/create/timescale.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CREATE_TIME_SCALE = void 0;
+exports.CREATE_TIME_SCALE = 1000000;

package/dist/from-web.d.ts

@@ -0,0 +1,2 @@
+import type { ReaderInterface } from './reader';
+export declare const webReader: ReaderInterface;

package/dist/from-web.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webReader = void 0;
+exports.webReader = {
+    read: async (src, range) => {
+        const resolvedUrl = typeof window !== 'undefined' && typeof window.location !== 'undefined'
+            ? new URL(src, window.location.origin).toString()
+            : src;
+        if (!resolvedUrl.startsWith('https://') &&
+            !resolvedUrl.startsWith('http://')) {
+            return Promise.reject(new Error(resolvedUrl +
+                ' is not a URL - needs to start with http:// or https://. If you want to read a local file, pass `nodeReader` to parseMedia().'));
+        }
+        const res = await fetch(resolvedUrl, {
+            headers: range === null
+                ? {}
+                : {
+                    Range: `bytes=${`${range[0]}-${range[1]}`}`,
+                },
+        });
+        if (!res.body) {
+            throw new Error('No body');
+        }
+        const length = res.headers.get('content-length');
+        if (!length) {
+            throw new Error('No content-length');
+        }
+        const contentLength = length === null ? null : parseInt(length, 10);
+        const reader = res.body.getReader();
+        return { reader, contentLength };
+    },
+    getLength: async (src) => {
+        const res = await fetch(src, {
+            method: 'HEAD',
+        });
+        if (!res.body) {
+            throw new Error('No body');
+        }
+        const length = res.headers.get('content-length');
+        if (!length) {
+            throw new Error('No content-length');
+        }
+        return parseInt(length, 10);
+    },
+};

package/dist/get-audio-codec.d.ts

@@ -14,7 +14,7 @@ export declare const getNumberOfChannelsFromTrak: (trak: TrakBox) => number | nu
 export declare const getSampleRate: (trak: TrakBox) => number | null;
 export declare const getAudioCodecFromTrak: (trak: TrakBox) => AudioCodecInfo | null;
 export declare const getAudioCodecFromIso: (moov: MoovBox) => AudioCodecInfo | null;
-export declare const getAudioCodecFromMatroska: (mainSegment: MainSegment) => "aac" | "mp3" | "opus" | "pcm" | "vorbis" | null;
+export declare const getAudioCodecFromMatroska: (mainSegment: MainSegment) => "vorbis" | "opus" | "mp3" | "aac" | "pcm" | null;
 export declare const getAudioCodecStringFromTrak: (trak: TrakBox) => {
     codecString: string;
     description: Uint8Array | undefined;

package/dist/get-video-metadata.d.ts

@@ -0,0 +1,2 @@
+import type { ParseMedia } from './options';
+export declare const parseMedia: ParseMedia;

package/dist/get-video-metadata.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMedia = void 0;
+const buffer_iterator_1 = require("./buffer-iterator");
+const from_web_1 = require("./from-web");
+const get_dimensions_1 = require("./get-dimensions");
+const get_duration_1 = require("./get-duration");
+const get_fps_1 = require("./get-fps");
+const has_all_info_1 = require("./has-all-info");
+const parse_video_1 = require("./parse-video");
+const parseMedia = async (src, options, readerInterface = from_web_1.webReader) => {
+    const reader = await readerInterface.read(src, null);
+    const returnValue = {};
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]));
+    let parseResult = (0, parse_video_1.parseVideo)(iterator);
+    while (parseResult.status === 'incomplete') {
+        const result = await reader.read();
+        if (result.done) {
+            break;
+        }
+        iterator.addData(result.value);
+        parseResult = parseResult.continueParsing();
+        if ((0, has_all_info_1.hasAllInfo)(options, parseResult)) {
+            if (!reader.closed) {
+                reader.cancel(new Error('has all information'));
+            }
+            break;
+        }
+    }
+    if (options.dimensions) {
+        returnValue.dimensions = (0, get_dimensions_1.getDimensions)(parseResult.segments);
+    }
+    if (options.durationInSeconds) {
+        returnValue.durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments);
+    }
+    if (options.fps) {
+        returnValue.fps = (0, get_fps_1.getFps)(parseResult.segments);
+    }
+    if (options.boxes) {
+        returnValue.boxes = parseResult.segments;
+    }
+    return returnValue;
+};
+exports.parseMedia = parseMedia;

package/dist/read-and-increment-offset.d.ts

@@ -0,0 +1,28 @@
+export declare class OffsetCounter {
+    #private;
+    constructor(initial: number);
+    increment(amount: number): void;
+    getOffset(): number;
+}
+export declare const getArrayBufferIterator: (data: ArrayBuffer, initialOffset: number) => {
+    view: DataView;
+    counter: OffsetCounter;
+    data: ArrayBuffer;
+    discard: (length: number) => void;
+    getSlice: (amount: number) => ArrayBuffer;
+    getAtom: () => string;
+    getMatroskaSegmentId: () => string;
+    getVint: (bytes: number) => number;
+    getUint8: () => number;
+    getEBML: () => number;
+    getInt8: () => number;
+    getUint16: () => number;
+    getInt16: () => number;
+    getUint32: () => number;
+    getFixedPoint1616Number: () => number;
+    getPascalString: () => number[];
+    getDecimalBytes(length: number): number;
+    getByteString(length: number): string;
+    getFloat64: () => number;
+};
+export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;