@remotion/media-parser 4.0.248 → 4.0.250

package/dist/boxes/webm/segments.js

@@ -1,152 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectSegment = void 0;
+const log_1 = require("../../log");
 const parse_ebml_1 = require("./parse-ebml");
-const parse_children_1 = require("./segments/parse-children");
-const continueAfterMatroskaParseResult = async ({ result, iterator, state, segment, }) => {
-    if (result.status === 'done') {
-        throw new Error('Should not continue after done');
-    }
-    const proceeded = await result.continueParsing();
-    if (proceeded.status === 'done') {
-        return {
-            status: 'done',
-            segment,
-        };
-    }
-    return {
-        continueParsing() {
-            return continueAfterMatroskaParseResult({
-                result: proceeded,
-                iterator,
-                state,
-                segment,
-            });
-        },
-        segment: null,
-        status: 'incomplete',
-    };
-};
-const expectSegment = async ({ iterator, state, offset, children, fields, topLevelStructure, }) => {
-    iterator.counter.decrement(iterator.counter.getOffset() - offset);
+const all_segments_1 = require("./segments/all-segments");
+const expectSegment = async ({ iterator, state, isInsideSegment, }) => {
+    var _a;
     if (iterator.bytesRemaining() === 0) {
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, parse_children_1.expectAndProcessSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            segment: null,
-        };
+        throw new Error('has no bytes');
     }
+    const offset = iterator.counter.getOffset();
+    const { returnToCheckpoint } = iterator.startCheckpoint();
     const segmentId = iterator.getMatroskaSegmentId();
     if (segmentId === null) {
-        iterator.counter.decrement(iterator.counter.getOffset() - offset);
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, parse_children_1.expectAndProcessSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            segment: null,
-        };
+        returnToCheckpoint();
+        return null;
     }
     const offsetBeforeVInt = iterator.counter.getOffset();
-    const length = iterator.getVint();
+    const size = iterator.getVint();
     const offsetAfterVInt = iterator.counter.getOffset();
-    if (length === null) {
-        iterator.counter.decrement(iterator.counter.getOffset() - offset);
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, exports.expectSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            segment: null,
-        };
+    if (size === null) {
+        returnToCheckpoint();
+        return null;
     }
-    const bytesRemainingNow = iterator.byteLength() - iterator.counter.getOffset();
-    if (segmentId === '0x18538067' || segmentId === '0x1f43b675') {
+    const bytesRemainingNow = iterator.bytesRemaining();
+    log_1.Log.trace(state.logLevel, 'Segment ID:', (_a = all_segments_1.ebmlMap[segmentId]) === null || _a === void 0 ? void 0 : _a.name, 'Size:' + size, bytesRemainingNow);
+    if (segmentId === all_segments_1.matroskaElements.Segment) {
+        state.webm.addSegment({
+            start: offset,
+            size,
+        });
         const newSegment = {
-            type: segmentId === '0x18538067' ? 'Segment' : 'Cluster',
+            type: 'Segment',
             minVintWidth: offsetAfterVInt - offsetBeforeVInt,
             value: [],
         };
-        const main = await (0, parse_children_1.expectChildren)({
-            iterator,
-            length,
-            children: newSegment.value,
-            state,
-            startOffset: iterator.counter.getOffset(),
-            fields,
-            topLevelStructure,
-        });
-        if (main.status === 'incomplete') {
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return continueAfterMatroskaParseResult({
-                        iterator,
-                        state,
-                        result: main,
-                        segment: newSegment,
-                    });
-                },
-                segment: newSegment,
-            };
+        return newSegment;
+    }
+    if (segmentId === all_segments_1.matroskaElements.Cluster) {
+        if (isInsideSegment === null) {
+            throw new Error('Expected to be inside segment');
         }
-        return {
-            status: 'done',
-            segment: newSegment,
+        state.webm.addCluster({
+            start: offset,
+            size,
+            segment: isInsideSegment.index,
+        });
+        const newSegment = {
+            type: 'Cluster',
+            minVintWidth: offsetAfterVInt - offsetBeforeVInt,
+            value: [],
         };
+        return newSegment;
     }
-    if (bytesRemainingNow < length) {
-        const bytesRead = iterator.counter.getOffset() - offset;
-        iterator.counter.decrement(bytesRead);
-        return {
-            status: 'incomplete',
-            segment: null,
-            continueParsing: () => {
-                return (0, exports.expectSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-        };
+    if (bytesRemainingNow < size) {
+        returnToCheckpoint();
+        return null;
     }
     const segment = await parseSegment({
         segmentId,
         iterator,
-        length,
+        length: size,
         state,
         headerReadSoFar: iterator.counter.getOffset() - offset,
     });
-    return {
-        status: 'done',
-        segment,
-    };
+    return segment;
 };
 exports.expectSegment = expectSegment;
 const parseSegment = async ({ segmentId, iterator, length, state, headerReadSoFar, }) => {

package/dist/buffer-iterator.d.ts

@@ -18,7 +18,6 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     peekB: (length: number) => void;
     peekD: (length: number) => void;
     getBits: (bits: number) => number;
-    byteLength: () => number;
     bytesRemaining: () => number;
     leb128: () => number;
     removeBytesRead: () => void;
@@ -48,6 +47,9 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     getPascalString: () => number[];
     getUint(length: number): number;
     getByteString(length: number, trimTrailingZeroes: boolean): string;
+    planBytes: (size: number) => {
+        discardRest: () => Uint8Array;
+    };
     getFloat64: () => number;
     readUntilNullTerminator: () => string;
     getFloat32: () => number;
@@ -55,12 +57,13 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     getInt32Le: () => number;
     getInt32: () => number;
     destroy: () => void;
-    disallowDiscard: () => void;
-    allowDiscard: () => void;
     startBox: (size: number) => {
         discardRest: () => void;
         expectNoMoreBytes: () => void;
     };
     readExpGolomb: () => number;
+    startCheckpoint: () => {
+        returnToCheckpoint: () => void;
+    };
 };
 export type BufferIterator = ReturnType<typeof getArrayBufferIterator>;

package/dist/buffer-iterator.js

@@ -69,18 +69,19 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     data.set(initialData);
     let view = new DataView(data.buffer);
     const counter = makeOffsetCounter();
-    let discardAllowed = true;
+    const startCheckpoint = () => {
+        const checkpoint = counter.getOffset();
+        return {
+            returnToCheckpoint: () => {
+                counter.decrement(counter.getOffset() - checkpoint);
+            },
+        };
+    };
     const getSlice = (amount) => {
         const value = data.slice(counter.getDiscardedOffset(), counter.getDiscardedOffset() + amount);
         counter.increment(amount);
         return value;
     };
-    const disallowDiscard = () => {
-        discardAllowed = false;
-    };
-    const allowDiscard = () => {
-        discardAllowed = true;
-    };
     const discard = (length) => {
         counter.increment(length);
     };
@@ -191,22 +192,22 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     const addData = (newData) => {
         const oldLength = buf.byteLength;
         const newLength = oldLength + newData.byteLength;
+        if (newLength < oldLength) {
+            throw new Error('Cannot decrement size');
+        }
+        if (newLength > (maxBytes !== null && maxBytes !== void 0 ? maxBytes : Infinity)) {
+            throw new Error(`Exceeded maximum byte length ${maxBytes} with ${newLength}`);
+        }
         buf.resize(newLength);
         const newArray = new Uint8Array(buf);
         newArray.set(newData, oldLength);
         data = newArray;
         view = new DataView(data.buffer);
     };
-    const byteLength = () => {
-        return data.byteLength;
-    };
     const bytesRemaining = () => {
         return data.byteLength - counter.getDiscardedOffset();
     };
     const removeBytesRead = () => {
-        if (!discardAllowed) {
-            return;
-        }
         const bytesToRemove = counter.getDiscardedOffset();
         // Only do this operation if it is really worth it 😇
         if (bytesToRemove < 100000) {
@@ -323,7 +324,6 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         peekB,
         peekD,
         getBits,
-        byteLength,
         bytesRemaining,
         leb128,
         removeBytesRead,
@@ -501,6 +501,18 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
             }
             return new TextDecoder().decode(bytes).trim();
         },
+        planBytes: (size) => {
+            const currentOffset = counter.getOffset();
+            return {
+                discardRest: () => {
+                    const toDiscard = size - (counter.getOffset() - currentOffset);
+                    if (toDiscard < 0) {
+                        throw new Error('read too many bytes');
+                    }
+                    return getSlice(toDiscard);
+                },
+            };
+        },
         getFloat64: () => {
             const val = view.getFloat64(counter.getDiscardedOffset());
             counter.increment(8);
@@ -516,10 +528,9 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         getInt32Le,
         getInt32,
         destroy,
-        disallowDiscard,
-        allowDiscard,
         startBox,
         readExpGolomb,
+        startCheckpoint,
     };
 };
 exports.getArrayBufferIterator = getArrayBufferIterator;

package/dist/bun-reader.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bun-reader.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const example_videos_1 = require("@remotion/example-videos");
+const fs_1 = require("fs");
+const stream_1 = require("stream");
+const range = null;
+const stream = (0, fs_1.createReadStream)(example_videos_1.exampleVideos.framer24fps, {
+    start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+    end: range === null ? Infinity : typeof range === 'number' ? Infinity : range[1],
+});
+const reader = stream_1.Readable.toWeb(stream).getReader();
+console.log(await reader.read());
+console.log(await reader.read());
+console.log(await reader.read());
+console.log(await reader.read());
+console.log(await reader.read());
+console.log(await reader.read());

package/dist/continue-mdat-routine.d.ts

@@ -0,0 +1,17 @@
+import type { BufferIterator } from './buffer-iterator';
+import type { LogLevel } from './log';
+import type { Options, ParseMediaFields } from './options';
+import type { IsoBaseMediaBox, ParseResult } from './parse-result';
+import type { PartialMdatBox } from './parse-video';
+import type { ParserState } from './state/parser-state';
+export declare const continueMdatRoutine: ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, continueMdat, signal, logLevel, fields, }: {
+    iterator: BufferIterator;
+    maxBytes: number;
+    allowIncompleteBoxes: boolean;
+    initialBoxes: IsoBaseMediaBox[];
+    state: ParserState;
+    continueMdat: PartialMdatBox;
+    signal: AbortSignal | null;
+    logLevel: LogLevel;
+    fields: Options<ParseMediaFields>;
+}) => Promise<ParseResult>;

package/dist/continue-mdat-routine.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.continueMdatRoutine = void 0;
+const parse_boxes_1 = require("./boxes/iso-base-media/parse-boxes");
+const parse_mdat_partially_1 = require("./boxes/iso-base-media/parse-mdat-partially");
+const traversal_1 = require("./boxes/iso-base-media/traversal");
+const has_all_info_1 = require("./has-all-info");
+const may_skip_video_data_1 = require("./may-skip-video-data/may-skip-video-data");
+const continueMdatRoutine = async ({ iterator, maxBytes, allowIncompleteBoxes, initialBoxes, state, continueMdat, signal, logLevel, fields, }) => {
+    var _a;
+    const initialOffset = iterator.counter.getOffset();
+    while (iterator.bytesRemaining() > 0 &&
+        iterator.counter.getOffset() - initialOffset < maxBytes) {
+        const result = await (0, parse_mdat_partially_1.parseMdatPartially)({
+            iterator,
+            boxSize: continueMdat.boxSize,
+            fileOffset: continueMdat.fileOffset,
+            parsedBoxes: initialBoxes,
+            state,
+            signal,
+        });
+        if (result.type === 'incomplete') {
+            throw new Error('Incomplete boxes are not allowed in this routine');
+        }
+        if (result.type === 'partial-mdat-box') {
+            return {
+                status: 'incomplete',
+                continueParsing: () => {
+                    return Promise.resolve((0, exports.continueMdatRoutine)({
+                        iterator,
+                        maxBytes,
+                        allowIncompleteBoxes,
+                        initialBoxes,
+                        state,
+                        continueMdat: result,
+                        signal,
+                        logLevel,
+                        fields,
+                    }));
+                },
+                skipTo: null,
+            };
+        }
+        const alreadyHasMdat = (_a = state.structure
+            .getStructureOrNull()) === null || _a === void 0 ? void 0 : _a.boxes.find((b) => b.type === 'mdat-box');
+        if (result.box.type === 'mdat-box' && alreadyHasMdat) {
+            initialBoxes = initialBoxes.filter((b) => b.type !== 'mdat-box');
+            initialBoxes.push(result.box);
+            iterator.allowDiscard();
+            break;
+        }
+        else {
+            initialBoxes.push(result.box);
+            if ((0, has_all_info_1.hasAllInfo)({ fields, state })) {
+                return {
+                    status: 'done',
+                };
+            }
+        }
+        iterator.removeBytesRead();
+    }
+    const mdatState = (0, traversal_1.getMdatBox)(initialBoxes);
+    const skipped = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-skipped' &&
+        !(0, may_skip_video_data_1.maySkipVideoData)({ state }) &&
+        state.supportsContentRange;
+    const buffered = (mdatState === null || mdatState === void 0 ? void 0 : mdatState.status) === 'samples-buffered' && !(0, may_skip_video_data_1.maySkipVideoData)({ state });
+    if (skipped || buffered) {
+        return {
+            status: 'incomplete',
+            continueParsing: () => {
+                if (buffered) {
+                    iterator.skipTo(mdatState.fileOffset, false);
+                }
+                return (0, parse_boxes_1.parseIsoBaseMediaBoxes)({
+                    iterator,
+                    maxBytes,
+                    allowIncompleteBoxes: false,
+                    initialBoxes,
+                    state,
+                    signal,
+                    logLevel,
+                    fields,
+                });
+            },
+            skipTo: skipped ? mdatState.fileOffset : null,
+        };
+    }
+    return {
+        status: 'done',
+    };
+};
+exports.continueMdatRoutine = continueMdatRoutine;

package/dist/emit-available-info.js

@@ -13,7 +13,7 @@ const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
 const get_metadata_1 = require("./metadata/get-metadata");
 const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue, contentLength, name, mimeType, fieldsInReturnValue, }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
     const keys = Object.keys(hasInfo);
     const segments = state.structure.getStructureOrNull();
     const { emittedFields } = state;
@@ -102,10 +102,12 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
                 parseResult &&
                 segments) {
                 const dimensionsQueried = (0, get_dimensions_1.getDimensions)(segments, state);
-                const dimensions = {
-                    height: dimensionsQueried.height,
-                    width: dimensionsQueried.width,
-                };
+                const dimensions = dimensionsQueried === null
+                    ? null
+                    : {
+                        height: dimensionsQueried.height,
+                        width: dimensionsQueried.width,
+                    };
                 (_h = callbacks.onDimensions) === null || _h === void 0 ? void 0 : _h.call(callbacks, dimensions);
                 if (fieldsInReturnValue.dimensions) {
                     returnValue.dimensions = dimensions;
@@ -120,10 +122,12 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
                 parseResult &&
                 segments) {
                 const dimensionsQueried = (0, get_dimensions_1.getDimensions)(segments, state);
-                const unrotatedDimensions = {
-                    height: dimensionsQueried.unrotatedHeight,
-                    width: dimensionsQueried.unrotatedWidth,
-                };
+                const unrotatedDimensions = dimensionsQueried === null
+                    ? null
+                    : {
+                        height: dimensionsQueried.unrotatedHeight,
+                        width: dimensionsQueried.unrotatedWidth,
+                    };
                 (_j = callbacks.onUnrotatedDimensions) === null || _j === void 0 ? void 0 : _j.call(callbacks, unrotatedDimensions);
                 if (fieldsInReturnValue.unrotatedDimensions) {
                     returnValue.unrotatedDimensions = unrotatedDimensions;
@@ -138,8 +142,8 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
                 parseResult &&
                 segments) {
                 const dimensionsQueried = (0, get_dimensions_1.getDimensions)(segments, state);
-                const { rotation } = dimensionsQueried;
-                (_k = callbacks.onRotation) === null || _k === void 0 ? void 0 : _k.call(callbacks, rotation);
+                const rotation = (_k = dimensionsQueried === null || dimensionsQueried === void 0 ? void 0 : dimensionsQueried.rotation) !== null && _k !== void 0 ? _k : 0;
+                (_l = callbacks.onRotation) === null || _l === void 0 ? void 0 : _l.call(callbacks, rotation);
                 if (fieldsInReturnValue.rotation) {
                     returnValue.rotation = rotation;
                 }
@@ -152,8 +156,8 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
                 hasInfo.videoCodec &&
                 parseResult &&
                 segments) {
-                const videoCodec = (0, get_video_codec_1.getVideoCodec)(segments, state);
-                (_l = callbacks.onVideoCodec) === null || _l === void 0 ? void 0 : _l.call(callbacks, videoCodec);
+                const videoCodec = (0, get_video_codec_1.getVideoCodec)(state);
+                (_m = callbacks.onVideoCodec) === null || _m === void 0 ? void 0 : _m.call(callbacks, videoCodec);
                 if (fieldsInReturnValue.videoCodec) {
                     returnValue.videoCodec = videoCodec;
                 }
@@ -166,8 +170,8 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
                 hasInfo.audioCodec &&
                 parseResult &&
                 segments) {
-                const audioCodec = (0, get_audio_codec_1.getAudioCodec)(segments, state);
-                (_m = callbacks.onAudioCodec) === null || _m === void 0 ? void 0 : _m.call(callbacks, audioCodec);
+                const audioCodec = (0, get_audio_codec_1.getAudioCodec)(state);
+                (_o = callbacks.onAudioCodec) === null || _o === void 0 ? void 0 : _o.call(callbacks, audioCodec);
                 if (fieldsInReturnValue.audioCodec) {
                     returnValue.audioCodec = audioCodec;
                 }
@@ -177,8 +181,8 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
         }
         if (key === 'tracks') {
             if (!emittedFields.tracks && hasInfo.tracks && parseResult && segments) {
-                const { videoTracks, audioTracks } = (0, get_tracks_1.getTracks)(segments, state);
-                (_o = callbacks.onTracks) === null || _o === void 0 ? void 0 : _o.call(callbacks, { videoTracks, audioTracks });
+                const { videoTracks, audioTracks } = (0, get_tracks_1.getTracks)(state);
+                (_p = callbacks.onTracks) === null || _p === void 0 ? void 0 : _p.call(callbacks, { videoTracks, audioTracks });
                 if (fieldsInReturnValue.tracks) {
                     returnValue.tracks = { videoTracks, audioTracks };
                 }
@@ -199,7 +203,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
         }
         if (key === 'size') {
             if (!emittedFields.size && hasInfo.size) {
-                (_p = callbacks.onSize) === null || _p === void 0 ? void 0 : _p.call(callbacks, contentLength);
+                (_q = callbacks.onSize) === null || _q === void 0 ? void 0 : _q.call(callbacks, contentLength);
                 if (fieldsInReturnValue.size) {
                     returnValue.size = contentLength;
                 }
@@ -209,7 +213,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
         }
         if (key === 'mimeType') {
             if (!emittedFields.mimeType && hasInfo.mimeType) {
-                (_q = callbacks.onMimeType) === null || _q === void 0 ? void 0 : _q.call(callbacks, mimeType);
+                (_r = callbacks.onMimeType) === null || _r === void 0 ? void 0 : _r.call(callbacks, mimeType);
                 if (fieldsInReturnValue.mimeType) {
                     returnValue.mimeType = mimeType;
                 }
@@ -219,7 +223,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
         }
         if (key === 'name') {
             if (!emittedFields.name && hasInfo.name) {
-                (_r = callbacks.onName) === null || _r === void 0 ? void 0 : _r.call(callbacks, name);
+                (_s = callbacks.onName) === null || _s === void 0 ? void 0 : _s.call(callbacks, name);
                 if (fieldsInReturnValue.name) {
                     returnValue.name = name;
                 }
@@ -229,8 +233,8 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
         }
         if (key === 'isHdr') {
             if (!returnValue.isHdr && hasInfo.isHdr && parseResult && segments) {
-                const isHdr = (0, get_is_hdr_1.getIsHdr)(segments, state);
-                (_s = callbacks.onIsHdr) === null || _s === void 0 ? void 0 : _s.call(callbacks, isHdr);
+                const isHdr = (0, get_is_hdr_1.getIsHdr)(state);
+                (_t = callbacks.onIsHdr) === null || _t === void 0 ? void 0 : _t.call(callbacks, isHdr);
                 if (fieldsInReturnValue.isHdr) {
                     returnValue.isHdr = isHdr;
                 }
@@ -244,7 +248,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
                 parseResult &&
                 segments) {
                 const container = (0, get_container_1.getContainer)(segments);
-                (_t = callbacks.onContainer) === null || _t === void 0 ? void 0 : _t.call(callbacks, container);
+                (_u = callbacks.onContainer) === null || _u === void 0 ? void 0 : _u.call(callbacks, container);
                 if (fieldsInReturnValue.container) {
                     returnValue.container = container;
                 }
@@ -258,7 +262,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
                 parseResult &&
                 segments) {
                 const metadata = (0, get_metadata_1.getMetadata)(segments);
-                (_u = callbacks.onMetadata) === null || _u === void 0 ? void 0 : _u.call(callbacks, metadata);
+                (_v = callbacks.onMetadata) === null || _v === void 0 ? void 0 : _v.call(callbacks, metadata);
                 if (fieldsInReturnValue.metadata) {
                     returnValue.metadata = metadata;
                 }
@@ -272,7 +276,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
                 parseResult &&
                 segments) {
                 const location = (0, get_location_1.getLocation)(segments);
-                (_v = callbacks.onLocation) === null || _v === void 0 ? void 0 : _v.call(callbacks, location);
+                (_w = callbacks.onLocation) === null || _w === void 0 ? void 0 : _w.call(callbacks, location);
                 if (fieldsInReturnValue.location) {
                     returnValue.location = location;
                 }
@@ -284,7 +288,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
             if (!emittedFields.slowKeyframes &&
                 hasInfo.slowKeyframes &&
                 parseResult) {
-                (_w = callbacks.onSlowKeyframes) === null || _w === void 0 ? void 0 : _w.call(callbacks, state.keyframes.getKeyframes());
+                (_x = callbacks.onSlowKeyframes) === null || _x === void 0 ? void 0 : _x.call(callbacks, state.keyframes.getKeyframes());
                 if (fieldsInReturnValue.slowKeyframes) {
                     returnValue.slowKeyframes = state.keyframes.getKeyframes();
                 }
@@ -296,7 +300,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
             if (!emittedFields.slowNumberOfFrames &&
                 hasInfo.slowNumberOfFrames &&
                 parseResult) {
-                (_x = callbacks.onSlowNumberOfFrames) === null || _x === void 0 ? void 0 : _x.call(callbacks, state.slowDurationAndFps.getSlowNumberOfFrames());
+                (_y = callbacks.onSlowNumberOfFrames) === null || _y === void 0 ? void 0 : _y.call(callbacks, state.slowDurationAndFps.getSlowNumberOfFrames());
                 if (fieldsInReturnValue.slowNumberOfFrames) {
                     returnValue.slowNumberOfFrames =
                         state.slowDurationAndFps.getSlowNumberOfFrames();
@@ -307,7 +311,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
         }
         if (key === 'keyframes') {
             if (!emittedFields.keyframes && hasInfo.keyframes && parseResult) {
-                (_y = callbacks.onKeyframes) === null || _y === void 0 ? void 0 : _y.call(callbacks, (0, get_keyframes_1.getKeyframes)(state.structure.getStructure()));
+                (_z = callbacks.onKeyframes) === null || _z === void 0 ? void 0 : _z.call(callbacks, (0, get_keyframes_1.getKeyframes)(state.structure.getStructure()));
                 if (fieldsInReturnValue.keyframes) {
                     returnValue.keyframes = (0, get_keyframes_1.getKeyframes)(state.structure.getStructure());
                 }
@@ -315,6 +319,16 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
             }
             continue;
         }
+        if (key === 'images') {
+            if (!emittedFields.images && hasInfo.images && parseResult) {
+                (_0 = callbacks.onImages) === null || _0 === void 0 ? void 0 : _0.call(callbacks, state.images.images);
+                if (fieldsInReturnValue.images) {
+                    returnValue.images = state.images.images;
+                }
+                emittedFields.images = true;
+            }
+            continue;
+        }
         throw new Error(`Unhandled key: ${key}`);
     }
 };