@remotion/media-parser 4.0.233 → 4.0.235

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

@@ -2,7 +2,7 @@ import type { MoovBox } from './boxes/iso-base-media/moov/moov';
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import { type MediaParserAudioCodec } from './get-tracks';
 import type { Structure } from './parse-result';
-import type { ParserState } from './parser-state';
+import type { ParserState } from './state/parser-state';
 export declare const getAudioCodec: (boxes: Structure, parserState: ParserState) => MediaParserAudioCodec | null;
 export declare const hasAudioCodec: (boxes: Structure, state: ParserState) => boolean;
 type AudioCodecInfo = {

package/dist/get-dimensions.d.ts

@@ -1,5 +1,5 @@
 import type { Structure } from './parse-result';
-import type { ParserState } from './parser-state';
+import type { ParserState } from './state/parser-state';
 export type Dimensions = {
     width: number;
     height: number;

package/dist/get-duration.d.ts

@@ -1,5 +1,5 @@
 import type { AnySegment, Structure } from './parse-result';
-import type { ParserState } from './parser-state';
+import type { ParserState } from './state/parser-state';
 export declare const isMatroska: (boxes: AnySegment[]) => {
     type: "Segment";
     value: import("./boxes/webm/segments/all-segments").PossibleEbml[];

package/dist/get-is-hdr.d.ts

@@ -1,4 +1,4 @@
 import type { Structure } from './parse-result';
-import type { ParserState } from './parser-state';
+import type { ParserState } from './state/parser-state';
 export declare const getIsHdr: (boxes: Structure, state: ParserState) => boolean;
 export declare const hasHdr: (boxes: Structure, state: ParserState) => boolean;

package/dist/get-metadata.d.ts

@@ -0,0 +1,7 @@
+import type { Structure } from './parse-result';
+export type MetadataEntry = {
+    key: string;
+    value: string | number;
+    trackId: number | null;
+};
+export declare const getMetadata: (structure: Structure) => MetadataEntry[];

package/dist/get-metadata.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadata = void 0;
+const traversal_1 = require("./boxes/iso-base-media/traversal");
+const truthy_1 = require("./truthy");
+const parseIsoMetaBox = (meta, trackId) => {
+    const ilstBox = meta.children.find((b) => b.type === 'ilst-box');
+    const keysBox = meta.children.find((b) => b.type === 'keys-box');
+    if (!ilstBox || !keysBox) {
+        return [];
+    }
+    if (ilstBox.entries.length !== keysBox.entries.length) {
+        throw new Error('Number of entries in ilst and keys box do not match');
+    }
+    const entries = [];
+    for (let i = 0; i < ilstBox.entries.length; i++) {
+        const ilstEntry = ilstBox.entries[i];
+        const keysEntry = keysBox.entries[i];
+        if (ilstEntry.value.type !== 'unknown') {
+            entries.push({
+                key: keysEntry.value,
+                value: ilstEntry.value.value,
+                trackId,
+            });
+        }
+    }
+    return entries;
+};
+const getMetadataFromIsoBase = (isoBase) => {
+    const moov = (0, traversal_1.getMoovBox)(isoBase.boxes);
+    if (!moov) {
+        return [];
+    }
+    const traks = (0, traversal_1.getTraks)(moov);
+    const meta = moov.children.find((b) => b.type === 'regular-box' && b.boxType === 'meta');
+    const metaInTracks = traks
+        .map((t) => {
+        const metaBox = t.children.find((child) => child.type === 'regular-box' && child.boxType === 'meta');
+        if (metaBox) {
+            const tkhd = (0, traversal_1.getTkhdBox)(t);
+            if (!tkhd) {
+                throw new Error('No tkhd box found');
+            }
+            return parseIsoMetaBox(metaBox, tkhd.trackId);
+        }
+        return null;
+    })
+        .filter(truthy_1.truthy);
+    if (!meta) {
+        return metaInTracks.flat(1);
+    }
+    return [...parseIsoMetaBox(meta, null), ...metaInTracks.flat(1)];
+};
+const getMetadata = (structure) => {
+    if (structure.type === 'matroska') {
+        return [];
+    }
+    if (structure.type === 'riff') {
+        return [];
+    }
+    return getMetadataFromIsoBase(structure);
+};
+exports.getMetadata = getMetadata;

package/dist/get-tracks.d.ts

@@ -2,7 +2,7 @@ import type { MoovBox } from './boxes/iso-base-media/moov/moov';
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import type { AllTracks } from './boxes/riff/get-tracks-from-avi';
 import type { Structure } from './parse-result';
-import type { ParserState } from './parser-state';
+import type { ParserState } from './state/parser-state';
 type SampleAspectRatio = {
     numerator: number;
     denominator: number;

package/dist/get-tracks.js

@@ -18,7 +18,7 @@ const hasTracks = (structure, state) => {
     if (structure.type === 'matroska') {
         const mainSegment = (0, traversal_2.getMainSegment)(structure.boxes);
         if (!mainSegment) {
-            throw new Error('No main segment found');
+            return false;
         }
         return (0, traversal_2.getTracksSegment)(mainSegment) !== null;
     }

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

@@ -1,7 +1,7 @@
 import type { TrakBox } from './boxes/iso-base-media/trak/trak';
 import { type MediaParserVideoCodec, type VideoTrackColorParams } from './get-tracks';
 import type { Structure } from './parse-result';
-import type { ParserState } from './parser-state';
+import type { ParserState } from './state/parser-state';
 export declare const getVideoCodecFromIsoTrak: (trakBox: TrakBox) => "h264" | "av1" | "h265" | "prores";
 export declare const getVideoCodec: (boxes: Structure) => MediaParserVideoCodec | null;
 export declare const hasVideoCodec: (boxes: Structure, state: ParserState) => boolean;

package/dist/has-all-info.d.ts

@@ -1,4 +1,9 @@
 import type { Options, ParseMediaFields } from './options';
-import type { ParseResult, Structure } from './parse-result';
-import type { ParserState } from './parser-state';
-export declare const getAvailableInfo: (options: Options<ParseMediaFields>, parseResult: ParseResult<Structure> | null, state: ParserState) => Record<keyof Options<ParseMediaFields>, boolean>;
+import type { Structure } from './parse-result';
+import type { ParserState } from './state/parser-state';
+export declare const getAvailableInfo: (options: Options<ParseMediaFields>, structure: Structure | null, state: ParserState) => Record<keyof Options<ParseMediaFields>, boolean>;
+export declare const hasAllInfo: ({ fields, state, structure, }: {
+    structure: Structure | null;
+    fields: Options<ParseMediaFields>;
+    state: ParserState;
+}) => boolean;

package/dist/has-all-info.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAvailableInfo = void 0;
+exports.hasAllInfo = exports.getAvailableInfo = void 0;
 const get_audio_codec_1 = require("./get-audio-codec");
 const get_container_1 = require("./get-container");
 const get_dimensions_1 = require("./get-dimensions");
@@ -9,38 +9,38 @@ const get_fps_1 = require("./get-fps");
 const get_is_hdr_1 = require("./get-is-hdr");
 const get_tracks_1 = require("./get-tracks");
 const get_video_codec_1 = require("./get-video-codec");
-const getAvailableInfo = (options, parseResult, state) => {
+const getAvailableInfo = (options, structure, state) => {
     const keys = Object.entries(options).filter(([, value]) => value);
     const infos = keys.map(([_key]) => {
         const key = _key;
         if (key === 'structure') {
-            return Boolean(parseResult && parseResult.status === 'done');
+            return false;
         }
         if (key === 'durationInSeconds') {
-            return Boolean(parseResult && (0, get_duration_1.hasDuration)(parseResult.segments, state));
+            return Boolean(structure && (0, get_duration_1.hasDuration)(structure, state));
         }
         if (key === 'dimensions' ||
             key === 'rotation' ||
             key === 'unrotatedDimensions') {
-            return Boolean(parseResult && (0, get_dimensions_1.hasDimensions)(parseResult.segments, state));
+            return Boolean(structure && (0, get_dimensions_1.hasDimensions)(structure, state));
         }
         if (key === 'fps') {
-            return Boolean(parseResult && (0, get_fps_1.hasFps)(parseResult.segments));
+            return Boolean(structure && (0, get_fps_1.hasFps)(structure));
         }
         if (key === 'isHdr') {
-            return Boolean(parseResult && (0, get_is_hdr_1.hasHdr)(parseResult.segments, state));
+            return Boolean(structure && (0, get_is_hdr_1.hasHdr)(structure, state));
         }
         if (key === 'videoCodec') {
-            return Boolean(parseResult && (0, get_video_codec_1.hasVideoCodec)(parseResult.segments, state));
+            return Boolean(structure && (0, get_video_codec_1.hasVideoCodec)(structure, state));
         }
         if (key === 'audioCodec') {
-            return Boolean(parseResult && (0, get_audio_codec_1.hasAudioCodec)(parseResult.segments, state));
+            return Boolean(structure && (0, get_audio_codec_1.hasAudioCodec)(structure, state));
         }
         if (key === 'tracks') {
-            return Boolean(parseResult && (0, get_tracks_1.hasTracks)(parseResult.segments, state));
+            return Boolean(structure && (0, get_tracks_1.hasTracks)(structure, state));
         }
         if (key === 'internalStats') {
-            return false;
+            return true;
         }
         if (key === 'size') {
             return true;
@@ -49,7 +49,10 @@ const getAvailableInfo = (options, parseResult, state) => {
             return true;
         }
         if (key === 'container') {
-            return Boolean(parseResult && (0, get_container_1.hasContainer)(parseResult.segments));
+            return Boolean(structure && (0, get_container_1.hasContainer)(structure));
+        }
+        if (key === 'metadata') {
+            return false;
         }
         throw new Error(`Unknown key: ${key}`);
     });
@@ -61,3 +64,9 @@ const getAvailableInfo = (options, parseResult, state) => {
     return Object.fromEntries(entries);
 };
 exports.getAvailableInfo = getAvailableInfo;
+const hasAllInfo = ({ fields, state, structure, }) => {
+    const availableInfo = (0, exports.getAvailableInfo)(fields !== null && fields !== void 0 ? fields : {}, structure, state);
+    return (Object.values(availableInfo).every(Boolean) &&
+        (state.maySkipVideoData() || state.canSkipTracksState.canSkipTracks()));
+};
+exports.hasAllInfo = hasAllInfo;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { IoEventEmitter } from './create/event-emitter';
 import type { ProgressTracker } from './create/progress-tracker';
 import type { LogLevel } from './log';
+export { MetadataEntry } from './metadata/get-metadata';
 export { WriterInterface } from './writers/writer';
 export { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, OtherTrack, Track, VideoTrack, VideoTrackColorParams, } from './get-tracks';
 export type { Options, ParseMediaContainer, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOnProgress, ParseMediaOptions, ParseMediaProgress, ParseMediaResult, TracksField, } from './options';
@@ -37,6 +38,11 @@ export declare const MediaParserInternals: {
         reject: (reason: unknown) => void;
         resolve: (value: T | PromiseLike<T>) => void;
     };
+    createAacCodecPrivate: ({ audioObjectType, sampleRate, channelConfiguration, }: {
+        audioObjectType: number;
+        sampleRate: number;
+        channelConfiguration: number;
+    }) => Uint8Array;
 };
 export type { IoEventEmitter, LogLevel, ProgressTracker };
 export { VERSION } from './version';

package/dist/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = exports.MediaParserInternals = exports.parseMedia = void 0;
+const aac_codecprivate_1 = require("./aac-codecprivate");
 const event_emitter_1 = require("./create/event-emitter");
 const create_iso_base_media_1 = require("./create/iso-base-media/create-iso-base-media");
 const create_matroska_media_1 = require("./create/matroska/create-matroska-media");
@@ -19,6 +20,7 @@ exports.MediaParserInternals = {
     makeProgressTracker: progress_tracker_1.makeProgressTracker,
     withResolvers: with_resolvers_1.withResolvers,
     withResolversAndWaitForReturn: with_resolvers_1.withResolversAndWaitForReturn,
+    createAacCodecPrivate: aac_codecprivate_1.createAacCodecPrivate,
 };
 var version_1 = require("./version");
 Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });

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

@@ -0,0 +1,7 @@
+import type { Structure } from '../parse-result';
+export type MetadataEntry = {
+    key: string;
+    value: string | number;
+    trackId: number | null;
+};
+export declare const getMetadata: (structure: Structure) => MetadataEntry[];

package/dist/metadata/get-metadata.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadata = void 0;
+const metadata_from_iso_1 = require("./metadata-from-iso");
+const metadata_from_matroska_1 = require("./metadata-from-matroska");
+const metadata_from_riff_1 = require("./metadata-from-riff");
+const getMetadata = (structure) => {
+    if (structure.type === 'matroska') {
+        return (0, metadata_from_matroska_1.getMetadataFromMatroska)(structure);
+    }
+    if (structure.type === 'riff') {
+        return (0, metadata_from_riff_1.getMetadataFromRiff)(structure);
+    }
+    return (0, metadata_from_iso_1.getMetadataFromIsoBase)(structure);
+};
+exports.getMetadata = getMetadata;

package/dist/metadata/metadata-from-iso.d.ts

@@ -0,0 +1,4 @@
+import type { IsoBaseMediaStructure, RegularBox } from '../parse-result';
+import type { MetadataEntry } from './get-metadata';
+export declare const parseIsoMetaBox: (meta: RegularBox, trackId: number | null) => MetadataEntry[];
+export declare const getMetadataFromIsoBase: (isoBase: IsoBaseMediaStructure) => MetadataEntry[];

package/dist/metadata/metadata-from-iso.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataFromIsoBase = exports.parseIsoMetaBox = void 0;
+const traversal_1 = require("../boxes/iso-base-media/traversal");
+const truthy_1 = require("../truthy");
+/**
+ *
+ * @param ilstBox 	©ART - Artist
+    ▪	Hex: A9 41 52 54
+    2.	©alb - Album
+    ▪	Hex: A9 61 6C 62
+    3.	©cmt - Comment
+    ▪	Hex: A9 63 6D 74
+    4.	©day - Release Date
+    ▪	Hex: A9 64 61 79
+    5.	©gen - Genre
+    ▪	Hex: A9 67 65 6E
+    6.	©nam - Title
+    ▪	Hex: A9 6E 61 6D
+    7.	©too - Encoder
+    ▪	Hex: A9 74 6F 6F
+    8.	©wrt - Writer
+    ▪	Hex: A9 77 72 74
+    9.	©cpy - Copyright
+    ▪	Hex: A9 63 70 79
+    10.	©dir - Director
+    ▪	Hex: A9 64 69 72
+    11.	©prd - Producer
+    ▪	Hex: A9 70 72 64
+    12.	©des - Description
+    ▪	Hex: A9 64 65 73
+ */
+const mapToKey = (index) => {
+    if (index === 0xa9415254) {
+        return 'artist';
+    }
+    if (index === 0xa9616c62) {
+        return 'album';
+    }
+    if (index === 0xa9636d74) {
+        return 'comment';
+    }
+    if (index === 0xa9646179) {
+        return 'releaseDate';
+    }
+    if (index === 0xa967656e) {
+        return 'genre';
+    }
+    if (index === 0xa96e616d) {
+        return 'title';
+    }
+    if (index === 0xa9746f6f) {
+        return 'encoder';
+    }
+    if (index === 0xa9777274) {
+        return 'writer';
+    }
+    if (index === 0xa9637079) {
+        return 'copyright';
+    }
+    if (index === 0xa9646972) {
+        return 'director';
+    }
+    if (index === 0xa9707264) {
+        return 'producer';
+    }
+    if (index === 0xa9646573) {
+        return 'description';
+    }
+    return null;
+};
+const parseIlstBoxWithoutKeys = (ilstBox) => {
+    return ilstBox.entries
+        .map((entry) => {
+        const key = mapToKey(entry.index);
+        if (!key) {
+            return null;
+        }
+        if (entry.value.type === 'unknown') {
+            return null;
+        }
+        return {
+            trackId: null,
+            key,
+            value: entry.value.value,
+        };
+    })
+        .filter(truthy_1.truthy);
+};
+const parseIsoMetaBox = (meta, trackId) => {
+    const ilstBox = meta.children.find((b) => b.type === 'ilst-box');
+    const keysBox = meta.children.find((b) => b.type === 'keys-box');
+    if (!ilstBox || !keysBox) {
+        if (ilstBox) {
+            return parseIlstBoxWithoutKeys(ilstBox);
+        }
+        return [];
+    }
+    const entries = [];
+    for (let i = 0; i < ilstBox.entries.length; i++) {
+        const ilstEntry = ilstBox.entries[i];
+        const keysEntry = keysBox.entries[i];
+        if (ilstEntry.value.type !== 'unknown') {
+            const value = typeof ilstEntry.value.value === 'string' &&
+                ilstEntry.value.value.endsWith('\u0000')
+                ? ilstEntry.value.value.slice(0, -1)
+                : ilstEntry.value.value;
+            entries.push({
+                key: keysEntry.value,
+                value,
+                trackId,
+            });
+        }
+    }
+    return entries;
+};
+exports.parseIsoMetaBox = parseIsoMetaBox;
+const getMetadataFromIsoBase = (isoBase) => {
+    const moov = (0, traversal_1.getMoovBox)(isoBase.boxes);
+    if (!moov) {
+        return [];
+    }
+    const traks = (0, traversal_1.getTraks)(moov);
+    const meta = moov.children.find((b) => b.type === 'regular-box' && b.boxType === 'meta');
+    const udta = moov.children.find((b) => b.type === 'regular-box' && b.boxType === 'udta');
+    const metaInUdta = udta === null || udta === void 0 ? void 0 : udta.children.find((b) => {
+        return b.type === 'regular-box' && b.boxType === 'meta';
+    });
+    const metaInTracks = traks
+        .map((t) => {
+        const metaBox = t.children.find((child) => child.type === 'regular-box' && child.boxType === 'meta');
+        if (metaBox) {
+            const tkhd = (0, traversal_1.getTkhdBox)(t);
+            if (!tkhd) {
+                throw new Error('No tkhd box found');
+            }
+            return (0, exports.parseIsoMetaBox)(metaBox, tkhd.trackId);
+        }
+        return null;
+    })
+        .filter(truthy_1.truthy);
+    return [
+        ...(meta ? (0, exports.parseIsoMetaBox)(meta, null) : []),
+        ...(metaInUdta ? (0, exports.parseIsoMetaBox)(metaInUdta, null) : []),
+        ...metaInTracks.flat(1),
+    ];
+};
+exports.getMetadataFromIsoBase = getMetadataFromIsoBase;

package/dist/metadata/metadata-from-matroska.d.ts

@@ -0,0 +1,3 @@
+import type { MatroskaStructure } from '../parse-result';
+import type { MetadataEntry } from './get-metadata';
+export declare const getMetadataFromMatroska: (structure: MatroskaStructure) => MetadataEntry[];

package/dist/metadata/metadata-from-matroska.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataFromMatroska = void 0;
+const traversal_1 = require("../boxes/webm/traversal");
+const removeEndZeroes = (value) => {
+    return value.endsWith('\u0000') ? removeEndZeroes(value.slice(0, -1)) : value;
+};
+const parseSimpleTagIntoEbml = (children, trackId) => {
+    const tagName = children.find((c) => c.type === 'TagName');
+    const tagString = children.find((c) => c.type === 'TagString');
+    if (!tagName || !tagString) {
+        return null;
+    }
+    return {
+        trackId,
+        key: tagName.value.toLowerCase(),
+        value: removeEndZeroes(tagString.value),
+    };
+};
+const getMetadataFromMatroska = (structure) => {
+    var _a;
+    const entries = [];
+    for (const segment of structure.boxes) {
+        if (segment.type !== 'Segment') {
+            continue;
+        }
+        const tags = segment.value.filter((s) => s.type === 'Tags');
+        for (const tag of tags) {
+            for (const child of tag.value) {
+                if (child.type !== 'Tag') {
+                    continue;
+                }
+                let trackId = null;
+                const target = child.value.find((c) => c.type === 'Targets');
+                if (target) {
+                    const tagTrackId = (_a = target.value.find((c) => c.type === 'TagTrackUID')) === null || _a === void 0 ? void 0 : _a.value;
+                    if (tagTrackId) {
+                        trackId = (0, traversal_1.getTrackWithUid)(segment, tagTrackId);
+                    }
+                }
+                const simpleTags = child.value.filter((s) => s.type === 'SimpleTag');
+                for (const simpleTag of simpleTags) {
+                    const parsed = parseSimpleTagIntoEbml(simpleTag.value, trackId);
+                    if (parsed) {
+                        entries.push(parsed);
+                    }
+                }
+            }
+        }
+    }
+    return entries;
+};
+exports.getMetadataFromMatroska = getMetadataFromMatroska;

package/dist/metadata/metadata-from-riff.d.ts

@@ -0,0 +1,3 @@
+import type { RiffStructure } from '../parse-result';
+import type { MetadataEntry } from './get-metadata';
+export declare const getMetadataFromRiff: (structure: RiffStructure) => MetadataEntry[];

package/dist/metadata/metadata-from-riff.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataFromRiff = void 0;
+const truthy_1 = require("../truthy");
+const getMetadataFromRiff = (structure) => {
+    const boxes = structure.boxes.find((b) => b.type === 'list-box' && b.listType === 'INFO');
+    if (!boxes) {
+        return [];
+    }
+    const { children } = boxes;
+    return children
+        .map((child) => {
+        if (child.type !== 'isft-box') {
+            return null;
+        }
+        return {
+            trackId: null,
+            key: 'encoder',
+            value: child.software,
+        };
+    })
+        .filter(truthy_1.truthy);
+};
+exports.getMetadataFromRiff = getMetadataFromRiff;

package/dist/options.d.ts

@@ -1,9 +1,10 @@
 import type { Dimensions } from './get-dimensions';
 import type { AudioTrack, MediaParserAudioCodec, MediaParserVideoCodec, VideoTrack } from './get-tracks';
 import type { LogLevel } from './log';
+import type { MetadataEntry } from './metadata/get-metadata';
 import type { Structure } from './parse-result';
-import type { InternalStats } from './parser-state';
 import type { ReaderInterface } from './readers/reader';
+import type { InternalStats } from './state/parser-state';
 import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
 export type KnownAudioCodecs = 'aac' | 'mp3' | 'aiff' | 'opus' | 'pcm' | 'vorbis' | 'unknown';
 export type ParseMediaFields = {
@@ -21,6 +22,7 @@ export type ParseMediaFields = {
     name: boolean;
     container: boolean;
     isHdr: boolean;
+    metadata: boolean;
 };
 export type AllParseMediaFields = {
     dimensions: true;
@@ -37,6 +39,7 @@ export type AllParseMediaFields = {
     name: true;
     container: true;
     isHdr: true;
+    metadata: true;
 };
 export type Options<Fields extends ParseMediaFields> = {
     dimensions?: Fields['dimensions'];
@@ -53,6 +56,7 @@ export type Options<Fields extends ParseMediaFields> = {
     name?: Fields['name'];
     container?: Fields['container'];
     isHdr?: Fields['isHdr'];
+    metadata?: Fields['metadata'];
 };
 export type TracksField = {
     videoTracks: VideoTrack[];
@@ -75,12 +79,12 @@ export type ParseMediaCallbacks<Fields extends Options<ParseMediaFields>> = (Fie
     onTracks?: (tracks: TracksField) => void;
 } : {}) & (Fields['rotation'] extends true ? {
     onRotation?: (rotation: number | null) => void;
+} : {}) & (Fields['metadata'] extends true ? {
+    onMetadata?: (metadata: MetadataEntry[]) => void;
 } : {}) & (Fields['unrotatedDimensions'] extends true ? {
     onUnrotatedDimensions?: (dimensions: Dimensions) => void;
 } : {}) & (Fields['isHdr'] extends true ? {
     onIsHdr?: (isHdr: boolean) => void;
-} : {}) & (Fields['internalStats'] extends true ? {
-    onInternalStats?: (stats: InternalStats) => void;
 } : {}) & (Fields['size'] extends true ? {
     onSize?: (size: number | null) => void;
 } : {}) & (Fields['name'] extends true ? {
@@ -112,6 +116,8 @@ export type ParseMediaResult<Fields extends Options<ParseMediaFields>> = (Fields
     size: number | null;
 } : {}) & (Fields['name'] extends true ? {
     name: string;
+} : {}) & (Fields['metadata'] extends true ? {
+    metadata: MetadataEntry[];
 } : {}) & (Fields['container'] extends true ? {
     container: ParseMediaContainer | null;
 } : {});