@remotion/media-parser 4.0.240 → 4.0.242

package/dist/create/iso-base-media/create-mvhd.d.ts

@@ -7,4 +7,4 @@ export declare const createMvhd: ({ timescale, durationInUnits, rate, volume, ne
     matrix: number[];
     creationTime: number | null;
     modificationTime: number | null;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

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

@@ -1,4 +1,4 @@
 export declare const createTrak: ({ tkhd, mdia, }: {
     tkhd: Uint8Array;
     mdia: Uint8Array;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/create-udta.d.ts

@@ -1 +1 @@
-export declare const createUdta: (children: Uint8Array) => Uint8Array;
+export declare const createUdta: (children: Uint8Array) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/create-url.d.ts

@@ -1 +1 @@
-export declare const createUrlAtom: () => Uint8Array;
+export declare const createUrlAtom: () => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/ilst/create-cmt.d.ts

@@ -1 +1 @@
-export declare const createCmt: (comment: string) => Uint8Array;
+export declare const createCmt: (comment: string) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/ilst/create-too.d.ts

@@ -1 +1 @@
-export declare const createToo: (value: string) => Uint8Array;
+export declare const createToo: (value: string) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/mdia/create-mdhd.d.ts

@@ -3,4 +3,4 @@ export declare const createMdhd: ({ creationTime, modificationTime, timescale, d
     modificationTime: number | null;
     timescale: number;
     duration: number;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/mp4-header.d.ts

@@ -3,4 +3,4 @@ export declare const createPaddedMoovAtom: ({ durationInUnits, trackInfo, timesc
     durationInUnits: number;
     trackInfo: IsoBaseMediaTrackData[];
     timescale: number;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/primitives.d.ts

@@ -1,15 +1,15 @@
 import type { ThreeDMatrix } from '../../boxes/iso-base-media/mvhd';
-export declare const stringsToUint8Array: (str: string) => Uint8Array;
-export declare const numberTo32BitUIntOrInt: (num: number) => Uint8Array;
-export declare const numberTo32BitUIntOrIntLeading128: (num: number) => Uint8Array;
-export declare const numberTo16BitUIntOrInt: (num: number) => Uint8Array;
-export declare const setFixedPointSignedOrUnsigned1616Number: (num: number) => Uint8Array;
-export declare const setFixedPointSigned230Number: (num: number) => Uint8Array;
-export declare const addSize: (arr: Uint8Array) => Uint8Array;
-export declare const addLeading128Size: (arr: Uint8Array) => Uint8Array;
-export declare const floatTo16Point1632Bit: (number: number) => Uint8Array;
-export declare const floatTo16Point16_16Bit: (number: number) => Uint8Array;
-export declare const serializeMatrix: (matrix: number[]) => Uint8Array;
-export declare const stringToPascalString: (str: string) => Uint8Array;
-export declare const padIsoBaseMediaBytes: (data: Uint8Array, totalLength: number) => Uint8Array;
+export declare const stringsToUint8Array: (str: string) => Uint8Array<ArrayBufferLike>;
+export declare const numberTo32BitUIntOrInt: (num: number) => Uint8Array<ArrayBuffer>;
+export declare const numberTo32BitUIntOrIntLeading128: (num: number) => Uint8Array<ArrayBuffer>;
+export declare const numberTo16BitUIntOrInt: (num: number) => Uint8Array<ArrayBuffer>;
+export declare const setFixedPointSignedOrUnsigned1616Number: (num: number) => Uint8Array<ArrayBuffer>;
+export declare const setFixedPointSigned230Number: (num: number) => Uint8Array<ArrayBuffer>;
+export declare const addSize: (arr: Uint8Array) => Uint8Array<ArrayBufferLike>;
+export declare const addLeading128Size: (arr: Uint8Array) => Uint8Array<ArrayBufferLike>;
+export declare const floatTo16Point1632Bit: (number: number) => Uint8Array<ArrayBuffer>;
+export declare const floatTo16Point16_16Bit: (number: number) => Uint8Array<ArrayBuffer>;
+export declare const serializeMatrix: (matrix: number[]) => Uint8Array<ArrayBufferLike>;
+export declare const stringToPascalString: (str: string) => Uint8Array<ArrayBuffer>;
+export declare const padIsoBaseMediaBytes: (data: Uint8Array, totalLength: number) => Uint8Array<ArrayBufferLike>;
 export declare const IDENTITY_MATRIX: ThreeDMatrix;

package/dist/create/iso-base-media/serialize-track.d.ts

@@ -6,4 +6,4 @@ export type IsoBaseMediaTrackData = {
     samplePositions: SamplePosition[];
     timescale: number;
 };
-export declare const serializeTrack: ({ track, durationInUnits, samplePositions, timescale, }: IsoBaseMediaTrackData) => Uint8Array;
+export declare const serializeTrack: ({ track, durationInUnits, samplePositions, timescale, }: IsoBaseMediaTrackData) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/create-tkhd.d.ts

@@ -12,7 +12,7 @@ export declare const createTkhdForAudio: ({ creationTime, modificationTime, flag
     duration: number;
     volume: number;
     timescale: number;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;
 export declare const createTkhdForVideo: ({ creationTime, modificationTime, duration, trackId, volume, matrix, width, height, flags, timescale, }: {
     creationTime: number | null;
     modificationTime: number | null;
@@ -24,4 +24,4 @@ export declare const createTkhdForVideo: ({ creationTime, modificationTime, dura
     height: number;
     flags: number;
     timescale: number;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/create-minf.d.ts

@@ -1,4 +1,4 @@
 export declare const createMinf: ({ vmhdAtom, stblAtom, }: {
     vmhdAtom: Uint8Array;
     stblAtom: Uint8Array;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/create-dinf.d.ts

@@ -1 +1 @@
-export declare const createDinf: () => Uint8Array;
+export declare const createDinf: () => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/create-smhd.d.ts

@@ -1 +1 @@
-export declare const createSmhd: () => Uint8Array;
+export declare const createSmhd: () => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/create-stbl.d.ts

@@ -3,4 +3,4 @@ export declare const createStbl: ({ samplePositions, codecSpecificData, isVideo,
     samplePositions: SamplePosition[];
     codecSpecificData: Uint8Array;
     isVideo: boolean;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/create-vmhd.d.ts

@@ -1 +1 @@
-export declare const createVmhd: () => Uint8Array;
+export declare const createVmhd: () => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-ctts.d.ts

@@ -1,2 +1,2 @@
 import type { SamplePosition } from '../../../../../../get-sample-positions';
-export declare const createCttsBox: (samplePositions: SamplePosition[]) => Uint8Array | null;
+export declare const createCttsBox: (samplePositions: SamplePosition[]) => Uint8Array<ArrayBufferLike> | null;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stco.d.ts

@@ -1,2 +1,2 @@
 import type { SamplePosition } from '../../../../../../get-sample-positions';
-export declare const createStcoAtom: (samplePositions: SamplePosition[]) => Uint8Array;
+export declare const createStcoAtom: (samplePositions: SamplePosition[]) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stsc.d.ts

@@ -1,2 +1,2 @@
 import type { SamplePosition } from '../../../../../../get-sample-positions';
-export declare const createStsc: (samplePositions: SamplePosition[]) => Uint8Array;
+export declare const createStsc: (samplePositions: SamplePosition[]) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stss.d.ts

@@ -1,2 +1,2 @@
 import type { SamplePosition } from '../../../../../../get-sample-positions';
-export declare const createStss: (samplePositions: SamplePosition[]) => Uint8Array;
+export declare const createStss: (samplePositions: SamplePosition[]) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stsz.d.ts

@@ -1,2 +1,2 @@
 import type { SamplePosition } from '../../../../../../get-sample-positions';
-export declare const createStsz: (samplePositions: SamplePosition[]) => Uint8Array;
+export declare const createStsz: (samplePositions: SamplePosition[]) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stts.d.ts

@@ -1,2 +1,2 @@
 import type { SamplePosition } from '../../../../../../get-sample-positions';
-export declare const createSttsAtom: (samplePositions: SamplePosition[]) => Uint8Array;
+export declare const createSttsAtom: (samplePositions: SamplePosition[]) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-avc1.d.ts

@@ -1 +1 @@
-export declare const createStsdData: (codecSpecificData: Uint8Array) => Uint8Array;
+export declare const createStsdData: (codecSpecificData: Uint8Array) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-avcc.d.ts

@@ -1 +1 @@
-export declare const createAvccBox: (privateData: Uint8Array | null) => Uint8Array;
+export declare const createAvccBox: (privateData: Uint8Array | null) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-pasp.d.ts

@@ -1 +1 @@
-export declare const createPasp: (x: number, y: number) => Uint8Array;
+export declare const createPasp: (x: number, y: number) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/udta/create-meta.d.ts

@@ -1,4 +1,4 @@
 export declare const createMeta: ({ hdlr, ilst, }: {
     hdlr: Uint8Array;
     ilst: Uint8Array;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/create/iso-base-media/udta/meta/create-hdlr.d.ts

@@ -1 +1 @@
-export declare const createHdlr: (type: "video" | "audio" | "mdir") => Uint8Array;
+export declare const createHdlr: (type: "video" | "audio" | "mdir") => Uint8Array<ArrayBufferLike>;

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

@@ -7,4 +7,4 @@ export declare const makeSimpleBlock: ({ bytes, trackNumber, timecodeRelativeToC
     keyframe: boolean;
     invisible: boolean;
     lacing: number;
-}) => Uint8Array;
+}) => Uint8Array<ArrayBufferLike>;

package/dist/emit-available-info.d.ts

@@ -1,12 +1,14 @@
 import type { AllParseMediaFields, Options, ParseMediaCallbacks, ParseMediaFields, ParseMediaResult } from './options';
-import type { ParseResult, Structure } from './parse-result';
+import type { ParseResult } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const emitAvailableInfo: ({ hasInfo, parseResult, moreFields, state, returnValue, contentLength, name, }: {
+export declare const emitAvailableInfo: ({ hasInfo, parseResult, callbacks, state, returnValue, contentLength, name, mimeType, fieldsInReturnValue, }: {
     hasInfo: Record<keyof Options<ParseMediaFields>, boolean>;
-    parseResult: ParseResult<Structure> | null;
-    moreFields: ParseMediaCallbacks<AllParseMediaFields>;
+    parseResult: ParseResult | null;
+    callbacks: ParseMediaCallbacks;
+    fieldsInReturnValue: Options<ParseMediaFields>;
     state: ParserState;
     returnValue: ParseMediaResult<AllParseMediaFields>;
     contentLength: number | null;
+    mimeType: string | null;
     name: string;
 }) => void;

package/dist/emit-available-info.js

@@ -7,109 +7,192 @@ const get_dimensions_1 = require("./get-dimensions");
 const get_duration_1 = require("./get-duration");
 const get_fps_1 = require("./get-fps");
 const get_is_hdr_1 = require("./get-is-hdr");
+const get_keyframes_1 = require("./get-keyframes");
 const get_location_1 = require("./get-location");
 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, moreFields, state, returnValue, contentLength, name, }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+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;
     const keys = Object.keys(hasInfo);
+    const segments = state.structure.getStructureOrNull();
+    const { emittedFields } = state;
     for (const key of keys) {
         if (key === 'structure') {
             if (parseResult &&
                 hasInfo.structure &&
-                returnValue.structure === undefined) {
-                (_a = moreFields.onStructure) === null || _a === void 0 ? void 0 : _a.call(moreFields, parseResult.segments);
-                returnValue.structure = parseResult.segments;
+                !emittedFields.structure &&
+                segments) {
+                (_a = callbacks.onStructure) === null || _a === void 0 ? void 0 : _a.call(callbacks, segments);
+                if (fieldsInReturnValue.structure) {
+                    returnValue.structure = segments;
+                }
+                emittedFields.structure = true;
             }
             continue;
         }
         if (key === 'durationInSeconds') {
-            if (hasInfo.durationInSeconds &&
-                returnValue.durationInSeconds === undefined &&
-                parseResult) {
-                const durationInSeconds = (0, get_duration_1.getDuration)(parseResult.segments, state);
-                (_b = moreFields.onDurationInSeconds) === null || _b === void 0 ? void 0 : _b.call(moreFields, durationInSeconds);
-                returnValue.durationInSeconds = durationInSeconds;
+            if (hasInfo.durationInSeconds && parseResult && segments) {
+                if (!emittedFields.durationInSeconds) {
+                    const durationInSeconds = (0, get_duration_1.getDuration)(segments, state);
+                    (_b = callbacks.onDurationInSeconds) === null || _b === void 0 ? void 0 : _b.call(callbacks, durationInSeconds);
+                    if (fieldsInReturnValue.durationInSeconds) {
+                        returnValue.durationInSeconds = durationInSeconds;
+                    }
+                    emittedFields.durationInSeconds = true;
+                }
+                if (!emittedFields.slowDurationInSeconds) {
+                    const durationInSeconds = (0, get_duration_1.getDuration)(segments, state);
+                    if (durationInSeconds !== null) {
+                        (_c = callbacks.onSlowDurationInSeconds) === null || _c === void 0 ? void 0 : _c.call(callbacks, durationInSeconds);
+                        if (fieldsInReturnValue.slowDurationInSeconds) {
+                            returnValue.slowDurationInSeconds = durationInSeconds;
+                        }
+                        emittedFields.slowDurationInSeconds = true;
+                    }
+                }
+            }
+            continue;
+        }
+        if (key === 'slowDurationInSeconds') {
+            if (hasInfo.slowDurationInSeconds &&
+                !emittedFields.slowDurationInSeconds &&
+                parseResult &&
+                segments) {
+                const slowDurationInSeconds = state.slowDurationAndFps.getSlowDurationInSeconds();
+                (_d = callbacks.onSlowDurationInSeconds) === null || _d === void 0 ? void 0 : _d.call(callbacks, slowDurationInSeconds);
+                if (fieldsInReturnValue.slowDurationInSeconds) {
+                    returnValue.slowDurationInSeconds = slowDurationInSeconds;
+                }
+                emittedFields.slowDurationInSeconds = true;
+            }
+            continue;
+        }
+        if (key === 'fps') {
+            if (hasInfo.fps && parseResult && segments) {
+                if (!emittedFields.fps) {
+                    const fps = (0, get_fps_1.getFps)(segments);
+                    (_e = callbacks.onFps) === null || _e === void 0 ? void 0 : _e.call(callbacks, fps);
+                    if (fieldsInReturnValue.fps) {
+                        returnValue.fps = fps;
+                    }
+                    emittedFields.fps = true;
+                }
+                if (!emittedFields.slowFps) {
+                    const fps = (0, get_fps_1.getFps)(segments);
+                    if (fps) {
+                        (_f = callbacks.onSlowFps) === null || _f === void 0 ? void 0 : _f.call(callbacks, fps);
+                        if (fieldsInReturnValue.slowFps) {
+                            returnValue.slowFps = fps;
+                        }
+                        emittedFields.slowFps = true;
+                    }
+                }
+            }
+            continue;
+        }
+        // must be handled after fps
+        if (key === 'slowFps') {
+            if (hasInfo.slowFps &&
+                !emittedFields.slowFps &&
+                parseResult &&
+                segments) {
+                const slowFps = state.slowDurationAndFps.getFps();
+                (_g = callbacks.onSlowFps) === null || _g === void 0 ? void 0 : _g.call(callbacks, slowFps);
+                if (fieldsInReturnValue.slowFps) {
+                    returnValue.slowFps = slowFps;
+                }
+                emittedFields.slowFps = true;
             }
             continue;
         }
         if (key === 'dimensions') {
             if (hasInfo.dimensions &&
-                returnValue.dimensions === undefined &&
-                parseResult) {
-                const dimensionsQueried = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
+                !emittedFields.dimensions &&
+                parseResult &&
+                segments) {
+                const dimensionsQueried = (0, get_dimensions_1.getDimensions)(segments, state);
                 const dimensions = {
                     height: dimensionsQueried.height,
                     width: dimensionsQueried.width,
                 };
-                (_c = moreFields.onDimensions) === null || _c === void 0 ? void 0 : _c.call(moreFields, dimensions);
-                returnValue.dimensions = dimensions;
+                (_h = callbacks.onDimensions) === null || _h === void 0 ? void 0 : _h.call(callbacks, dimensions);
+                if (fieldsInReturnValue.dimensions) {
+                    returnValue.dimensions = dimensions;
+                }
+                emittedFields.dimensions = true;
             }
             continue;
         }
         if (key === 'unrotatedDimensions') {
-            if (returnValue.unrotatedDimensions === undefined &&
-                hasInfo.unrotatedDimensions &&
-                parseResult) {
-                const dimensionsQueried = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
+            if (hasInfo.unrotatedDimensions &&
+                !emittedFields.unrotatedDimensions &&
+                parseResult &&
+                segments) {
+                const dimensionsQueried = (0, get_dimensions_1.getDimensions)(segments, state);
                 const unrotatedDimensions = {
                     height: dimensionsQueried.unrotatedHeight,
                     width: dimensionsQueried.unrotatedWidth,
                 };
-                (_d = moreFields.onUnrotatedDimensions) === null || _d === void 0 ? void 0 : _d.call(moreFields, unrotatedDimensions);
-                returnValue.unrotatedDimensions = unrotatedDimensions;
+                (_j = callbacks.onUnrotatedDimensions) === null || _j === void 0 ? void 0 : _j.call(callbacks, unrotatedDimensions);
+                if (fieldsInReturnValue.unrotatedDimensions) {
+                    returnValue.unrotatedDimensions = unrotatedDimensions;
+                }
+                emittedFields.unrotatedDimensions = true;
             }
             continue;
         }
         if (key === 'rotation') {
-            if (returnValue.rotation === undefined &&
-                hasInfo.rotation &&
-                parseResult) {
-                const dimensionsQueried = (0, get_dimensions_1.getDimensions)(parseResult.segments, state);
+            if (hasInfo.rotation &&
+                !emittedFields.rotation &&
+                parseResult &&
+                segments) {
+                const dimensionsQueried = (0, get_dimensions_1.getDimensions)(segments, state);
                 const { rotation } = dimensionsQueried;
-                (_e = moreFields.onRotation) === null || _e === void 0 ? void 0 : _e.call(moreFields, rotation);
-                returnValue.rotation = rotation;
-            }
-            continue;
-        }
-        if (key === 'fps') {
-            if (returnValue.fps === undefined && hasInfo.fps && parseResult) {
-                const fps = (0, get_fps_1.getFps)(parseResult.segments);
-                (_f = moreFields.onFps) === null || _f === void 0 ? void 0 : _f.call(moreFields, fps);
-                returnValue.fps = fps;
+                (_k = callbacks.onRotation) === null || _k === void 0 ? void 0 : _k.call(callbacks, rotation);
+                if (fieldsInReturnValue.rotation) {
+                    returnValue.rotation = rotation;
+                }
+                emittedFields.rotation = true;
             }
             continue;
         }
         if (key === 'videoCodec') {
-            if (returnValue.videoCodec === undefined &&
+            if (!emittedFields.videoCodec &&
                 hasInfo.videoCodec &&
-                parseResult) {
-                const videoCodec = (0, get_video_codec_1.getVideoCodec)(parseResult.segments, state);
-                (_g = moreFields.onVideoCodec) === null || _g === void 0 ? void 0 : _g.call(moreFields, videoCodec);
-                returnValue.videoCodec = 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);
+                if (fieldsInReturnValue.videoCodec) {
+                    returnValue.videoCodec = videoCodec;
+                }
+                emittedFields.videoCodec = true;
             }
             continue;
         }
         if (key === 'audioCodec') {
-            if (returnValue.audioCodec === undefined &&
+            if (!emittedFields.audioCodec &&
                 hasInfo.audioCodec &&
-                parseResult) {
-                const audioCodec = (0, get_audio_codec_1.getAudioCodec)(parseResult.segments, state);
-                (_h = moreFields.onAudioCodec) === null || _h === void 0 ? void 0 : _h.call(moreFields, audioCodec);
-                returnValue.audioCodec = 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);
+                if (fieldsInReturnValue.audioCodec) {
+                    returnValue.audioCodec = audioCodec;
+                }
+                emittedFields.audioCodec = true;
             }
             continue;
         }
         if (key === 'tracks') {
-            if (hasInfo.tracks &&
-                returnValue.videoTracks === undefined &&
-                returnValue.audioTracks === undefined &&
-                parseResult) {
-                const { videoTracks, audioTracks } = (0, get_tracks_1.getTracks)(parseResult.segments, state);
-                (_j = moreFields.onTracks) === null || _j === void 0 ? void 0 : _j.call(moreFields, { videoTracks, audioTracks });
-                returnValue.videoTracks = videoTracks;
-                returnValue.audioTracks = audioTracks;
+            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 });
+                if (fieldsInReturnValue.tracks) {
+                    returnValue.tracks = { videoTracks, audioTracks };
+                }
+                emittedFields.tracks = true;
             }
             continue;
         }
@@ -117,59 +200,128 @@ const emitAvailableInfo = ({ hasInfo, parseResult, moreFields, state, returnValu
             // Special case: Always emitting internal stats at the end
             if (hasInfo.internalStats) {
                 const internalStats = state.getInternalStats();
-                returnValue.internalStats = internalStats;
+                if (fieldsInReturnValue.internalStats) {
+                    returnValue.internalStats = internalStats;
+                }
+                emittedFields.internalStats = true;
             }
             continue;
         }
         if (key === 'size') {
-            if (returnValue.size === undefined && hasInfo.size) {
-                (_k = moreFields.onSize) === null || _k === void 0 ? void 0 : _k.call(moreFields, contentLength);
-                returnValue.size = contentLength;
+            if (!emittedFields.size && hasInfo.size) {
+                (_p = callbacks.onSize) === null || _p === void 0 ? void 0 : _p.call(callbacks, contentLength);
+                if (fieldsInReturnValue.size) {
+                    returnValue.size = contentLength;
+                }
+                emittedFields.size = true;
+            }
+            continue;
+        }
+        if (key === 'mimeType') {
+            if (!emittedFields.mimeType && hasInfo.mimeType) {
+                (_q = callbacks.onMimeType) === null || _q === void 0 ? void 0 : _q.call(callbacks, mimeType);
+                if (fieldsInReturnValue.mimeType) {
+                    returnValue.mimeType = mimeType;
+                }
+                emittedFields.mimeType = true;
             }
             continue;
         }
         if (key === 'name') {
-            if (returnValue.name === undefined && hasInfo.name) {
-                (_l = moreFields.onName) === null || _l === void 0 ? void 0 : _l.call(moreFields, name);
-                returnValue.name = name;
+            if (!emittedFields.name && hasInfo.name) {
+                (_r = callbacks.onName) === null || _r === void 0 ? void 0 : _r.call(callbacks, name);
+                if (fieldsInReturnValue.name) {
+                    returnValue.name = name;
+                }
+                emittedFields.name = true;
             }
             continue;
         }
         if (key === 'isHdr') {
-            if (returnValue.isHdr === undefined && hasInfo.isHdr && parseResult) {
-                const isHdr = (0, get_is_hdr_1.getIsHdr)(parseResult.segments, state);
-                (_m = moreFields.onIsHdr) === null || _m === void 0 ? void 0 : _m.call(moreFields, isHdr);
-                returnValue.isHdr = 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);
+                if (fieldsInReturnValue.isHdr) {
+                    returnValue.isHdr = isHdr;
+                }
+                emittedFields.isHdr = true;
             }
             continue;
         }
         if (key === 'container') {
-            if (returnValue.container === undefined &&
+            if (!returnValue.container &&
                 hasInfo.container &&
-                parseResult) {
-                const container = (0, get_container_1.getContainer)(parseResult.segments);
-                (_o = moreFields.onContainer) === null || _o === void 0 ? void 0 : _o.call(moreFields, container);
-                returnValue.container = container;
+                parseResult &&
+                segments) {
+                const container = (0, get_container_1.getContainer)(segments);
+                (_t = callbacks.onContainer) === null || _t === void 0 ? void 0 : _t.call(callbacks, container);
+                if (fieldsInReturnValue.container) {
+                    returnValue.container = container;
+                }
+                emittedFields.container = true;
             }
             continue;
         }
         if (key === 'metadata') {
-            if (returnValue.metadata === undefined &&
+            if (!emittedFields.metadata &&
                 hasInfo.metadata &&
-                parseResult) {
-                const metadata = (0, get_metadata_1.getMetadata)(parseResult.segments);
-                (_p = moreFields.onMetadata) === null || _p === void 0 ? void 0 : _p.call(moreFields, metadata);
-                returnValue.metadata = metadata;
+                parseResult &&
+                segments) {
+                const metadata = (0, get_metadata_1.getMetadata)(segments);
+                (_u = callbacks.onMetadata) === null || _u === void 0 ? void 0 : _u.call(callbacks, metadata);
+                if (fieldsInReturnValue.metadata) {
+                    returnValue.metadata = metadata;
+                }
+                emittedFields.metadata = true;
             }
             continue;
         }
         if (key === 'location') {
-            if (returnValue.location === undefined &&
+            if (!emittedFields.location &&
                 hasInfo.location &&
+                parseResult &&
+                segments) {
+                const location = (0, get_location_1.getLocation)(segments);
+                (_v = callbacks.onLocation) === null || _v === void 0 ? void 0 : _v.call(callbacks, location);
+                if (fieldsInReturnValue.location) {
+                    returnValue.location = location;
+                }
+                emittedFields.location = true;
+            }
+            continue;
+        }
+        if (key === 'slowKeyframes') {
+            if (!emittedFields.slowKeyframes &&
+                hasInfo.slowKeyframes &&
                 parseResult) {
-                const location = (0, get_location_1.getLocation)(parseResult.segments);
-                (_q = moreFields.onLocation) === null || _q === void 0 ? void 0 : _q.call(moreFields, location);
-                returnValue.location = location;
+                (_w = callbacks.onSlowKeyframes) === null || _w === void 0 ? void 0 : _w.call(callbacks, state.keyframes.getKeyframes());
+                if (fieldsInReturnValue.slowKeyframes) {
+                    returnValue.slowKeyframes = state.keyframes.getKeyframes();
+                }
+                emittedFields.slowKeyframes = true;
+            }
+            continue;
+        }
+        if (key === 'slowNumberOfFrames') {
+            if (!emittedFields.slowNumberOfFrames &&
+                hasInfo.slowNumberOfFrames &&
+                parseResult) {
+                (_x = callbacks.onSlowNumberOfFrames) === null || _x === void 0 ? void 0 : _x.call(callbacks, state.slowDurationAndFps.getSlowNumberOfFrames());
+                if (fieldsInReturnValue.slowNumberOfFrames) {
+                    returnValue.slowNumberOfFrames =
+                        state.slowDurationAndFps.getSlowNumberOfFrames();
+                }
+                emittedFields.slowNumberOfFrames = true;
+            }
+            continue;
+        }
+        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()));
+                if (fieldsInReturnValue.keyframes) {
+                    returnValue.keyframes = (0, get_keyframes_1.getKeyframes)(state.structure.getStructure());
+                }
+                emittedFields.keyframes = true;
             }
             continue;
         }

package/dist/errors/detect-file-type.d.ts

@@ -0,0 +1 @@
+export declare const detectFileType: (data: Uint8Array) => "webp" | "riff" | "webm" | "iso-base-media" | "transport-stream" | "mp3" | "gif" | "png" | "bmp" | "jpeg" | "unknown";