@remotion/media-parser 4.0.194 → 4.0.195

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

@@ -0,0 +1,19 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+type CttsEntry = {
+    sampleCount: number;
+    sampleOffset: number;
+};
+export interface CttsBox extends BaseBox {
+    type: 'ctts-box';
+    version: number;
+    flags: number[];
+    entryCount: number;
+    entries: CttsEntry[];
+}
+export declare const parseCtts: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => CttsBox;
+export {};

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCtts = void 0;
+const parseCtts = ({ iterator, offset, size, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported CTTS version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const entryCount = iterator.getUint32();
+    const entries = [];
+    for (let i = 0; i < entryCount; i++) {
+        const sampleCount = iterator.getUint32();
+        const sampleOffset = iterator.getUint32();
+        entries.push({
+            sampleCount,
+            sampleOffset,
+        });
+    }
+    return {
+        type: 'ctts-box',
+        boxSize: size,
+        offset,
+        version,
+        flags: [...flags],
+        entryCount,
+        entries,
+    };
+};
+exports.parseCtts = parseCtts;

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

@@ -0,0 +1,11 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export interface HvccBox {
+    type: 'hvcc-box';
+    data: Uint8Array;
+    configurationString: string;
+}
+export declare const parseHvcc: ({ data, size, offset, }: {
+    data: BufferIterator;
+    size: number;
+    offset: number;
+}) => HvccBox;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHvcc = void 0;
+const make_hvc1_codec_strings_1 = require("../../../make-hvc1-codec-strings");
+const parseHvcc = ({ data, size, offset, }) => {
+    const raw = data.getSlice(size - 8);
+    data.counter.decrement(size - 8);
+    const constraintString = (0, make_hvc1_codec_strings_1.getHvc1CodecString)(data);
+    const remaining = size - (data.counter.getOffset() - offset);
+    data.discard(remaining);
+    return {
+        type: 'hvcc-box',
+        data: raw,
+        configurationString: constraintString,
+    };
+};
+exports.parseHvcc = parseHvcc;

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

@@ -12,6 +12,7 @@ const parseKeys = (data, offset) => {
     if (atom !== 'keys') {
         throw new Error(`Expected keys type of keys, got ${atom}`);
     }
+    iterator.destroy();
     return {
         type: 'keys-box',
         boxSize: data.byteLength,

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

@@ -1,5 +1,6 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { AnySegment } from '../../../parse-result';
+import type { ParserContext } from '../../../parser-context';
 import type { BaseBox } from '../base-type';
 export interface MebxBox extends BaseBox {
     type: 'mebx-box';
@@ -7,8 +8,9 @@ export interface MebxBox extends BaseBox {
     format: string;
     children: AnySegment[];
 }
-export declare const parseMebx: ({ iterator, offset, size, }: {
+export declare const parseMebx: ({ iterator, offset, size, options, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
-}) => MebxBox;
+    options: ParserContext;
+}) => Promise<MebxBox>;

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

@@ -2,15 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMebx = void 0;
 const process_box_1 = require("../process-box");
-const parseMebx = ({ iterator, offset, size, }) => {
+const parseMebx = async ({ iterator, offset, size, options, }) => {
     // reserved, 6 bit
     iterator.discard(6);
     const dataReferenceIndex = iterator.getUint16();
-    const children = (0, process_box_1.parseBoxes)({
+    const children = await (0, process_box_1.parseBoxes)({
         iterator,
         maxBytes: iterator.counter.getOffset() - offset,
         allowIncompleteBoxes: false,
         initialBoxes: [],
+        options,
+        continueMdat: false,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

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

@@ -0,0 +1,12 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export interface PaspBox extends BaseBox {
+    type: 'pasp-box';
+    hSpacing: number;
+    vSpacing: number;
+}
+export declare const parsePasp: ({ iterator, offset, size, }: {
+    iterator: BufferIterator;
+    offset: number;
+    size: number;
+}) => PaspBox;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePasp = void 0;
+const parsePasp = ({ iterator, offset, size, }) => {
+    const hSpacing = iterator.getUint32();
+    const vSpacing = iterator.getUint32();
+    const bytesRemainingInBox = size - (iterator.counter.getOffset() - offset);
+    iterator.discard(bytesRemainingInBox);
+    return {
+        type: 'pasp-box',
+        boxSize: size,
+        offset,
+        hSpacing,
+        vSpacing,
+    };
+};
+exports.parsePasp = parsePasp;

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

@@ -1,5 +1,6 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { AnySegment } from '../../../parse-result';
+import type { ParserContext } from '../../../parser-context';
 type SampleBase = {
     format: string;
     offset: number;
@@ -9,7 +10,7 @@ type SampleBase = {
     vendor: number[];
     size: number;
 };
-type AudioSample = SampleBase & {
+export type AudioSample = SampleBase & {
     type: 'audio';
     numberOfChannels: number;
     sampleSize: number;
@@ -22,7 +23,7 @@ type AudioSample = SampleBase & {
     bitsPerSample: number | null;
     children: AnySegment[];
 };
-type VideoSample = SampleBase & {
+export type VideoSample = SampleBase & {
     type: 'video';
     temporalQuality: number;
     spacialQuality: number;
@@ -35,6 +36,7 @@ type VideoSample = SampleBase & {
     frameCountPerSample: number;
     depth: number;
     colorTableId: number;
+    descriptors: AnySegment[];
 };
 type UnknownSample = SampleBase & {
     type: 'unknown';
@@ -43,8 +45,13 @@ export type Sample = AudioSample | VideoSample | UnknownSample;
 type SampleAndNext = {
     sample: Sample | null;
 };
-export declare const processSample: ({ iterator, }: {
+export declare const processSample: ({ iterator, options, }: {
     iterator: BufferIterator;
-}) => SampleAndNext;
-export declare const parseSamples: (iterator: BufferIterator, maxBytes: number) => Sample[];
+    options: ParserContext;
+}) => Promise<SampleAndNext>;
+export declare const parseSamples: ({ iterator, maxBytes, options, }: {
+    iterator: BufferIterator;
+    maxBytes: number;
+    options: ParserContext;
+}) => Promise<Sample[]>;
 export {};

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

@@ -32,6 +32,7 @@ const videoTags = [
     'v210',
     'hvc1',
     'ap4h',
+    'av01',
 ];
 // https://developer.apple.com/documentation/quicktime-file-format/sound_sample_descriptions
 const audioTags = [
@@ -60,7 +61,7 @@ const audioTags = [
     'mp4a',
     'ac-3',
 ];
-const processSample = ({ iterator, }) => {
+const processSample = async ({ iterator, options, }) => {
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSize = iterator.getUint32();
@@ -98,13 +99,15 @@ const processSample = ({ iterator, }) => {
             const sampleSize = iterator.getUint16();
             const compressionId = iterator.getUint16();
             const packetSize = iterator.getUint16();
-            const sampleRate = iterator.getFixedPoint1616Number();
+            const sampleRate = iterator.getFixedPointUnsigned1616Number();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-            const children = (0, process_box_1.parseBoxes)({
+            const children = await (0, process_box_1.parseBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
                 initialBoxes: [],
+                options,
+                continueMdat: false,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -137,17 +140,19 @@ const processSample = ({ iterator, }) => {
             const sampleSize = iterator.getUint16();
             const compressionId = iterator.getInt16();
             const packetSize = iterator.getUint16();
-            const sampleRate = iterator.getFixedPoint1616Number();
+            const sampleRate = iterator.getFixedPointUnsigned1616Number();
             const samplesPerPacket = iterator.getUint32();
             const bytesPerPacket = iterator.getUint32();
             const bytesPerFrame = iterator.getUint32();
             const bytesPerSample = iterator.getUint32();
             const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-            const children = (0, process_box_1.parseBoxes)({
+            const children = await (0, process_box_1.parseBoxes)({
                 iterator,
                 allowIncompleteBoxes: false,
                 maxBytes: bytesRemainingInBox,
                 initialBoxes: [],
+                options,
+                continueMdat: false,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -182,15 +187,25 @@ const processSample = ({ iterator, }) => {
         const spacialQuality = iterator.getUint32();
         const width = iterator.getUint16();
         const height = iterator.getUint16();
-        const horizontalResolution = iterator.getFixedPoint1616Number();
-        const verticalResolution = iterator.getFixedPoint1616Number();
+        const horizontalResolution = iterator.getFixedPointUnsigned1616Number();
+        const verticalResolution = iterator.getFixedPointUnsigned1616Number();
         const dataSize = iterator.getUint32();
         const frameCountPerSample = iterator.getUint16();
         const compressorName = iterator.getPascalString();
         const depth = iterator.getUint16();
         const colorTableId = iterator.getInt16();
         const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - fileOffset);
-        iterator.discard(bytesRemainingInBox);
+        const children = await (0, process_box_1.parseBoxes)({
+            iterator,
+            allowIncompleteBoxes: false,
+            maxBytes: bytesRemainingInBox,
+            initialBoxes: [],
+            options,
+            continueMdat: false,
+        });
+        if (children.status === 'incomplete') {
+            throw new Error('Incomplete boxes are not allowed');
+        }
         return {
             sample: {
                 format: boxFormat,
@@ -212,19 +227,21 @@ const processSample = ({ iterator, }) => {
                 compressorName,
                 depth,
                 colorTableId,
+                descriptors: children.segments,
             },
         };
     }
     throw new Error(`Unknown sample format ${boxFormat}`);
 };
 exports.processSample = processSample;
-const parseSamples = (iterator, maxBytes) => {
+const parseSamples = async ({ iterator, maxBytes, options, }) => {
     const samples = [];
     const initialOffset = iterator.counter.getOffset();
     while (iterator.bytesRemaining() > 0 &&
         iterator.counter.getOffset() - initialOffset < maxBytes) {
-        const { sample } = (0, exports.processSample)({
+        const { sample } = await (0, exports.processSample)({
             iterator,
+            options,
         });
         if (sample) {
             samples.push(sample);

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

@@ -1,4 +1,5 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { ParserContext } from '../../../parser-context';
 import type { BaseBox } from '../base-type';
 import type { Sample } from './samples';
 export interface StsdBox extends BaseBox {
@@ -6,8 +7,9 @@ export interface StsdBox extends BaseBox {
     numberOfEntries: number;
     samples: Sample[];
 }
-export declare const parseStsd: ({ iterator, offset, size, }: {
+export declare const parseStsd: ({ iterator, offset, size, options, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
-}) => StsdBox;
+    options: ParserContext;
+}) => Promise<StsdBox>;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStsd = void 0;
 const samples_1 = require("./samples");
-const parseStsd = ({ iterator, offset, size, }) => {
+const parseStsd = async ({ iterator, offset, size, options, }) => {
     const version = iterator.getUint8();
     if (version !== 0) {
         throw new Error(`Unsupported STSD version ${version}`);
@@ -11,7 +11,11 @@ const parseStsd = ({ iterator, offset, size, }) => {
     iterator.discard(3);
     const numberOfEntries = iterator.getUint32();
     const bytesRemainingInBox = size - (iterator.counter.getOffset() - offset);
-    const boxes = (0, samples_1.parseSamples)(iterator, bytesRemainingInBox);
+    const boxes = await (0, samples_1.parseSamples)({
+        iterator,
+        maxBytes: bytesRemainingInBox,
+        options,
+    });
     if (boxes.length !== numberOfEntries) {
         throw new Error(`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`);
     }

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

@@ -0,0 +1,13 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+import type { BaseBox } from '../base-type';
+export interface StssBox extends BaseBox {
+    type: 'stss-box';
+    version: number;
+    flags: number[];
+    sampleNumber: number[];
+}
+export declare const parseStss: ({ iterator, offset, boxSize, }: {
+    iterator: BufferIterator;
+    offset: number;
+    boxSize: number;
+}) => StssBox;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStss = void 0;
+const parseStss = ({ iterator, offset, boxSize, }) => {
+    const version = iterator.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STSS version ${version}`);
+    }
+    const flags = iterator.getSlice(3);
+    const sampleCount = iterator.getUint32();
+    const sampleNumber = [];
+    for (let i = 0; i < sampleCount; i++) {
+        sampleNumber.push(iterator.getUint32());
+    }
+    const bytesRemainingInBox = boxSize - (iterator.counter.getOffset() - offset);
+    if (bytesRemainingInBox > 0) {
+        throw new Error(`Unexpected bytes remaining in box stss`);
+    }
+    return {
+        type: 'stss-box',
+        version,
+        flags: [...flags],
+        sampleNumber,
+        boxSize,
+        offset,
+    };
+};
+exports.parseStss = parseStss;

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

@@ -1,15 +1,21 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { BaseBox } from '../base-type';
+type Discriminated = {
+    countType: 'fixed';
+    sampleSize: number;
+} | {
+    countType: 'variable';
+    entries: number[];
+};
 export type StszBox = BaseBox & {
     type: 'stsz-box';
     version: number;
     flags: number[];
-    sampleSize: number;
     sampleCount: number;
-    samples: number[];
-};
+} & Discriminated;
 export declare const parseStsz: ({ iterator, offset, size, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
 }) => StszBox;
+export {};

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

@@ -9,6 +9,18 @@ const parseStsz = ({ iterator, offset, size, }) => {
     const flags = iterator.getSlice(3);
     const sampleSize = iterator.getUint32();
     const sampleCount = iterator.getUint32();
+    if (sampleSize !== 0) {
+        return {
+            type: 'stsz-box',
+            boxSize: size,
+            offset,
+            version,
+            flags: [...flags],
+            sampleCount,
+            countType: 'fixed',
+            sampleSize,
+        };
+    }
     const samples = [];
     for (let i = 0; i < sampleCount; i++) {
         const bytesRemaining = size - (iterator.counter.getOffset() - offset);
@@ -24,9 +36,9 @@ const parseStsz = ({ iterator, offset, size, }) => {
         offset,
         version,
         flags: [...flags],
-        sampleSize,
         sampleCount,
-        samples,
+        countType: 'variable',
+        entries: samples,
     };
 };
 exports.parseStsz = parseStsz;

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

@@ -0,0 +1,15 @@
+import type { BufferIterator } from '../../../buffer-iterator';
+export interface SttsBox {
+    type: 'stts-box';
+    sampleDistribution: SampleDistribution[];
+}
+type SampleDistribution = {
+    sampleCount: number;
+    sampleDelta: number;
+};
+export declare const parseStts: ({ data, size, fileOffset, }: {
+    data: BufferIterator;
+    size: number;
+    fileOffset: number;
+}) => SttsBox;
+export {};

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStts = void 0;
+const parseStts = ({ data, size, fileOffset, }) => {
+    const initialOffset = data.counter.getOffset();
+    const initialCounter = initialOffset - fileOffset;
+    const version = data.getUint8();
+    if (version !== 0) {
+        throw new Error(`Unsupported STTS version ${version}`);
+    }
+    // flags, we discard them
+    data.discard(3);
+    // entry count
+    const entryCount = data.getUint32();
+    const sampleDistributions = [];
+    // entries
+    for (let i = 0; i < entryCount; i++) {
+        const sampleCount = data.getUint32();
+        const sampleDelta = data.getUint32();
+        const sampleDistribution = {
+            sampleCount,
+            sampleDelta,
+        };
+        sampleDistributions.push(sampleDistribution);
+    }
+    const bytesUsed = data.counter.getOffset() - initialOffset + initialCounter;
+    if (bytesUsed !== size) {
+        throw new Error(`Expected stts box to be ${size} bytes, but was ${bytesUsed} bytes`);
+    }
+    return {
+        type: 'stts-box',
+        sampleDistribution: sampleDistributions,
+    };
+};
+exports.parseStts = parseStts;

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

@@ -14,6 +14,9 @@ export interface TkhdBox extends BaseBox {
     matrix: ThreeDMatrix;
     width: number;
     height: number;
+    unrotatedWidth: number;
+    unrotatedHeight: number;
+    rotation: number;
 }
 export declare const parseTkhd: ({ iterator, offset, size, }: {
     iterator: BufferIterator;

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

@@ -2,6 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTkhd = void 0;
 const to_date_1 = require("./to-date");
+function getRotationAngleFromMatrix(matrix) {
+    // Extract elements from the matrix
+    const [a, b, c, d] = matrix;
+    // Check if the matrix is a valid rotation matrix
+    if (Math.round(a * a + b * b) !== 1 || Math.round(c * c + d * d) !== 1) {
+        throw new Error('The provided matrix is not a valid rotation matrix.');
+    }
+    // Calculate the angle using the atan2 function
+    const angleRadians = Math.atan2(c, a); // atan2(sin(θ), cos(θ))
+    const angleDegrees = angleRadians * (180 / Math.PI); // Convert radians to degrees
+    return angleDegrees;
+}
+const applyRotation = ({ matrix, width, height, }) => {
+    const newWidth = matrix[0] * width + matrix[1] * height; // 0*3840 + 1*2160
+    const newHeight = matrix[2] * width + matrix[3] * height; // -1*3840 + 0*2160
+    return {
+        width: Math.abs(newWidth),
+        height: Math.abs(newHeight),
+    };
+};
 const parseTkhd = ({ iterator, offset, size, }) => {
     if (size !== 92) {
         throw new Error(`Expected tkhd size of version 0 to be 92, got ${size}`);
@@ -28,21 +48,25 @@ const parseTkhd = ({ iterator, offset, size, }) => {
     // reserved 4
     iterator.discard(2);
     const matrix = [
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
-        iterator.getUint32(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned1616Number(),
+        iterator.getFixedPointSigned230Number(),
     ];
-    const widthWithoutRotationApplied = iterator.getUint32() / (matrix[0] === 0 ? 1 : matrix[0]);
-    const heightWithoutRotationApplied = iterator.getUint32() / (matrix[4] === 0 ? 1 : matrix[4]);
-    // TODO: This is not correct, HEVC videos with matrix is wrong
-    const width = widthWithoutRotationApplied / (matrix[1] === 0 ? 1 : matrix[1]);
-    const height = heightWithoutRotationApplied / (matrix[1] === 0 ? 1 : matrix[1]);
+    const rotationMatrix = [matrix[0], matrix[1], matrix[3], matrix[4]];
+    const widthWithoutRotationApplied = iterator.getFixedPointUnsigned1616Number();
+    const heightWithoutRotationApplied = iterator.getFixedPointSigned1616Number();
+    const { width, height } = applyRotation({
+        matrix: rotationMatrix,
+        width: widthWithoutRotationApplied,
+        height: heightWithoutRotationApplied,
+    });
+    const rotation = getRotationAngleFromMatrix(rotationMatrix);
     return {
         offset,
         boxSize: size,
@@ -58,6 +82,9 @@ const parseTkhd = ({ iterator, offset, size, }) => {
         width,
         height,
         version,
+        rotation,
+        unrotatedWidth: widthWithoutRotationApplied,
+        unrotatedHeight: heightWithoutRotationApplied,
     };
 };
 exports.parseTkhd = parseTkhd;

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

@@ -1,12 +1,14 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { AnySegment } from '../../../parse-result';
+import type { ParserContext } from '../../../parser-context';
 import type { BaseBox } from '../base-type';
 export interface TrakBox extends BaseBox {
     type: 'trak-box';
     children: AnySegment[];
 }
-export declare const parseTrak: ({ data, size, offsetAtStart, }: {
+export declare const parseTrak: ({ data, size, offsetAtStart, options, }: {
     data: BufferIterator;
     size: number;
     offsetAtStart: number;
-}) => TrakBox;
+    options: ParserContext;
+}) => Promise<TrakBox>;

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

@@ -2,12 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTrak = void 0;
 const process_box_1 = require("../process-box");
-const parseTrak = ({ data, size, offsetAtStart, }) => {
-    const children = (0, process_box_1.parseBoxes)({
+const parseTrak = async ({ data, size, offsetAtStart, options, }) => {
+    const children = await (0, process_box_1.parseBoxes)({
         iterator: data,
         maxBytes: size - (data.counter.getOffset() - offsetAtStart),
         allowIncompleteBoxes: false,
         initialBoxes: [],
+        options,
+        continueMdat: false,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

package/dist/boxes/iso-base-media/void-box.d.ts

@@ -0,0 +1,4 @@
+export interface VoidBox {
+    type: 'void-box';
+    boxSize: number;
+}

package/dist/boxes/iso-base-media/void-box.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/boxes/webm/allowed-partial-segments.d.ts

@@ -0,0 +1 @@
+export declare const allowedPartialSegments: string[];

package/dist/boxes/webm/allowed-partial-segments.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowedPartialSegments = void 0;
+exports.allowedPartialSegments = ['0x1f43b675', '0x18538067'];

package/dist/boxes/webm/av1-codec-private.d.ts

@@ -0,0 +1,2 @@
+import type { ColorParameterBox } from '../iso-base-media/stsd/colr';
+export declare const parseAv1PrivateData: (data: Uint8Array, colrAtom: ColorParameterBox | null) => string;