music-metadata 10.0.1 → 10.2.0

package/lib/matroska/MatroskaParser.js

@@ -1,9 +1,8 @@
-import { Float32_BE, Float64_BE, StringType, UINT8 } from 'token-types';
 import initDebug from 'debug';
 import { BasicParser } from '../common/BasicParser.js';
-import * as matroskaDtd from './MatroskaDtd.js';
-import { DataType, TargetType, TrackType } from './types.js';
-import * as Token from 'token-types';
+import { matroskaDtd } from './MatroskaDtd.js';
+import { TargetType, TrackType } from './types.js';
+import { EbmlIterator, ParseAction } from '../ebml/EbmlIterator.js';
 const debug = initDebug('music-metadata:parser:matroska');
 /**
  * Extensible Binary Meta Language (EBML) parser
@@ -14,17 +13,13 @@ const debug = initDebug('music-metadata:parser:matroska');
  */
 export class MatroskaParser extends BasicParser {
     constructor() {
-        super();
-        this.padding = 0;
-        this.parserMap = new Map();
-        this.ebmlMaxIDLength = 4;
-        this.ebmlMaxSizeLength = 8;
-        this.parserMap.set(DataType.uint, e => this.readUint(e));
-        this.parserMap.set(DataType.string, e => this.readString(e));
-        this.parserMap.set(DataType.binary, e => this.readBuffer(e));
-        this.parserMap.set(DataType.uid, async (e) => this.readBuffer(e));
-        this.parserMap.set(DataType.bool, e => this.readFlag(e));
-        this.parserMap.set(DataType.float, e => this.readFloat(e));
+        super(...arguments);
+        this.seekHeadOffset = 0;
+        /**
+         * Use index to skip multiple segment/cluster elements at once.
+         * Significant performance impact
+         */
+        this.flagUseIndexToSkipClusters = false;
     }
     /**
      * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
@@ -34,207 +29,127 @@ export class MatroskaParser extends BasicParser {
      */
     init(metadata, tokenizer, options) {
         super.init(metadata, tokenizer, options);
+        this.flagUseIndexToSkipClusters = options.mkvUseIndex ?? false;
         return this;
     }
     async parse() {
-        var _a;
-        const containerSize = (_a = this.tokenizer.fileInfo.size) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER;
-        const matroska = await this.parseContainer(matroskaDtd.elements, containerSize, []);
-        this.metadata.setFormat('container', `EBML/${matroska.ebml.docType}`);
-        if (matroska.segment) {
-            const info = matroska.segment.info;
-            if (info) {
-                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);
-                    this.metadata.setFormat('duration', Number(duration));
-                }
-            }
-            const audioTracks = matroska.segment.tracks;
-            if (audioTracks && audioTracks.entries) {
-                audioTracks.entries.forEach(entry => {
-                    const stream = {
-                        codecName: entry.codecID.replace('A_', '').replace('V_', ''),
-                        codecSettings: entry.codecSettings,
-                        flagDefault: entry.flagDefault,
-                        flagLacing: entry.flagLacing,
-                        flagEnabled: entry.flagEnabled,
-                        language: entry.language,
-                        name: entry.name,
-                        type: entry.trackType,
-                        audio: entry.audio,
-                        video: entry.video
-                    };
-                    this.metadata.addStreamInfo(stream);
-                });
-                const audioTrack = audioTracks.entries
-                    .filter(entry => {
-                    return entry.trackType === TrackType.audio.valueOf();
-                })
-                    .reduce((acc, cur) => {
-                    if (!acc) {
-                        return cur;
-                    }
-                    if (!acc.flagDefault && cur.flagDefault) {
-                        return cur;
-                    }
-                    if (cur.trackNumber && cur.trackNumber < acc.trackNumber) {
-                        return cur;
-                    }
-                    return acc;
-                }, null);
-                if (audioTrack) {
-                    this.metadata.setFormat('codec', audioTrack.codecID.replace('A_', ''));
-                    this.metadata.setFormat('sampleRate', audioTrack.audio.samplingFrequency);
-                    this.metadata.setFormat('numberOfChannels', audioTrack.audio.channels);
-                }
-                if (matroska.segment.tags) {
-                    await Promise.all(matroska.segment.tags.tag.map(async (tag) => {
-                        const target = tag.target;
-                        const targetType = (target === null || target === void 0 ? void 0 : target.targetTypeValue) ? TargetType[target.targetTypeValue] : ((target === null || target === void 0 ? void 0 : 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);
-                        }));
-                    }));
-                }
-                if (matroska.segment.attachments) {
-                    await Promise.all(matroska.segment.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
-                    })));
-                }
-            }
-        }
-    }
-    async parseContainer(container, posDone, path) {
-        const tree = {};
-        while (this.tokenizer.position < posDone) {
-            let element;
-            try {
-                element = await this.readElement();
-            }
-            catch (error) {
-                if (error.message === 'End-Of-Stream') {
-                    break;
-                }
-                throw error;
-            }
-            const type = container[element.id];
-            if (type) {
-                debug(`Element: name=${type.name}, container=${!!type.container}`);
-                if (type.container) {
-                    const res = await this.parseContainer(type.container, element.len >= 0 ? this.tokenizer.position + element.len : -1, path.concat([type.name]));
-                    if (type.multiple) {
-                        if (!tree[type.name]) {
-                            tree[type.name] = [];
+        const containerSize = this.tokenizer.fileInfo.size ?? Number.MAX_SAFE_INTEGER;
+        const matroskaIterator = new EbmlIterator(this.tokenizer);
+        debug('Initializing DTD end MatroskaIterator');
+        await matroskaIterator.iterate(matroskaDtd, containerSize, {
+            startNext: (element) => {
+                switch (element.id) {
+                    // case 0x1f43b675: // cluster
+                    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) {
+                                // 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);
+                                return ParseAction.SkipElement;
+                            }
                         }
-                        tree[type.name].push(res);
-                    }
-                    else {
-                        tree[type.name] = res;
-                    }
-                }
-                else {
-                    tree[type.name] = await this.parserMap.get(type.value)(element);
+                        return ParseAction.IgnoreElement;
+                    default:
+                        return ParseAction.ReadNext;
                 }
-            }
-            else {
+            },
+            elementValue: async (element, value, offset) => {
+                debug(`Received: name=${element.name}, value=${value}`);
                 switch (element.id) {
-                    case 0xec: // void
-                        this.padding += element.len;
-                        await this.tokenizer.ignore(element.len);
+                    case 0x4282: // docType
+                        this.metadata.setFormat('container', `EBML/${value}`);
+                        break;
+                    case 0x114d9b74:
+                        this.seekHead = value;
+                        this.seekHeadOffset = offset;
+                        break;
+                    case 0x1549a966:
+                        { // Info (Segment Information)
+                            const info = value;
+                            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);
+                                this.metadata.setFormat('duration', Number(duration));
+                            }
+                        }
+                        break;
+                    case 0x1654ae6b:
+                        { // tracks
+                            const audioTracks = value;
+                            if (audioTracks?.entries) {
+                                audioTracks.entries.forEach(entry => {
+                                    const stream = {
+                                        codecName: entry.codecID.replace('A_', '').replace('V_', ''),
+                                        codecSettings: entry.codecSettings,
+                                        flagDefault: entry.flagDefault,
+                                        flagLacing: entry.flagLacing,
+                                        flagEnabled: entry.flagEnabled,
+                                        language: entry.language,
+                                        name: entry.name,
+                                        type: entry.trackType,
+                                        audio: entry.audio,
+                                        video: entry.video
+                                    };
+                                    this.metadata.addStreamInfo(stream);
+                                });
+                                const audioTrack = audioTracks.entries
+                                    .filter(entry => entry.trackType === TrackType.audio)
+                                    .reduce((acc, cur) => {
+                                    if (!acc)
+                                        return cur;
+                                    if (cur.flagDefault && !acc.flagDefault)
+                                        return cur;
+                                    if (cur.trackNumber < acc.trackNumber)
+                                        return cur;
+                                    return acc;
+                                }, null);
+                                if (audioTrack) {
+                                    this.metadata.setFormat('codec', audioTrack.codecID.replace('A_', ''));
+                                    this.metadata.setFormat('sampleRate', audioTrack.audio.samplingFrequency);
+                                    this.metadata.setFormat('numberOfChannels', audioTrack.audio.channels);
+                                }
+                            }
+                        }
+                        break;
+                    case 0x1254c367:
+                        { // tags
+                            const tags = value;
+                            await Promise.all(tags.tag.map(async (tag) => {
+                                const target = tag.target;
+                                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);
+                                }));
+                            }));
+                        }
+                        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
+                            })));
+                        }
                         break;
-                    default:
-                        debug(`parseEbml: path=${path.join('/')}, unknown element: id=${element.id.toString(16)}`);
-                        this.padding += element.len;
-                        await this.tokenizer.ignore(element.len);
                 }
             }
-        }
-        return tree;
-    }
-    async readVintData(maxLength) {
-        const msb = await this.tokenizer.peekNumber(UINT8);
-        let mask = 0x80;
-        let oc = 1;
-        // Calculate VINT_WIDTH
-        while ((msb & mask) === 0) {
-            if (oc > maxLength) {
-                throw new Error('VINT value exceeding maximum size');
-            }
-            ++oc;
-            mask >>= 1;
-        }
-        const id = new Uint8Array(oc);
-        await this.tokenizer.readBuffer(id);
-        return id;
-    }
-    async readElement() {
-        const id = await this.readVintData(this.ebmlMaxIDLength);
-        const lenField = await this.readVintData(this.ebmlMaxSizeLength);
-        lenField[0] ^= 0x80 >> (lenField.length - 1);
-        return {
-            id: MatroskaParser.readUIntBE(id, id.length),
-            len: MatroskaParser.readUIntBE(lenField, lenField.length)
-        };
-    }
-    async readFloat(e) {
-        switch (e.len) {
-            case 0:
-                return 0.0;
-            case 4:
-                return this.tokenizer.readNumber(Float32_BE);
-            case 8:
-                return this.tokenizer.readNumber(Float64_BE);
-            case 10:
-                return this.tokenizer.readNumber(Float64_BE);
-            default:
-                throw new Error(`Invalid IEEE-754 float length: ${e.len}`);
-        }
-    }
-    async readFlag(e) {
-        return (await this.readUint(e)) === 1;
-    }
-    async readUint(e) {
-        const buf = await this.readBuffer(e);
-        return MatroskaParser.readUIntBE(buf, e.len);
-    }
-    async readString(e) {
-        const rawString = await this.tokenizer.readToken(new StringType(e.len, 'utf-8'));
-        return rawString.replace(/\x00.*$/g, '');
-    }
-    async readBuffer(e) {
-        const buf = new Uint8Array(e.len);
-        await this.tokenizer.readBuffer(buf);
-        return buf;
+        });
     }
     async addTag(tagId, value) {
         await this.metadata.addTag('matroska', tagId, value);
     }
-    static readUIntBE(buf, len) {
-        return Number(MatroskaParser.readUIntBeAsBigInt(buf, len));
-    }
-    /**
-     * Reeds an unsigned integer from a big endian buffer of length `len`
-     * @param buf Buffer to decode from
-     * @param len Number of bytes
-     * @private
-     */
-    static readUIntBeAsBigInt(buf, len) {
-        const normalizedNumber = new Uint8Array(8);
-        const cleanNumber = buf.subarray(0, len);
-        try {
-            normalizedNumber.set(cleanNumber, 8 - len);
-            return Token.UINT64_BE.get(normalizedNumber, 0);
-        }
-        catch (error) {
-            return BigInt(-1);
-        }
-    }
 }
+//# sourceMappingURL=MatroskaParser.js.map

package/lib/matroska/types.d.ts

@@ -1,33 +1,10 @@
-export interface IHeader {
-    id: number;
-    len: number;
-}
-export declare enum DataType {
-    'string' = 0,
-    uint = 1,
-    uid = 2,
-    bool = 3,
-    binary = 4,
-    float = 5
-}
-export interface IElementType<T> {
-    readonly name: string;
-    readonly value?: DataType;
-    readonly container?: IContainerType;
-    readonly multiple?: boolean;
-}
-export interface IContainerType {
-    [id: number]: IElementType<string | number | boolean | Uint8Array>;
-}
-export interface ITree {
-    [name: string]: string | number | boolean | Uint8Array | ITree | ITree[];
+import type { IEbmlDoc } from '../ebml/types.js';
+export interface ISeek {
+    id: Uint8Array;
+    position: number;
 }
 export interface ISeekHead {
-    id?: Uint8Array;
-    position?: number;
-}
-export interface IMetaSeekInformation {
-    seekHeads: ISeekHead[];
+    seek: ISeek[];
 }
 export interface ISegmentInformation {
     uid?: Uint8Array;
@@ -40,9 +17,9 @@ export interface ISegmentInformation {
 }
 export interface ITrackEntry {
     uid?: Uint8Array;
-    trackNumber?: number;
+    trackNumber: number;
     trackType?: TrackType;
-    audio?: ITrackAudio;
+    audio: ITrackAudio;
     video?: ITrackVideo;
     flagEnabled?: boolean;
     flagDefault?: boolean;
@@ -51,7 +28,7 @@ export interface ITrackEntry {
     trackTimecodeScale?: number;
     name?: string;
     language?: string;
-    codecID?: string;
+    codecID: string;
     codecPrivate?: Uint8Array;
     codecName?: string;
     codecSettings?: string;
@@ -121,6 +98,7 @@ export declare enum TrackType {
     button = 18,
     control = 32
 }
+export type TrackTypeKey = keyof TrackType;
 export interface ITarget {
     trackUID?: Uint8Array;
     chapterUID?: Uint8Array;
@@ -146,29 +124,17 @@ export interface IAttachmedFile {
     uid: string;
 }
 export interface IAttachments {
-    attachedFiles?: IAttachmedFile[];
+    attachedFiles: IAttachmedFile[];
 }
 export interface IMatroskaSegment {
-    metaSeekInfo?: IMetaSeekInformation;
-    seekHeads?: ISeekHead[];
+    metaSeekInfo?: ISeekHead;
+    seekHeads?: ISeek[];
     info?: ISegmentInformation;
     tracks?: ITrackElement;
     tags?: ITags;
     cues?: ICuePoint[];
     attachments?: IAttachments;
 }
-export interface IEbmlElements {
-    version?: number;
-    readVersion?: number;
-    maxIDWidth?: number;
-    maxSizeWidth?: number;
-    docType?: string;
-    docTypeVersion?: number;
-    docTypeReadVersion?: number;
-}
-export interface IEbmlDoc {
-    ebml: IEbmlElements;
-}
 export interface IMatroskaDoc extends IEbmlDoc {
     segment: IMatroskaSegment;
 }

package/lib/matroska/types.js

@@ -1,12 +1,3 @@
-export var DataType;
-(function (DataType) {
-    DataType[DataType["string"] = 0] = "string";
-    DataType[DataType["uint"] = 1] = "uint";
-    DataType[DataType["uid"] = 2] = "uid";
-    DataType[DataType["bool"] = 3] = "bool";
-    DataType[DataType["binary"] = 4] = "binary";
-    DataType[DataType["float"] = 5] = "float";
-})(DataType || (DataType = {}));
 export var TargetType;
 (function (TargetType) {
     TargetType[TargetType["shot"] = 10] = "shot";

package/lib/mp4/Atom.d.ts

@@ -4,11 +4,11 @@ export type AtomDataHandler = (atom: Atom, remaining: number) => Promise<void>;
 export declare class Atom {
     readonly header: AtomToken.IAtomHeader;
     extended: boolean;
-    readonly parent: Atom;
-    static readAtom(tokenizer: ITokenizer, dataHandler: AtomDataHandler, parent: Atom, remaining: number): Promise<Atom>;
+    readonly parent: Atom | null;
+    static readAtom(tokenizer: ITokenizer, dataHandler: AtomDataHandler, parent: Atom | null, remaining: number): Promise<Atom>;
     readonly children: Atom[];
     readonly atomPath: string;
-    constructor(header: AtomToken.IAtomHeader, extended: boolean, parent: Atom);
+    constructor(header: AtomToken.IAtomHeader, extended: boolean, parent: Atom | null);
     getHeaderLength(): number;
     getPayloadLength(remaining: number): number;
     readAtoms(tokenizer: ITokenizer, dataHandler: AtomDataHandler, size: number): Promise<void>;

package/lib/mp4/Atom.js

@@ -23,7 +23,7 @@ export class Atom {
         this.extended = extended;
         this.parent = parent;
         this.children = [];
-        this.atomPath = (this.parent ? this.parent.atomPath + '.' : '') + this.header.name;
+        this.atomPath = (this.parent ? `${this.parent.atomPath}.` : '') + this.header.name;
     }
     getHeaderLength() {
         return this.extended ? 16 : 8;
@@ -51,19 +51,16 @@ export class Atom {
             case 'ilst':
             case 'tref':
                 return this.readAtoms(tokenizer, dataHandler, this.getPayloadLength(remaining));
-            case 'meta': // Metadata Atom, ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW8
+            case 'meta': { // Metadata Atom, ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW8
                 // meta has 4 bytes of padding, ignore
                 const peekHeader = await tokenizer.peekToken(Header);
                 const paddingLength = peekHeader.name === 'hdlr' ? 0 : 4;
                 await tokenizer.ignore(paddingLength);
                 return this.readAtoms(tokenizer, dataHandler, this.getPayloadLength(remaining) - paddingLength);
-            case 'mdhd': // Media header atom
-            case 'mvhd': // 'movie' => 'mvhd': movie header atom; child of Movie Atom
-            case 'tkhd':
-            case 'stsz':
-            case 'mdat':
+            }
             default:
                 return dataHandler(this, remaining);
         }
     }
 }
+//# sourceMappingURL=Atom.js.map

package/lib/mp4/AtomToken.js

@@ -68,7 +68,7 @@ export class FixedLengthAtom {
         if (len < expLen) {
             throw new Error(`Atom ${atomId} expected to be ${expLen}, but specifies ${len} bytes long.`);
         }
-        else if (len > expLen) {
+        if (len > expLen) {
             debug(`Warning: atom ${atomId} expected to be ${expLen}, but was actually ${len} bytes long.`);
         }
     }
@@ -390,3 +390,4 @@ function readTokenTable(buf, token, off, remainingLen, numberOfEntries) {
     }
     return entries;
 }
+//# sourceMappingURL=AtomToken.js.map

package/lib/mp4/MP4Parser.js

@@ -91,6 +91,7 @@ function distinct(value, index, self) {
 export class MP4Parser extends BasicParser {
     constructor() {
         super(...arguments);
+        this.tracks = [];
         this.atomParsers = {
             /**
              * Parse movie header (mvhd) atom
@@ -208,13 +209,13 @@ export class MP4Parser extends BasicParser {
         const integerType = (signed ? 'INT' : 'UINT') + array.length * 8 + (array.length > 1 ? '_BE' : '');
         const token = Token[integerType];
         if (!token) {
-            throw new Error('Token for integer type not found: "' + integerType + '"');
+            throw new Error(`Token for integer type not found: "${integerType}"`);
         }
         return Number(token.get(array, 0));
     }
     async parse() {
         this.tracks = [];
-        let remainingFileSize = this.tokenizer.fileInfo.size;
+        let remainingFileSize = this.tokenizer.fileInfo.size || 0;
         while (!this.tokenizer.fileInfo.size || remainingFileSize > 0) {
             try {
                 const token = await this.tokenizer.peekToken(AtomToken.Header);
@@ -226,9 +227,13 @@ export class MP4Parser extends BasicParser {
                 }
             }
             catch (error) {
-                const errMsg = `Error at offset=${this.tokenizer.position}: ${error.message}`;
-                debug(errMsg);
-                this.addWarning(errMsg);
+                if (error instanceof Error) {
+                    const errMsg = `Error at offset=${this.tokenizer.position}: ${error.message}`;
+                    debug(errMsg);
+                    this.addWarning(errMsg);
+                }
+                else
+                    throw error;
                 break;
             }
             const rootAtom = await Atom.readAtom(this.tokenizer, (atom, remaining) => this.handleAtom(atom, remaining), null, remainingFileSize);
@@ -309,10 +314,8 @@ export class MP4Parser extends BasicParser {
         if (this.atomParsers[atom.header.name]) {
             return this.atomParsers[atom.header.name](remaining);
         }
-        else {
-            debug(`No parser for atom path=${atom.atomPath}, payload-len=${remaining}, ignoring atom`);
-            await this.tokenizer.ignore(remaining);
-        }
+        debug(`No parser for atom path=${atom.atomPath}, payload-len=${remaining}, ignoring atom`);
+        await this.tokenizer.ignore(remaining);
     }
     getTrackDescription() {
         return this.tracks[this.tracks.length - 1];
@@ -326,7 +329,7 @@ export class MP4Parser extends BasicParser {
         await this.metadata.addTag(tagFormat, id, value);
     }
     addWarning(message) {
-        debug('Warning: ' + message);
+        debug(`Warning: ${message}`);
         this.metadata.addWarning(message);
     }
     /**
@@ -343,20 +346,22 @@ export class MP4Parser extends BasicParser {
                     return this.parseValueAtom(tagKey, child);
                 case 'name': // name atom (optional)
                 case 'mean':
-                case 'rate':
+                case 'rate': {
                     const name = await this.tokenizer.readToken(new AtomToken.NameAtom(payLoadLength));
-                    tagKey += ':' + name.name;
+                    tagKey += `:${name.name}`;
                     break;
-                default:
+                }
+                default: {
                     const uint8Array = await this.tokenizer.readToken(new Token.Uint8ArrayType(payLoadLength));
-                    this.addWarning('Unsupported meta-item: ' + tagKey + '[' + child.header.name + '] => value=' + uint8ArrayToHex(uint8Array) + ' ascii=' + uint8ArrayToString(uint8Array, 'ascii'));
+                    this.addWarning(`Unsupported meta-item: ${tagKey}[${child.header.name}] => value=${uint8ArrayToHex(uint8Array)} ascii=${uint8ArrayToString(uint8Array, 'ascii')}`);
+                }
             }
         }, metaAtom.getPayloadLength(0));
     }
     async parseValueAtom(tagKey, metaAtom) {
         const dataAtom = await this.tokenizer.readToken(new AtomToken.DataAtom(Number(metaAtom.header.length) - AtomToken.Header.len));
         if (dataAtom.type.set !== 0) {
-            throw new Error('Unsupported type-set != 0: ' + dataAtom.type.set);
+            throw new Error(`Unsupported type-set != 0: ${dataAtom.type.set}`);
         }
         // Use well-known-type table
         // Ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW35
@@ -364,24 +369,27 @@ export class MP4Parser extends BasicParser {
             case 0: // reserved: Reserved for use where no type needs to be indicated
                 switch (tagKey) {
                     case 'trkn':
-                    case 'disk':
+                    case 'disk': {
                         const num = Token.UINT8.get(dataAtom.value, 3);
                         const of = Token.UINT8.get(dataAtom.value, 5);
                         // console.log("  %s[data] = %s/%s", tagKey, num, of);
-                        await this.addTag(tagKey, num + '/' + of);
+                        await this.addTag(tagKey, `${num}/${of}`);
                         break;
-                    case 'gnre':
+                    }
+                    case 'gnre': {
                         const genreInt = Token.UINT8.get(dataAtom.value, 1);
                         const genreStr = Genres[genreInt - 1];
                         // console.log("  %s[data] = %s", tagKey, genreStr);
                         await this.addTag(tagKey, genreStr);
                         break;
-                    case 'rate':
+                    }
+                    case 'rate': {
                         const rate = new TextDecoder('ascii').decode(dataAtom.value);
                         await this.addTag(tagKey, rate);
                         break;
+                    }
                     default:
-                        debug('unknown proprietary value type for: ' + metaAtom.atomPath);
+                        debug(`unknown proprietary value type for: ${metaAtom.atomPath}`);
                 }
                 break;
             case 1: // UTF-8: Without any count or NULL terminator
@@ -515,3 +523,4 @@ export class MP4Parser extends BasicParser {
         return stcTable[stcTable.length - 1].samplesPerChunk;
     }
 }
+//# sourceMappingURL=MP4Parser.js.map