music-metadata 10.1.0 → 10.3.0

package/lib/matroska/MatroskaParser.js

@@ -1,10 +1,8 @@
-import { Float32_BE, Float64_BE, StringType, UINT8 } from 'token-types';
 import initDebug from 'debug';
-import { EndOfStreamError } from 'strtok3';
 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
@@ -15,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).
@@ -35,206 +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 === null || audioTracks === void 0 ? void 0 : 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);
-                }
-                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 instanceof EndOfStreamError) {
-                    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 {
-                    const parser = this.parserMap.get(type.value);
-                    if (typeof parser === 'function') {
-                        tree[type.name] = await parser(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,34 +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[];
-}
-export type ValueType = string | number | Uint8Array | boolean | ITree | ITree[];
-export interface ISeekHead {
-    id?: Uint8Array;
-    position?: number;
+import type { IEbmlDoc } from '../ebml/types.js';
+export interface ISeek {
+    id: Uint8Array;
+    position: number;
 }
-export interface IMetaSeekInformation {
-    seekHeads: ISeekHead[];
+export interface ISeekHead {
+    seek: ISeek[];
 }
 export interface ISegmentInformation {
     uid?: Uint8Array;
@@ -151,26 +127,14 @@ export interface IAttachments {
     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/AtomToken.d.ts

@@ -1,4 +1,18 @@
 import type { IToken, IGetToken } from 'strtok3';
+declare const Mp4ContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class Mp4ContentError extends Mp4ContentError_base {
+}
 interface IVersionAndFlags {
     /**
      * A 1-byte specification of the version

package/lib/mp4/AtomToken.js

@@ -1,13 +1,16 @@
 import * as Token from 'token-types';
 import initDebug from 'debug';
 import { FourCcToken } from '../common/FourCC.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:parser:MP4:atom');
+export class Mp4ContentError extends makeUnexpectedFileContentError('MP4') {
+}
 export const Header = {
     len: 8,
     get: (buf, off) => {
         const length = Token.UINT32_BE.get(buf, off);
         if (length < 0)
-            throw new Error('Invalid atom header length');
+            throw new Mp4ContentError('Invalid atom header length');
         return {
             length: BigInt(length),
             name: new Token.StringType(4, 'latin1').get(buf, off + 4)
@@ -66,7 +69,7 @@ export class FixedLengthAtom {
     constructor(len, expLen, atomId) {
         this.len = len;
         if (len < expLen) {
-            throw new Error(`Atom ${atomId} expected to be ${expLen}, but specifies ${len} bytes long.`);
+            throw new Mp4ContentError(`Atom ${atomId} expected to be ${expLen}, but specifies ${len} bytes long.`);
         }
         if (len > expLen) {
             debug(`Warning: atom ${atomId} expected to be ${expLen}, but was actually ${len} bytes long.`);
@@ -381,7 +384,7 @@ function readTokenTable(buf, token, off, remainingLen, numberOfEntries) {
     if (remainingLen === 0)
         return [];
     if (remainingLen !== numberOfEntries * token.len)
-        throw new Error('mismatch number-of-entries with remaining atom-length');
+        throw new Mp4ContentError('mismatch number-of-entries with remaining atom-length');
     const entries = [];
     // parse offset-table
     for (let n = 0; n < numberOfEntries; ++n) {

package/lib/mp4/MP4Parser.js

@@ -6,6 +6,7 @@ import { Atom } from './Atom.js';
 import * as AtomToken from './AtomToken.js';
 import { TrackType } from '../type.js';
 import { uint8ArrayToHex, uint8ArrayToString } from 'uint8array-extras';
+import { Mp4ContentError } from './AtomToken.js';
 const debug = initDebug('music-metadata:parser:MP4');
 const tagFormat = 'iTunes';
 const encoderDict = {
@@ -209,7 +210,7 @@ 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 Mp4ContentError(`Token for integer type not found: "${integerType}"`);
         }
         return Number(token.get(array, 0));
     }
@@ -361,7 +362,7 @@ export class MP4Parser extends BasicParser {
     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 Mp4ContentError(`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
@@ -464,7 +465,7 @@ export class MP4Parser extends BasicParser {
             const sampleSize = chapterTrack.sampleSize > 0 ? chapterTrack.sampleSize : chapterTrack.sampleSizeTable[i];
             len -= nextChunkLen + sampleSize;
             if (len < 0)
-                throw new Error('Chapter chunk exceeding token length');
+                throw new Mp4ContentError('Chapter chunk exceeding token length');
             await this.tokenizer.ignore(nextChunkLen);
             const title = await this.tokenizer.readToken(new AtomToken.ChapterText(sampleSize));
             debug(`Chapter ${i + 1}: ${title}`);

package/lib/mpeg/MpegParser.d.ts

@@ -1,4 +1,18 @@
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+declare const MpegContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class MpegContentError extends MpegContentError_base {
+}
 export declare class MpegParser extends AbstractID3Parser {
     private frameCount;
     private syncFrameCount;
@@ -47,3 +61,4 @@ export declare class MpegParser extends AbstractID3Parser {
     private skipFrameData;
     private areAllSame;
 }
+export {};

package/lib/mpeg/MpegParser.js

@@ -4,7 +4,10 @@ import initDebug from 'debug';
 import * as common from '../common/Util.js';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
 import { InfoTagHeaderTag, LameEncoderVersion, readXingHeader } from './XingTag.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:parser:mpeg');
+export class MpegContentError extends makeUnexpectedFileContentError('MPEG') {
+}
 /**
  * Cache buffer size used for searching synchronization preabmle
  */
@@ -140,13 +143,13 @@ class MpegFrameHeader {
         // Calculate bitrate
         const bitrateInKbps = this.calcBitrate();
         if (!bitrateInKbps) {
-            throw new Error('Cannot determine bit-rate');
+            throw new MpegContentError('Cannot determine bit-rate');
         }
         this.bitrate = bitrateInKbps * 1000;
         // Calculate sampling rate
         this.samplingRate = this.calcSamplingRate();
         if (this.samplingRate == null) {
-            throw new Error('Cannot determine sampling-rate');
+            throw new MpegContentError('Cannot determine sampling-rate');
         }
     }
     parseAdtsHeader(buf, off) {
@@ -383,7 +386,7 @@ export class MpegParser extends AbstractID3Parser {
         }
         const slot_size = header.calcSlotSize();
         if (slot_size === null) {
-            throw new Error('invalid slot_size');
+            throw new MpegContentError('invalid slot_size');
         }
         const samples_per_frame = header.calcSamplesPerFrame();
         debug(`samples_per_frame=${samples_per_frame}`);
@@ -555,7 +558,7 @@ export class MpegParser extends AbstractID3Parser {
     }
     async skipFrameData(frameDataLeft) {
         if (frameDataLeft < 0)
-            throw new Error('frame-data-left cannot be negative');
+            throw new MpegContentError('frame-data-left cannot be negative');
         await this.tokenizer.ignore(frameDataLeft);
         this.countSkipFrameData += frameDataLeft;
     }

package/lib/musepack/MusepackConentError.d.ts

@@ -0,0 +1,15 @@
+declare const MusepackContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class MusepackContentError extends MusepackContentError_base {
+}
+export {};

package/lib/musepack/MusepackConentError.js

@@ -0,0 +1,4 @@
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+export class MusepackContentError extends makeUnexpectedFileContentError('Musepack') {
+}
+//# sourceMappingURL=MusepackConentError.js.map

package/lib/musepack/index.js

@@ -3,6 +3,7 @@ import * as Token from 'token-types';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
 import { MpcSv8Parser } from './sv8/MpcSv8Parser.js';
 import { MpcSv7Parser } from './sv7/MpcSv7Parser.js';
+import { MusepackContentError } from './MusepackConentError.js';
 const debug = initDebug('music-metadata:parser:musepack');
 class MusepackParser extends AbstractID3Parser {
     async postId3v2Parse() {
@@ -10,17 +11,17 @@ class MusepackParser extends AbstractID3Parser {
         let mpcParser;
         switch (signature) {
             case 'MP+': {
-                debug('Musepack stream-version 7');
+                debug('Stream-version 7');
                 mpcParser = new MpcSv7Parser();
                 break;
             }
             case 'MPC': {
-                debug('Musepack stream-version 8');
+                debug('Stream-version 8');
                 mpcParser = new MpcSv8Parser();
                 break;
             }
             default: {
-                throw new Error('Invalid Musepack signature prefix');
+                throw new MusepackContentError('Invalid signature prefix');
             }
         }
         mpcParser.init(this.metadata, this.tokenizer, this.options);