@remotion/media-parser 4.0.201 → 4.0.204

package/dist/av1-codec-string.d.ts

@@ -1,8 +1,3 @@
 import type { ColorParameterBox } from './boxes/iso-base-media/stsd/colr';
 import type { Av1BitstreamHeaderSegment } from './boxes/webm/bitstream/av1/header-segment';
-import type { ClusterSegment, TrackEntrySegment } from './boxes/webm/segments/track-entry';
 export declare const constructAv1CodecString: (av1BitstreamHeader: Av1BitstreamHeaderSegment, colrAtom: ColorParameterBox | null) => string;
-export declare const av1CodecStringToString: ({ track, clusterSegment, }: {
-    track: TrackEntrySegment;
-    clusterSegment: ClusterSegment;
-}) => string | null;

package/dist/av1-codec-string.js

@@ -1,9 +1,7 @@
 "use strict";
 // https://aomediacodec.github.io/av1-isobmff/#codecsparam
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.av1CodecStringToString = exports.constructAv1CodecString = void 0;
-const traversal_1 = require("./boxes/webm/traversal");
-const traversal_2 = require("./traversal");
+exports.constructAv1CodecString = void 0;
 const constructAv1CodecString = (av1BitstreamHeader, colrAtom) => {
     let str = 'av01.';
     // Profile
@@ -91,18 +89,3 @@ const constructAv1CodecString = (av1BitstreamHeader, colrAtom) => {
     return str;
 };
 exports.constructAv1CodecString = constructAv1CodecString;
-const av1CodecStringToString = ({ track, clusterSegment, }) => {
-    const codecSegment = (0, traversal_2.getCodecSegment)(track);
-    if (!codecSegment) {
-        throw new Error('Expected codec segment');
-    }
-    if (codecSegment.codec !== 'V_AV1') {
-        throw new Error(`Should not call this function if it is not AV1: ${codecSegment.codec}`);
-    }
-    const av1BitstreamHeader = (0, traversal_1.getAv1BitstreamHeader)(clusterSegment);
-    if (!av1BitstreamHeader) {
-        return null;
-    }
-    return (0, exports.constructAv1CodecString)(av1BitstreamHeader, null);
-};
-exports.av1CodecStringToString = av1CodecStringToString;

package/dist/boxes/iso-base-media/ftype.d.ts

@@ -0,0 +1,9 @@
+import type { BaseBox } from './base-type';
+export interface FtypBox extends BaseBox {
+    type: 'ftyp-box';
+    majorBrand: string;
+    minorVersion: number;
+    compatibleBrands: string[];
+}
+export declare const fourByteToNumber: (data: ArrayBuffer, from: number) => number;
+export declare const parseFtyp: (data: ArrayBuffer, offset: number) => FtypBox;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFtyp = exports.fourByteToNumber = void 0;
+const fourByteToNumber = (data, from) => {
+    const view = new DataView(data);
+    return ((view.getUint8(from + 0) << 24) |
+        (view.getUint8(from + 1) << 16) |
+        (view.getUint8(from + 2) << 8) |
+        view.getUint8(from + 3));
+};
+exports.fourByteToNumber = fourByteToNumber;
+const parseFtyp = (data, offset) => {
+    const majorBrand = new TextDecoder().decode(data.slice(8, 12)).trim();
+    const minorVersion = (0, exports.fourByteToNumber)(data, 12);
+    const rest = data.slice(16);
+    const types = rest.byteLength / 4;
+    const compatibleBrands = [];
+    for (let i = 0; i < types; i++) {
+        const fourBytes = rest.slice(i * 4, i * 4 + 4);
+        compatibleBrands.push(new TextDecoder().decode(fourBytes).trim());
+    }
+    return {
+        type: 'ftyp-box',
+        majorBrand,
+        minorVersion,
+        compatibleBrands,
+        offset,
+        boxSize: data.byteLength,
+    };
+};
+exports.parseFtyp = parseFtyp;

package/dist/boxes/iso-base-media/get-sample-positions-from-track.d.ts

@@ -0,0 +1,4 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { IsoBaseMediaBox } from '../../parse-result';
+import type { TrakBox } from './trak/trak';
+export declare const getSamplePositionsFromTrack: (trakBox: TrakBox, moofBox: IsoBaseMediaBox | null) => SamplePosition[];

package/dist/boxes/iso-base-media/get-sample-positions-from-track.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSamplePositionsFromTrack = void 0;
+const get_fps_1 = require("../../get-fps");
+const get_sample_positions_1 = require("../../get-sample-positions");
+const samples_from_moof_1 = require("../../samples-from-moof");
+const traversal_1 = require("../../traversal");
+const getSamplePositionsFromTrack = (trakBox, moofBox) => {
+    const stszBox = (0, traversal_1.getStszBox)(trakBox);
+    const stcoBox = (0, traversal_1.getStcoBox)(trakBox);
+    const stscBox = (0, traversal_1.getStscBox)(trakBox);
+    const stssBox = (0, traversal_1.getStssBox)(trakBox);
+    const sttsBox = (0, traversal_1.getSttsBox)(trakBox);
+    const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
+    const cttsBox = (0, traversal_1.getCttsBox)(trakBox);
+    const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
+    if (!tkhdBox) {
+        throw new Error('Expected tkhd box in trak box');
+    }
+    if (!stszBox) {
+        throw new Error('Expected stsz box in trak box');
+    }
+    if (!stcoBox) {
+        throw new Error('Expected stco box in trak box');
+    }
+    if (!stscBox) {
+        throw new Error('Expected stsc box in trak box');
+    }
+    if (!sttsBox) {
+        throw new Error('Expected stts box in trak box');
+    }
+    if (!timescaleAndDuration) {
+        throw new Error('Expected timescale and duration in trak box');
+    }
+    let samplePositions = (0, get_sample_positions_1.getSamplePositions)({
+        stcoBox,
+        stscBox,
+        stszBox,
+        stssBox,
+        sttsBox,
+        cttsBox,
+    });
+    if (samplePositions.length === 0 && moofBox) {
+        samplePositions = (0, samples_from_moof_1.getSamplesFromMoof)({ moofBox, trackId: tkhdBox.trackId });
+    }
+    return samplePositions;
+};
+exports.getSamplePositionsFromTrack = getSamplePositionsFromTrack;

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

@@ -19,13 +19,13 @@ const parseMvhd = ({ iterator, offset, size, }) => {
     const durationInUnits = iterator.getUint32();
     const durationInSeconds = durationInUnits / timeScale;
     const rateArray = iterator.getSlice(4);
-    const rateView = (0, buffer_iterator_1.getArrayBufferIterator)(rateArray);
+    const rateView = (0, buffer_iterator_1.getArrayBufferIterator)(rateArray, rateArray.length);
     const rate = rateView.getInt8() * 10 +
         rateView.getInt8() +
         rateView.getInt8() * 0.1 +
         rateView.getInt8() * 0.01;
     const volumeArray = iterator.getSlice(2);
-    const volumeView = (0, buffer_iterator_1.getArrayBufferIterator)(volumeArray);
+    const volumeView = (0, buffer_iterator_1.getArrayBufferIterator)(volumeArray, volumeArray.length);
     const volume = volumeView.getInt8() + volumeView.getInt8() * 0.1;
     // reserved 16bit
     iterator.discard(2);

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseKeys = void 0;
 const buffer_iterator_1 = require("../../../buffer-iterator");
 const parseKeys = (data, offset) => {
-    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data);
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data, data.byteLength);
     const size = iterator.getUint32();
     if (size !== data.byteLength) {
         throw new Error(`Expected keys size of ${data.byteLength}, got ${size}`);

package/dist/boxes/iso-base-media/tfdt.d.ts

@@ -0,0 +1,12 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface TfdtBox {
+    type: 'tfdt-box';
+    version: number;
+    baseMediaDecodeTime: number;
+    offset: number;
+}
+export declare const parseTfdt: ({ iterator, size, offset, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => TfdtBox;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTfdt = void 0;
+const parseTfdt = ({ iterator, size, offset, }) => {
+    const version = iterator.getUint8();
+    iterator.discard(3);
+    // Flags, discard them
+    const num = version === 0 ? iterator.getUint32() : Number(iterator.getUint64());
+    const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+    if (bytesRemaining !== 0) {
+        throw new Error('expected 0 bytes ' + bytesRemaining);
+    }
+    return {
+        type: 'tfdt-box',
+        version,
+        baseMediaDecodeTime: num,
+        offset,
+    };
+};
+exports.parseTfdt = parseTfdt;

package/dist/boxes/iso-base-media/tfhd.d.ts

@@ -0,0 +1,16 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface TfhdBox {
+    type: 'tfhd-box';
+    version: number;
+    trackId: number;
+    baseDataOffset: number;
+    baseSampleDescriptionIndex: number;
+    defaultSampleDuration: number;
+    defaultSampleSize: number;
+    defaultSampleFlags: number;
+}
+export declare const getTfhd: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    size: number;
+    offset: number;
+}) => TfhdBox;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTfhd = void 0;
+const getTfhd = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    const flags = iterator.getUint24();
+    const trackId = iterator.getUint32();
+    const baseDataOffsetPresent = flags & 0x01;
+    const baseDataOffset = baseDataOffsetPresent
+        ? Number(iterator.getUint64())
+        : 0;
+    const baseSampleDescriptionIndexPresent = flags & 0x02;
+    const baseSampleDescriptionIndex = baseSampleDescriptionIndexPresent
+        ? iterator.getUint32()
+        : 0;
+    const defaultSampleDurationPresent = flags & 0x08;
+    const defaultSampleDuration = defaultSampleDurationPresent
+        ? iterator.getUint32()
+        : 0;
+    const defaultSampleSizePresent = flags & 0x10;
+    const defaultSampleSize = defaultSampleSizePresent ? iterator.getUint32() : 0;
+    const defaultSampleFlagsPresent = flags & 0x20;
+    const defaultSampleFlags = defaultSampleFlagsPresent
+        ? iterator.getUint32()
+        : 0;
+    const bytesRemaining = size - (iterator.counter.getOffset() - offset);
+    if (bytesRemaining !== 0) {
+        throw new Error('expected 0 bytes ' + bytesRemaining);
+    }
+    return {
+        type: 'tfhd-box',
+        version,
+        trackId,
+        baseDataOffset,
+        baseSampleDescriptionIndex,
+        defaultSampleDuration,
+        defaultSampleSize,
+        defaultSampleFlags,
+    };
+};
+exports.getTfhd = getTfhd;

package/dist/boxes/iso-base-media/trun.d.ts

@@ -0,0 +1,21 @@
+import type { BufferIterator } from '../../buffer-iterator';
+export interface TrunBox {
+    type: 'trun-box';
+    version: number;
+    sampleCount: number;
+    dataOffset: number | null;
+    firstSampleFlags: number | null;
+    samples: TRunSample[];
+}
+type TRunSample = {
+    sampleDuration: number | null;
+    sampleSize: number | null;
+    sampleFlags: number | null;
+    sampleCompositionTimeOffset: number | null;
+};
+export declare const parseTrun: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => TrunBox;
+export {};

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTrun = void 0;
+const parseTrun = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported TRUN version ${version}`);
+    }
+    const flags = iterator.getUint24();
+    const sampleCount = iterator.getUint32();
+    const dataOffset = flags & 0x01 ? iterator.getInt32() : null;
+    const firstSampleFlags = flags & 0x04 ? iterator.getUint32() : null;
+    const samples = [];
+    for (let i = 0; i < sampleCount; i++) {
+        const sampleDuration = flags & 0x100 ? iterator.getUint32() : null;
+        const sampleSize = flags & 0x200 ? iterator.getUint32() : null;
+        const sampleFlags = flags & 0x400 ? iterator.getUint32() : null;
+        const sampleCompositionTimeOffset = flags & 0x800
+            ? version === 0
+                ? iterator.getUint32()
+                : iterator.getInt32Le()
+            : null;
+        samples.push({
+            sampleDuration,
+            sampleSize,
+            sampleFlags,
+            sampleCompositionTimeOffset,
+        });
+    }
+    const currentOffset = iterator.counter.getOffset();
+    const left = size - (currentOffset - offset);
+    if (left !== 0) {
+        throw new Error(`Unexpected data left in TRUN box: ${left}`);
+    }
+    return {
+        type: 'trun-box',
+        version,
+        sampleCount,
+        dataOffset,
+        firstSampleFlags,
+        samples,
+    };
+};
+exports.parseTrun = parseTrun;

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,15 +50,6 @@ 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) {
@@ -89,7 +80,7 @@ const av1Bitstream = ({ stream, length, onVideoSample, trackNumber, context, tim
             }
         }
         onVideoSample(trackNumber, {
-            bytes: (0, combine_uint8array_1.combineUint8Arrays)(extraBytes, frame),
+            data: (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 | 5 | 3 | 6 | 4;
-export declare const getVariableInt: (value: number, width?: number) => Uint8Array;
+export declare const measureEBMLVarInt: (value: number) => 2 | 3 | 1 | 4 | 5 | 6;
+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;