music-metadata 12.2.0 → 12.2.2

package/lib/matroska/MatroskaDtd.js

@@ -4,6 +4,10 @@ import { DataType } from '../ebml/types.js';
  * Derived from https://github.com/tungol/EBML/blob/master/doctypes/matroska.dtd
  * Extended with:
  * - https://www.matroska.org/technical/specs/index.html
+ * Cardinality and paths audited against:
+ * https://github.com/ietf-wg-cellar/matroska-specification/blob/master/ebml_matroska.xml
+ * UID integers deliberately decode as bytes to preserve all 64 bits.
+ * Recursive ChapterAtom/SimpleTag children are not expanded by this metadata subset.
  */
 export const matroskaDtd = {
     name: 'dtd',
@@ -28,6 +32,7 @@ export const matroskaDtd = {
                 // Meta Seek Information (also known as MetaSeek)
                 0x114d9b74: {
                     name: 'seekHead',
+                    multiple: true,
                     container: {
                         0x4dbb: {
                             name: 'seek',
@@ -51,7 +56,7 @@ export const matroskaDtd = {
                         0x3e83bb: { name: 'nextFilename', value: DataType.string },
                         0x2ad7b1: { name: 'timecodeScale', value: DataType.uint },
                         0x4489: { name: 'duration', value: DataType.float },
-                        0x4461: { name: 'dateUTC', value: DataType.uint },
+                        0x4461: { name: 'dateUTC', value: DataType.int },
                         0x7ba9: { name: 'title', value: DataType.string },
                         0x4d80: { name: 'muxingApp', value: DataType.string },
                         0x5741: { name: 'writingApp', value: DataType.string }
@@ -62,12 +67,17 @@ export const matroskaDtd = {
                     name: 'cluster',
                     multiple: true,
                     container: {
-                        0xe7: { name: 'timecode', value: DataType.uid },
-                        0x58d7: { name: 'silentTracks ', multiple: true },
-                        0xa7: { name: 'position', value: DataType.uid },
-                        0xab: { name: 'prevSize', value: DataType.uid },
-                        0xa0: { name: 'blockGroup' },
-                        0xa3: { name: 'simpleBlock' }
+                        0xe7: { name: 'timecode', value: DataType.uint },
+                        0x5854: {
+                            name: 'silentTracks',
+                            container: {
+                                0x58d7: { name: 'trackNumber', value: DataType.uint, multiple: true }
+                            }
+                        },
+                        0xa7: { name: 'position', value: DataType.uint },
+                        0xab: { name: 'prevSize', value: DataType.uint },
+                        0xa0: { name: 'blockGroup', multiple: true },
+                        0xa3: { name: 'simpleBlock', value: DataType.binary, multiple: true }
                     }
                 },
                 // Track
@@ -86,9 +96,9 @@ export const matroskaDtd = {
                                 0x55aa: { name: 'flagForced', value: DataType.bool }, // extended
                                 0x9c: { name: 'flagLacing', value: DataType.bool },
                                 0x6de7: { name: 'minCache', value: DataType.uint },
-                                0x6de8: { name: 'maxCache', value: DataType.uint },
+                                0x6df8: { name: 'maxCache', value: DataType.uint },
                                 0x23e383: { name: 'defaultDuration', value: DataType.uint },
-                                0x23314f: { name: 'timecodeScale', value: DataType.float },
+                                0x23314f: { name: 'trackTimecodeScale', value: DataType.float },
                                 0x536e: { name: 'name', value: DataType.string },
                                 0x22b59c: { name: 'language', value: DataType.string },
                                 0x22b59d: { name: 'languageIETF', value: DataType.string },
@@ -96,22 +106,23 @@ export const matroskaDtd = {
                                 0x63a2: { name: 'codecPrivate', value: DataType.binary },
                                 0x258688: { name: 'codecName', value: DataType.string },
                                 0x3a9697: { name: 'codecSettings', value: DataType.string },
-                                0x3b4040: { name: 'codecInfoUrl', value: DataType.string },
-                                0x26b240: { name: 'codecDownloadUrl', value: DataType.string },
+                                0x3b4040: { name: 'codecInfoUrl', value: DataType.string, multiple: true },
+                                0x26b240: { name: 'codecDownloadUrl', value: DataType.string, multiple: true },
                                 0xaa: { name: 'codecDecodeAll', value: DataType.bool },
-                                0x6fab: { name: 'trackOverlay', value: DataType.uint },
+                                0x6fab: { name: 'trackOverlay', value: DataType.uint, multiple: true },
                                 // Video
                                 0xe0: {
                                     name: 'video',
                                     container: {
-                                        0x9a: { name: 'flagInterlaced', value: DataType.bool },
+                                        0x9a: { name: 'flagInterlaced', value: DataType.uint },
                                         0x53b8: { name: 'stereoMode', value: DataType.uint },
                                         0xb0: { name: 'pixelWidth', value: DataType.uint },
                                         0xba: { name: 'pixelHeight', value: DataType.uint },
                                         0x54b0: { name: 'displayWidth', value: DataType.uint },
                                         0x54ba: { name: 'displayHeight', value: DataType.uint },
+                                        0x54b2: { name: 'displayUnit', value: DataType.uint },
                                         0x54b3: { name: 'aspectRatioType', value: DataType.uint },
-                                        0x2eb524: { name: 'colourSpace', value: DataType.uint },
+                                        0x2eb524: { name: 'colourSpace', value: DataType.binary },
                                         0x2fb523: { name: 'gammaValue', value: DataType.float }
                                     }
                                 },
@@ -122,7 +133,6 @@ export const matroskaDtd = {
                                         0xb5: { name: 'samplingFrequency', value: DataType.float },
                                         0x78b5: { name: 'outputSamplingFrequency', value: DataType.float },
                                         0x9f: { name: 'channels', value: DataType.uint }, // https://www.matroska.org/technical/specs/index.html
-                                        0x94: { name: 'channels', value: DataType.uint },
                                         0x7d7b: { name: 'channelPositions', value: DataType.binary },
                                         0x6264: { name: 'bitDepth', value: DataType.uint }
                                     }
@@ -133,29 +143,29 @@ export const matroskaDtd = {
                                     container: {
                                         0x6240: {
                                             name: 'contentEncoding',
+                                            multiple: true,
                                             container: {
                                                 0x5031: { name: 'order', value: DataType.uint },
-                                                0x5032: { name: 'scope', value: DataType.bool },
+                                                0x5032: { name: 'scope', value: DataType.uint },
                                                 0x5033: { name: 'type', value: DataType.uint },
                                                 0x5034: {
-                                                    name: 'contentEncoding',
+                                                    name: 'contentCompression',
                                                     container: {
                                                         0x4254: { name: 'contentCompAlgo', value: DataType.uint },
                                                         0x4255: { name: 'contentCompSettings', value: DataType.binary }
                                                     }
                                                 },
                                                 0x5035: {
-                                                    name: 'contentEncoding',
+                                                    name: 'contentEncryption',
                                                     container: {
                                                         0x47e1: { name: 'contentEncAlgo', value: DataType.uint },
                                                         0x47e2: { name: 'contentEncKeyID', value: DataType.binary },
-                                                        0x47e3: { name: 'contentSignature ', value: DataType.binary },
-                                                        0x47e4: { name: 'ContentSigKeyID  ', value: DataType.binary },
-                                                        0x47e5: { name: 'contentSigAlgo ', value: DataType.uint },
-                                                        0x47e6: { name: 'contentSigHashAlgo ', value: DataType.uint }
+                                                        0x47e3: { name: 'contentSignature', value: DataType.binary },
+                                                        0x47e4: { name: 'contentSigKeyID', value: DataType.binary },
+                                                        0x47e5: { name: 'contentSigAlgo', value: DataType.uint },
+                                                        0x47e6: { name: 'contentSigHashAlgo', value: DataType.uint }
                                                     }
-                                                },
-                                                0x6264: { name: 'bitDepth', value: DataType.uint }
+                                                }
                                             }
                                         }
                                     }
@@ -170,10 +180,12 @@ export const matroskaDtd = {
                     container: {
                         0xbb: {
                             name: 'cuePoint',
+                            multiple: true,
                             container: {
-                                0xb3: { name: 'cueTime', value: DataType.uid },
+                                0xb3: { name: 'cueTime', value: DataType.uint },
                                 0xb7: {
                                     name: 'positions',
+                                    multiple: true,
                                     container: {
                                         0xf7: { name: 'track', value: DataType.uint },
                                         0xf1: { name: 'clusterPosition', value: DataType.uint },
@@ -181,6 +193,7 @@ export const matroskaDtd = {
                                         0xea: { name: 'codecState', value: DataType.uint },
                                         0xdb: {
                                             name: 'reference',
+                                            multiple: true,
                                             container: {
                                                 0x96: { name: 'time', value: DataType.uint },
                                                 0x97: { name: 'cluster', value: DataType.uint },
@@ -218,27 +231,30 @@ export const matroskaDtd = {
                     container: {
                         0x45b9: {
                             name: 'editionEntry',
+                            multiple: true,
                             container: {
                                 0xb6: {
                                     name: 'chapterAtom',
+                                    multiple: true,
                                     container: {
                                         0x73c4: { name: 'uid', value: DataType.uid },
                                         0x91: { name: 'timeStart', value: DataType.uint },
-                                        0x92: { name: 'timeEnd', value: DataType.uid },
+                                        0x92: { name: 'timeEnd', value: DataType.uint },
                                         0x98: { name: 'hidden', value: DataType.bool },
-                                        0x4598: { name: 'enabled', value: DataType.uid },
+                                        0x4598: { name: 'enabled', value: DataType.bool },
                                         0x8f: {
                                             name: 'track',
                                             container: {
-                                                0x89: { name: 'trackNumber', value: DataType.uid },
-                                                0x80: {
-                                                    name: 'display',
-                                                    container: {
-                                                        0x85: { name: 'string', value: DataType.string },
-                                                        0x437c: { name: 'language ', value: DataType.string },
-                                                        0x437e: { name: 'country ', value: DataType.string }
-                                                    }
-                                                }
+                                                0x89: { name: 'trackUID', value: DataType.uid, multiple: true }
+                                            }
+                                        },
+                                        0x80: {
+                                            name: 'display',
+                                            multiple: true,
+                                            container: {
+                                                0x85: { name: 'string', value: DataType.string },
+                                                0x437c: { name: 'language', value: DataType.string, multiple: true },
+                                                0x437e: { name: 'country', value: DataType.string, multiple: true }
                                             }
                                         }
                                     }
@@ -250,6 +266,7 @@ export const matroskaDtd = {
                 // Tagging
                 0x1254c367: {
                     name: 'tags',
+                    multiple: true,
                     container: {
                         0x7373: {
                             name: 'tag',
@@ -258,12 +275,12 @@ export const matroskaDtd = {
                                 0x63c0: {
                                     name: 'target',
                                     container: {
-                                        0x63c5: { name: 'tagTrackUID', value: DataType.uid },
-                                        0x63c4: { name: 'tagChapterUID', value: DataType.uint },
-                                        0x63c6: { name: 'tagAttachmentUID', value: DataType.uid },
+                                        0x63c5: { name: 'tagTrackUID', value: DataType.uid, multiple: true },
+                                        0x63c4: { name: 'tagChapterUID', value: DataType.uid, multiple: true },
+                                        0x63c6: { name: 'tagAttachmentUID', value: DataType.uid, multiple: true },
                                         0x63ca: { name: 'targetType', value: DataType.string }, // extended
                                         0x68ca: { name: 'targetTypeValue', value: DataType.uint }, // extended
-                                        0x63c9: { name: 'tagEditionUID', value: DataType.uid } // extended
+                                        0x63c9: { name: 'tagEditionUID', value: DataType.uid, multiple: true } // extended
                                     }
                                 },
                                 0x67c8: {

package/lib/matroska/MatroskaParser.js

@@ -4,6 +4,30 @@ import { EbmlIterator, ParseAction } from '../ebml/EbmlIterator.js';
 import { matroskaDtd } from './MatroskaDtd.js';
 import { TargetType, TrackType } from './types.js';
 const debug = initDebug('music-metadata:parser:matroska');
+const targetTypes = TargetType;
+function isCompleteTrack(entry) {
+    return (typeof entry.trackNumber === 'number' &&
+        Number.isSafeInteger(entry.trackNumber) &&
+        entry.trackNumber > 0 &&
+        typeof entry.codecID === 'string' &&
+        entry.codecID.length > 0 &&
+        Object.values(TrackType).some(type => type === entry.trackType));
+}
+function isCompleteFile(file) {
+    return (typeof file.name === 'string' &&
+        typeof file.mimeType === 'string' &&
+        file.data instanceof Uint8Array &&
+        file.uid instanceof Uint8Array);
+}
+function videoInfo(video) {
+    const { flagInterlaced, ...properties } = video;
+    const result = properties;
+    // Matroska uses 0=undetermined, 1=interlaced, 2=progressive.
+    if (flagInterlaced === 1 || flagInterlaced === 2) {
+        result.flagInterlaced = flagInterlaced === 1;
+    }
+    return result;
+}
 /**
  * Extensible Binary Meta Language (EBML) parser
  * https://en.wikipedia.org/wiki/Extensible_Binary_Meta_Language
@@ -23,23 +47,44 @@ export class MatroskaParser extends BasicParser {
     flagUseIndexToSkipClusters = this.options.mkvUseIndex ?? false;
     async parse() {
         const containerSize = this.tokenizer.fileInfo.size ?? Number.MAX_SAFE_INTEGER;
+        const attachmentMimeTypes = new WeakMap();
         const matroskaIterator = new EbmlIterator(this.tokenizer, this.options);
         debug('Initializing DTD end MatroskaIterator');
         await matroskaIterator.iterate(matroskaDtd, containerSize, {
-            startNext: element => {
+            // Process tags and attachments one at a time. Never assemble a Segment/root tree.
+            collect: element => [0x114d9b74, 0x1549a966, 0x1654ae6b, 0x7373, 0x61a7].includes(element.id),
+            startNext: async (element) => {
                 switch (element.id) {
-                    // case 0x1f43b675: // cluster
+                    case 0x18538067: // SeekPosition is relative to the Segment payload, not the SeekHead.
+                        this.seekHeadOffset = this.tokenizer.position;
+                        return ParseAction.ReadNext;
+                    case 0x1941a469: // Attachments are only used for cover pictures.
+                        return this.options.skipCovers ? ParseAction.IgnoreElement : ParseAction.ReadNext;
+                    case 0x465c: {
+                        // FileData
+                        const mimeType = element.parent && attachmentMimeTypes.get(element.parent);
+                        // If MIME follows FileData, retain one payload under maxMemoryAllocation
+                        // until AttachedFile ends, then classify it. This also works on streams.
+                        return mimeType !== undefined && !mimeType.startsWith('image/')
+                            ? ParseAction.IgnoreElement
+                            : ParseAction.ReadNext;
+                    }
+                    case 0x114d9b74:
+                        return this.flagUseIndexToSkipClusters ? ParseAction.ReadNext : ParseAction.IgnoreElement;
+                    case 0x63a2: // CodecPrivate is not exposed as metadata.
+                    case 0x6d80: // ContentEncodings
+                    case 0x1043a770: // Chapters are not currently exposed by this parser.
                     case 0x1c53bb6b: // Cueing Data
                         debug(`Skip element: name=${element.name}, id=0x${element.id.toString(16)}`);
                         return ParseAction.IgnoreElement;
                     case 0x1f43b675: // cluster
                         if (this.flagUseIndexToSkipClusters && this.seekHead) {
-                            const index = this.seekHead.seek.find(index => index.position + this.seekHeadOffset > this.tokenizer.position);
-                            if (index) {
+                            const index = (this.seekHead.seek ?? []).find(index => index.position !== undefined && index.position + this.seekHeadOffset > this.tokenizer.position);
+                            if (index?.position !== undefined) {
                                 // Go to next index position
                                 const ignoreSize = index.position + this.seekHeadOffset - this.tokenizer.position;
                                 debug(`Use index to go to next position, ignoring ${ignoreSize} bytes`);
-                                this.tokenizer.ignore(ignoreSize);
+                                await this.tokenizer.ignore(ignoreSize);
                                 return ParseAction.SkipElement;
                             }
                         }
@@ -48,24 +93,28 @@ export class MatroskaParser extends BasicParser {
                         return ParseAction.ReadNext;
                 }
             },
-            elementValue: async (element, value, offset) => {
-                debug(`Received: name=${element.name}, value=${value}`);
-                switch (element.id) {
+            onElement: async (event) => {
+                if (debug.enabled) {
+                    const value = event.value instanceof Uint8Array ? `${event.value.byteLength} bytes` : event.value;
+                    debug(`Received: name=${event.element.name}, value=${value}`);
+                }
+                switch (event.id) {
                     case 0x4282: // docType
-                        this.metadata.setFormat('container', `EBML/${value}`);
+                        this.metadata.setFormat('container', `EBML/${event.value}`);
                         break;
                     case 0x114d9b74:
-                        this.seekHead = value;
-                        this.seekHeadOffset = offset;
+                        this.seekHead = event.value;
                         break;
                     case 0x1549a966:
                         {
                             // Info (Segment Information)
-                            const info = value;
+                            const info = event.value;
+                            if (info.title !== undefined) {
+                                await this.addTag('segment:title', info.title);
+                            }
                             const timecodeScale = info.timecodeScale ? info.timecodeScale : 1000000;
                             if (typeof info.duration === 'number') {
                                 const duration = (info.duration * timecodeScale) / 1000000000;
-                                await this.addTag('segment:title', info.title);
                                 if (Number.isFinite(duration) && duration > 0) {
                                     this.metadata.setFormat('duration', duration);
                                     this.metadata.setFormat('containerDuration', duration);
@@ -76,9 +125,18 @@ export class MatroskaParser extends BasicParser {
                     case 0x1654ae6b:
                         {
                             // tracks
-                            const audioTracks = value;
+                            const audioTracks = event.value;
                             if (audioTracks?.entries) {
-                                audioTracks.entries.forEach(entry => {
+                                const entries = audioTracks.entries
+                                    .filter(entry => {
+                                    if (isCompleteTrack(entry)) {
+                                        return true;
+                                    }
+                                    this.metadata.addWarning('Ignoring Matroska track without valid TrackNumber, TrackType or CodecID');
+                                    return false;
+                                })
+                                    .filter(isCompleteTrack);
+                                entries.forEach(entry => {
                                     const stream = {
                                         id: entry.trackNumber,
                                         codecId: entry.codecID,
@@ -98,7 +156,7 @@ export class MatroskaParser extends BasicParser {
                                                 channels: entry.audio?.channels ?? 1
                                             }
                                             : undefined,
-                                        video: entry.trackType === TrackType.video ? entry.video : undefined
+                                        video: entry.trackType === TrackType.video && entry.video ? videoInfo(entry.video) : undefined
                                     };
                                     if (stream.video && entry.defaultDuration && entry.defaultDuration > 0) {
                                         stream.video = { ...stream.video, frameRate: 1e9 / entry.defaultDuration };
@@ -108,7 +166,7 @@ export class MatroskaParser extends BasicParser {
                                     }
                                     this.metadata.addStreamInfo(stream);
                                 });
-                                const audioTrack = audioTracks.entries
+                                const audioTrack = entries
                                     .filter(entry => entry.trackType === TrackType.audio && entry.flagEnabled !== false)
                                     .reduce((acc, cur) => {
                                     if (!acc) {
@@ -136,50 +194,56 @@ export class MatroskaParser extends BasicParser {
                             }
                         }
                         break;
-                    case 0x1254c367:
-                        {
-                            // tags
-                            const tags = value;
-                            await Promise.all(tags.tag.map(async (tag) => {
-                                const target = tag.target;
-                                if (target?.tagTrackUID) {
-                                    const key = this.uidKey(target.tagTrackUID);
-                                    if (key !== '0') {
-                                        const statistics = this.trackStatistics.get(key) ?? new Map();
-                                        for (const simpleTag of tag.simpleTags) {
-                                            if (simpleTag.name && typeof simpleTag.string === 'string') {
-                                                statistics.set(simpleTag.name.toUpperCase(), simpleTag.string);
-                                            }
-                                        }
-                                        this.trackStatistics.set(key, statistics);
+                    case 0x7373: {
+                        // One Tag, released before the next sibling.
+                        const tag = event.value;
+                        const target = tag.target;
+                        for (const uid of target?.tagTrackUID ?? []) {
+                            const key = this.uidKey(uid);
+                            if (key !== '0') {
+                                const statistics = this.trackStatistics.get(key) ?? new Map();
+                                for (const simpleTag of tag.simpleTags ?? []) {
+                                    if (simpleTag.name && typeof simpleTag.string === 'string') {
+                                        statistics.set(simpleTag.name.toUpperCase(), simpleTag.string);
                                     }
                                 }
-                                const targetType = target?.targetTypeValue
-                                    ? TargetType[target.targetTypeValue]
-                                    : target?.targetType
-                                        ? target.targetType
-                                        : 'track';
-                                await Promise.all(tag.simpleTags.map(async (simpleTag) => {
-                                    const value = simpleTag.string ? simpleTag.string : simpleTag.binary;
-                                    await this.addTag(`${targetType}:${simpleTag.name}`, value);
-                                }));
-                            }));
+                                this.trackStatistics.set(key, statistics);
+                            }
+                        }
+                        const targetType = target?.targetTypeValue !== undefined
+                            ? (targetTypes[target.targetTypeValue] ?? 'track')
+                            : (target?.targetType ?? 'track');
+                        for (const simpleTag of tag.simpleTags ?? []) {
+                            const value = simpleTag.string ?? simpleTag.binary;
+                            if (simpleTag.name && value !== undefined) {
+                                await this.addTag(`${targetType}:${simpleTag.name}`, value);
+                            }
                         }
                         break;
-                    case 0x1941a469:
-                        {
-                            // attachments
-                            const attachments = value;
-                            await Promise.all(attachments.attachedFiles
-                                .filter(file => file.mimeType.startsWith('image/'))
-                                .map(file => this.addTag('picture', {
-                                data: file.data,
-                                format: file.mimeType,
-                                description: file.description,
-                                name: file.name
-                            })));
+                    }
+                    case 0x4660: // FileMediaType
+                        if (event.element.parent) {
+                            attachmentMimeTypes.set(event.element.parent, event.value);
                         }
                         break;
+                    case 0x61a7: {
+                        // One AttachedFile, released before the next sibling.
+                        const file = event.value;
+                        if (file.mimeType?.startsWith('image/')) {
+                            if (isCompleteFile(file)) {
+                                await this.addTag('picture', {
+                                    data: file.data,
+                                    format: file.mimeType,
+                                    description: file.description,
+                                    name: file.name
+                                });
+                            }
+                            else {
+                                this.metadata.addWarning('Ignoring incomplete Matroska image attachment');
+                            }
+                        }
+                        break;
+                    }
                 }
             }
         });

package/lib/matroska/types.d.ts

@@ -1,73 +1,38 @@
-import type { IEbmlDoc } from '../ebml/types.js';
-import type { IAudioTrack, IVideoTrack, TrackType } from '../type.js';
+import type { DecodedElement } from '../ebml/types.js';
+import type { TrackType } from '../type.js';
+import type { matroskaDtd } from './MatroskaDtd.js';
 export type { TrackTypeKey } from '../type.js';
 export { TrackType, TrackTypeValueToKeyMap } from '../type.js';
-export interface ISeek {
-    id: Uint8Array;
-    position: number;
-}
-export interface ISeekHead {
-    seek: ISeek[];
-}
-export interface ISegmentInformation {
-    uid?: Uint8Array;
-    timecodeScale?: number;
-    duration?: number;
-    dateUTC?: number;
-    title?: string;
-    muxingApp?: string;
-    writingApp?: string;
-}
-export interface ITrackEntry {
-    uid?: Uint8Array;
+export type IMatroskaDoc = DecodedElement<typeof matroskaDtd>;
+export type IMatroskaSegment = NonNullable<IMatroskaDoc['segment']>;
+export type ISeekHead = NonNullable<IMatroskaSegment['seekHead']>[number];
+export type ISeek = NonNullable<ISeekHead['seek']>[number];
+export type ISegmentInformation = NonNullable<IMatroskaSegment['info']>;
+export type ITrackElement = NonNullable<IMatroskaSegment['tracks']>;
+export type IDecodedTrackEntry = NonNullable<ITrackElement['entries']>[number];
+/** A decoded entry is promoted only after validating these mandatory fields. */
+export type ITrackEntry = IDecodedTrackEntry & {
     trackNumber: number;
-    trackType?: TrackType;
-    audio?: ITrackAudio;
-    video?: ITrackVideo;
-    flagEnabled?: boolean;
-    flagDefault?: boolean;
-    flagForced?: boolean;
-    flagLacing?: boolean;
-    defaultDuration?: number;
-    trackTimecodeScale?: number;
-    name?: string;
-    language?: string;
-    languageIETF?: string;
     codecID: string;
-    codecPrivate?: Uint8Array;
-    codecName?: string;
-    codecSettings?: string;
-    codecInfoUrl?: string;
-    codecDownloadUrl?: string;
-    codecDecodeAll?: string;
-    trackOverlay?: string;
-}
-export type ITrackVideo = IVideoTrack;
-export type ITrackAudio = IAudioTrack;
-export interface ICuePoint {
-    cueTime?: number;
-    cueTrackPositions: ICueTrackPosition[];
-}
-export interface ICueTrackPosition {
-    cueTrack?: number;
-    cueClusterPosition?: number;
-    cueBlockNumber?: number;
-    cueCodecState?: number;
-    cueReference?: ICueReference;
-}
-export interface ICueReference {
-    cueRefTime?: number;
-    cueRefCluster?: number;
-    cueRefNumber?: number;
-    cueRefCodecState?: number;
-}
-export interface ISimpleTag {
-    name?: string;
-    string?: string;
-    binary?: Uint8Array;
-    language?: string;
-    default?: boolean;
-}
+    trackType: TrackType;
+};
+export type ITrackVideo = NonNullable<IDecodedTrackEntry['video']>;
+export type ITrackAudio = NonNullable<IDecodedTrackEntry['audio']>;
+export type ICuePoint = NonNullable<NonNullable<IMatroskaSegment['cues']>['cuePoint']>[number];
+export type ICueTrackPosition = NonNullable<ICuePoint['positions']>[number];
+export type ICueReference = NonNullable<ICueTrackPosition['reference']>[number];
+export type ITags = NonNullable<IMatroskaSegment['tags']>[number];
+export type ITag = NonNullable<ITags['tag']>[number];
+export type ITarget = NonNullable<ITag['target']>;
+export type ISimpleTag = NonNullable<ITag['simpleTags']>[number];
+export type IAttachments = NonNullable<IMatroskaSegment['attachments']>;
+export type IDecodedAttachedFile = NonNullable<IAttachments['attachedFiles']>[number];
+export type IAttachedFile = IDecodedAttachedFile & {
+    name: string;
+    mimeType: string;
+    data: Uint8Array;
+    uid: Uint8Array;
+};
 export declare const TargetType: {
     10: string;
     20: string;
@@ -77,43 +42,3 @@ export declare const TargetType: {
     60: string;
     70: string;
 };
-export interface ITarget {
-    tagTrackUID?: Uint8Array;
-    trackUID?: Uint8Array;
-    chapterUID?: Uint8Array;
-    attachmentUID?: Uint8Array;
-    targetTypeValue?: keyof typeof TargetType;
-    targetType?: string;
-}
-export interface ITag {
-    target: ITarget;
-    simpleTags: ISimpleTag[];
-}
-export interface ITags {
-    tag: ITag[];
-}
-export interface ITrackElement {
-    entries?: ITrackEntry[];
-}
-export interface IAttachmedFile {
-    description?: string;
-    name: string;
-    mimeType: string;
-    data: Uint8Array;
-    uid: string;
-}
-export interface IAttachments {
-    attachedFiles: IAttachmedFile[];
-}
-export interface IMatroskaSegment {
-    metaSeekInfo?: ISeekHead;
-    seekHeads?: ISeek[];
-    info?: ISegmentInformation;
-    tracks?: ITrackElement;
-    tags?: ITags;
-    cues?: ICuePoint[];
-    attachments?: IAttachments;
-}
-export interface IMatroskaDoc extends IEbmlDoc {
-    segment: IMatroskaSegment;
-}