music-metadata 10.2.0 → 10.3.1

package/lib/ParseError.d.ts

@@ -0,0 +1,87 @@
+export type UnionOfParseErrors = CouldNotDetermineFileTypeError | UnsupportedFileTypeError | UnexpectedFileContentError | FieldDecodingError | InternalParserError;
+export declare const makeParseError: <Name extends string>(name: Name) => {
+    new (message: string): {
+        name: Name;
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+declare const CouldNotDetermineFileTypeError_base: {
+    new (message: string): {
+        name: "CouldNotDetermineFileTypeError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class CouldNotDetermineFileTypeError extends CouldNotDetermineFileTypeError_base {
+}
+declare const UnsupportedFileTypeError_base: {
+    new (message: string): {
+        name: "UnsupportedFileTypeError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class UnsupportedFileTypeError extends UnsupportedFileTypeError_base {
+}
+declare const UnexpectedFileContentError_base: {
+    new (message: string): {
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+declare class UnexpectedFileContentError extends UnexpectedFileContentError_base {
+    readonly fileType: string;
+    constructor(fileType: string, message: string);
+    toString(): string;
+}
+declare const FieldDecodingError_base: {
+    new (message: string): {
+        name: "FieldDecodingError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class FieldDecodingError extends FieldDecodingError_base {
+}
+declare const InternalParserError_base: {
+    new (message: string): {
+        name: "InternalParserError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};
+export declare class InternalParserError extends InternalParserError_base {
+}
+export declare const makeUnexpectedFileContentError: <FileType extends string>(fileType: FileType) => {
+    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 {};

package/lib/ParseError.js

@@ -0,0 +1,39 @@
+export const makeParseError = (name) => {
+    return class ParseError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = name;
+        }
+    };
+};
+// Concrete error class representing a file type determination failure.
+export class CouldNotDetermineFileTypeError extends makeParseError('CouldNotDetermineFileTypeError') {
+}
+// Concrete error class representing an unsupported file type.
+export class UnsupportedFileTypeError extends makeParseError('UnsupportedFileTypeError') {
+}
+// Concrete error class representing unexpected file content.
+class UnexpectedFileContentError extends makeParseError('UnexpectedFileContentError') {
+    constructor(fileType, message) {
+        super(message);
+        this.fileType = fileType;
+    }
+    // Override toString to include file type information.
+    toString() {
+        return `${this.name} (FileType: ${this.fileType}): ${this.message}`;
+    }
+}
+// Concrete error class representing a field decoding error.
+export class FieldDecodingError extends makeParseError('FieldDecodingError') {
+}
+export class InternalParserError extends makeParseError('InternalParserError') {
+}
+// Factory function to create a specific type of UnexpectedFileContentError.
+export const makeUnexpectedFileContentError = (fileType) => {
+    return class extends UnexpectedFileContentError {
+        constructor(message) {
+            super(fileType, message);
+        }
+    };
+};
+//# sourceMappingURL=ParseError.js.map

package/lib/ParserFactory.d.ts

@@ -1,6 +1,6 @@
 import { type MediaType } from 'media-typer';
 import { type INativeMetadataCollector } from './common/MetadataCollector.js';
-import type { IOptions, IAudioMetadata, ParserType } from './type.js';
+import type { IAudioMetadata, IOptions, ParserType } from './type.js';
 import type { ITokenizer } from 'strtok3';
 export interface ITokenParser {
     /**

package/lib/ParserFactory.js

@@ -16,6 +16,7 @@ import { WavPackParser } from './wavpack/WavPackParser.js';
 import { DsfParser } from './dsf/DsfParser.js';
 import { DsdiffParser } from './dsdiff/DsdiffParser.js';
 import { MatroskaParser } from './matroska/MatroskaParser.js';
+import { CouldNotDetermineFileTypeError, InternalParserError, UnsupportedFileTypeError } from './ParseError.js';
 const debug = initDebug('music-metadata:parser:factory');
 export function parseHttpContentType(contentType) {
     const type = ContentType.parse(contentType);
@@ -44,22 +45,22 @@ export async function parseOnContentType(tokenizer, opts) {
 }
 export async function parse(tokenizer, parserId, opts) {
     if (!parserId) {
-        // Parser could not be determined on MIME-type or extension
-        debug('Guess parser on content...');
-        const buf = new Uint8Array(4100);
-        await tokenizer.peekBuffer(buf, { mayBeLess: true });
         if (tokenizer.fileInfo.path) {
             parserId = getParserIdForExtension(tokenizer.fileInfo.path);
         }
         if (!parserId) {
+            // Parser could not be determined on MIME-type or extension
+            debug('Guess parser on content...');
+            const buf = new Uint8Array(4100);
+            await tokenizer.peekBuffer(buf, { mayBeLess: true });
             const guessedType = await fileTypeFromBuffer(buf);
             if (!guessedType) {
-                throw new Error('Failed to determine audio format');
+                throw new CouldNotDetermineFileTypeError('Failed to determine audio format');
             }
             debug(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`);
             parserId = getParserIdForMimeType(guessedType.mime);
             if (!parserId) {
-                throw new Error(`Guessed MIME-type not supported: ${guessedType.mime}`);
+                throw new UnsupportedFileTypeError(`Guessed MIME-type not supported: ${guessedType.mime}`);
             }
         }
     }
@@ -149,7 +150,7 @@ export async function loadParser(moduleName) {
         case 'wavpack': return new WavPackParser();
         case 'matroska': return new MatroskaParser();
         default:
-            throw new Error(`Unknown parser type: ${moduleName}`);
+            throw new InternalParserError(`Unknown parser type: ${moduleName}`);
     }
 }
 function getExtension(fname) {

package/lib/aiff/AiffParser.js

@@ -5,8 +5,8 @@ import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
 import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
 import * as AiffToken from './AiffToken.js';
+import { AiffContentError, compressionTypes } from './AiffToken.js';
 import * as iff from '../iff/index.js';
-import { compressionTypes } from './AiffToken.js';
 const debug = initDebug('music-metadata:parser:aiff');
 /**
  * AIFF - Audio Interchange File Format
@@ -23,7 +23,7 @@ export class AIFFParser extends BasicParser {
     async parse() {
         const header = await this.tokenizer.readToken(iff.Header);
         if (header.chunkID !== 'FORM')
-            throw new Error('Invalid Chunk-ID, expected \'FORM\''); // Not AIFF format
+            throw new AiffContentError('Invalid Chunk-ID, expected \'FORM\''); // Not AIFF format
         const type = await this.tokenizer.readToken(FourCcToken);
         switch (type) {
             case 'AIFF':
@@ -35,7 +35,7 @@ export class AIFFParser extends BasicParser {
                 this.isCompressed = true;
                 break;
             default:
-                throw new Error(`Unsupported AIFF type: ${type}`);
+                throw new AiffContentError(`Unsupported AIFF type: ${type}`);
         }
         this.metadata.setFormat('lossless', !this.isCompressed);
         try {
@@ -60,7 +60,7 @@ export class AIFFParser extends BasicParser {
         switch (header.chunkID) {
             case 'COMM': { // The Common Chunk
                 if (this.isCompressed === null) {
-                    throw new Error('Failed to parse AIFF.COMM chunk when compression type is unknown');
+                    throw new AiffContentError('Failed to parse AIFF.COMM chunk when compression type is unknown');
                 }
                 const common = await this.tokenizer.readToken(new AiffToken.Common(header, this.isCompressed));
                 this.metadata.setFormat('bitsPerSample', common.sampleSize);

package/lib/aiff/AiffToken.d.ts

@@ -12,6 +12,20 @@ export declare const compressionTypes: {
     FL32: string;
 };
 export type CompressionTypeCode = keyof typeof compressionTypes;
+declare const AiffContentError_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 AiffContentError extends AiffContentError_base {
+}
 /**
  * The Common Chunk.
  * Describes fundamental parameters of the waveform data such as sample rate, bit resolution, and how many channels of
@@ -31,3 +45,4 @@ export declare class Common implements IGetToken<ICommon> {
     constructor(header: iff.IChunkHeader, isAifc: boolean);
     get(buf: Uint8Array, off: number): ICommon;
 }
+export {};

package/lib/aiff/AiffToken.js

@@ -1,5 +1,6 @@
 import * as Token from 'token-types';
 import { FourCcToken } from '../common/FourCC.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 export const compressionTypes = {
     NONE: 'not compressed	PCM	Apple Computer',
     sowt: 'PCM (byte swapped)',
@@ -11,12 +12,14 @@ export const compressionTypes = {
     ALAW: 'CCITT G.711 A-law 8-bit ITU-T G.711 A-law',
     FL32: 'Float 32	IEEE 32-bit float '
 };
+export class AiffContentError extends makeUnexpectedFileContentError('AIFF') {
+}
 export class Common {
     constructor(header, isAifc) {
         this.isAifc = isAifc;
         const minimumChunkSize = isAifc ? 22 : 18;
         if (header.chunkSize < minimumChunkSize)
-            throw new Error(`COMMON CHUNK size should always be at least ${minimumChunkSize}`);
+            throw new AiffContentError(`COMMON CHUNK size should always be at least ${minimumChunkSize}`);
         this.len = header.chunkSize;
     }
     get(buf, off) {
@@ -39,7 +42,7 @@ export class Common {
                         res.compressionName = new Token.StringType(strLen, 'latin1').get(buf, off + 23);
                     }
                     else {
-                        throw new Error('Illegal pstring length');
+                        throw new AiffContentError('Illegal pstring length');
                     }
                 }
                 else {

package/lib/apev2/APEv2Parser.d.ts

@@ -3,6 +3,20 @@ import type { IOptions, IRandomReader, IApeHeader } from '../type.js';
 import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { type IFooter, type IHeader } from './APEv2Token.js';
+declare const ApeContentError_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 ApeContentError extends ApeContentError_base {
+}
 export declare class APEv2Parser extends BasicParser {
     static tryParseApeHeader(metadata: INativeMetadataCollector, tokenizer: strtok3.ITokenizer, options: IOptions): Promise<void>;
     /**
@@ -28,3 +42,4 @@ export declare class APEv2Parser extends BasicParser {
     private parseDescriptorExpansion;
     private parseHeader;
 }
+export {};

package/lib/apev2/APEv2Parser.js

@@ -5,9 +5,12 @@ import { uint8ArrayToString } from 'uint8array-extras';
 import * as util from '../common/Util.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { DataType, DescriptorParser, Header, TagFooter, TagItemHeader } from './APEv2Token.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:parser:APEv2');
 const tagFormat = 'APEv2';
 const preamble = 'APETAGEX';
+export class ApeContentError extends makeUnexpectedFileContentError('APEv2') {
+}
 export class APEv2Parser extends BasicParser {
     constructor() {
         super(...arguments);
@@ -52,7 +55,7 @@ export class APEv2Parser extends BasicParser {
     static parseTagFooter(metadata, buffer, options) {
         const footer = TagFooter.get(buffer, buffer.length - TagFooter.len);
         if (footer.ID !== preamble)
-            throw new Error('Unexpected APEv2 Footer ID preamble value.');
+            throw new ApeContentError('Unexpected APEv2 Footer ID preamble value');
         strtok3.fromBuffer(buffer);
         const apeParser = new APEv2Parser();
         apeParser.init(metadata, strtok3.fromBuffer(buffer), options);
@@ -83,7 +86,7 @@ export class APEv2Parser extends BasicParser {
     async parse() {
         const descriptor = await this.tokenizer.readToken(DescriptorParser);
         if (descriptor.ID !== 'MAC ')
-            throw new Error('Unexpected descriptor ID');
+            throw new ApeContentError('Unexpected descriptor ID');
         this.ape.descriptor = descriptor;
         const lenExp = descriptor.descriptorBytes - DescriptorParser.len;
         const header = await (lenExp > 0 ? this.parseDescriptorExpansion(lenExp) : this.parseHeader());
@@ -156,7 +159,7 @@ export class APEv2Parser extends BasicParser {
         this.metadata.setFormat('numberOfChannels', header.channel);
         this.metadata.setFormat('duration', APEv2Parser.calculateDuration(header));
         if (!this.ape.descriptor) {
-            throw new Error('Missing APE descriptor');
+            throw new ApeContentError('Missing APE descriptor');
         }
         return {
             forwardBytes: this.ape.descriptor.seekTableBytes + this.ape.descriptor.headerDataBytes +

package/lib/asf/AsfObject.d.ts

@@ -1,6 +1,20 @@
 import type { IGetToken, ITokenizer } from 'strtok3';
 import type { AnyTagValue, IPicture, ITag } from '../type.js';
 import GUID from './GUID.js';
+declare const AsfContentParseError_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 AsfContentParseError extends AsfContentParseError_base {
+}
 /**
  * Data Type: Specifies the type of information being stored. The following values are recognized.
  */
@@ -307,3 +321,4 @@ export declare class WmPictureToken implements IGetToken<IWmPicture> {
     constructor(len: number);
     get(buffer: Uint8Array, offset: number): IWmPicture;
 }
+export {};

package/lib/asf/AsfObject.js

@@ -4,6 +4,9 @@ import * as util from '../common/Util.js';
 import GUID from './GUID.js';
 import { getParserForAttr, parseUnicodeAttr } from './AsfUtil.js';
 import { AttachedPictureType } from '../id3v2/ID3v2Token.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+export class AsfContentParseError extends makeUnexpectedFileContentError('ASF') {
+}
 /**
  * Data Type: Specifies the type of information being stored. The following values are recognized.
  */
@@ -73,7 +76,7 @@ export class State {
         else {
             const parseAttr = getParserForAttr(valueType);
             if (!parseAttr) {
-                throw new Error(`unexpected value headerType: ${valueType}`);
+                throw new AsfContentParseError(`unexpected value headerType: ${valueType}`);
             }
             tags.push({ id: name, value: parseAttr(data) });
         }

package/lib/asf/AsfParser.js

@@ -3,6 +3,7 @@ import { TrackType } from '../type.js';
 import GUID from './GUID.js';
 import * as AsfObject from './AsfObject.js';
 import { BasicParser } from '../common/BasicParser.js';
+import { AsfContentParseError } from './AsfObject.js';
 const debug = initDebug('music-metadata:parser:ASF');
 const headerType = 'asf';
 /**
@@ -19,7 +20,7 @@ export class AsfParser extends BasicParser {
     async parse() {
         const header = await this.tokenizer.readToken(AsfObject.TopLevelHeaderObjectToken);
         if (!header.objectId.equals(GUID.HeaderObject)) {
-            throw new Error(`expected asf header; but was not found; got: ${header.objectId.str}`);
+            throw new AsfContentParseError(`expected asf header; but was not found; got: ${header.objectId.str}`);
         }
         try {
             await this.parseObjectHeader(header.numberOfHeaderObjects);

package/lib/common/CombinedTagMapper.js

@@ -8,6 +8,7 @@ import { VorbisTagMapper } from '../ogg/vorbis/VorbisTagMapper.js';
 import { RiffInfoTagMapper } from '../riff/RiffInfoTagMap.js';
 import { MatroskaTagMapper } from '../matroska/MatroskaTagMapper.js';
 import { AiffTagMapper } from '../aiff/AiffTagMap.js';
+import { InternalParserError } from '../ParseError.js';
 export class CombinedTagMapper {
     constructor() {
         this.tagMappers = {};
@@ -39,7 +40,7 @@ export class CombinedTagMapper {
         if (tagMapper) {
             return this.tagMappers[tagType].mapGenericTag(tag, warnings);
         }
-        throw new Error(`No generic tag mapper defined for tag-format: ${tagType}`);
+        throw new InternalParserError(`No generic tag mapper defined for tag-format: ${tagType}`);
     }
     registerTagMapper(genericTagMapper) {
         for (const tagType of genericTagMapper.tagTypes) {

package/lib/common/FourCC.js

@@ -1,5 +1,6 @@
 import { stringToUint8Array, uint8ArrayToString } from 'uint8array-extras';
 import * as util from './Util.js';
+import { InternalParserError, FieldDecodingError } from '../ParseError.js';
 const validFourCC = /^[\x21-\x7e©][\x20-\x7e\x00()]{3}/;
 /**
  * Token for read FourCC
@@ -10,14 +11,14 @@ export const FourCcToken = {
     get: (buf, off) => {
         const id = uint8ArrayToString(buf.slice(off, off + FourCcToken.len), 'latin1');
         if (!id.match(validFourCC)) {
-            throw new Error(`FourCC contains invalid characters: ${util.a2hex(id)} "${id}"`);
+            throw new FieldDecodingError(`FourCC contains invalid characters: ${util.a2hex(id)} "${id}"`);
         }
         return id;
     },
     put: (buffer, offset, id) => {
         const str = stringToUint8Array(id);
         if (str.length !== 4)
-            throw new Error('Invalid length');
+            throw new InternalParserError('Invalid length');
         buffer.set(str, offset);
         return offset + 4;
     }

package/lib/common/Util.js

@@ -1,4 +1,5 @@
 import { StringType } from 'token-types';
+import { FieldDecodingError } from '../ParseError.js';
 export function getBit(buf, off, bit) {
     return (buf[off] & (1 << bit)) !== 0;
 }
@@ -34,7 +35,7 @@ export function trimRightNull(x) {
 function swapBytes(uint8Array) {
     const l = uint8Array.length;
     if ((l & 1) !== 0)
-        throw new Error('Buffer length must be even');
+        throw new FieldDecodingError('Buffer length must be even');
     for (let i = 0; i < l; i += 2) {
         const a = uint8Array[i];
         uint8Array[i] = uint8Array[i + 1];
@@ -54,7 +55,7 @@ export function decodeString(uint8Array, encoding) {
     if (encoding === 'utf-16le' && uint8Array[0] === 0xFE && uint8Array[1] === 0xFF) {
         // BOM, indicating big endian decoding
         if ((uint8Array.length & 1) !== 0)
-            throw new Error('Expected even number of octets for 16-bit unicode string');
+            throw new FieldDecodingError('Expected even number of octets for 16-bit unicode string');
         return decodeString(swapBytes(uint8Array), encoding);
     }
     return new StringType(uint8Array.length, encoding).get(uint8Array, 0);

package/lib/core.d.ts

@@ -5,6 +5,7 @@ import { type AnyWebByteStream, type IFileInfo, type ITokenizer } from 'strtok3'
 import type { IAudioMetadata, INativeTagDict, IOptions, IPicture, IPrivateOptions, IRandomReader, ITag } from './type.js';
 export type { IFileInfo } from 'strtok3';
 export { type IAudioMetadata, type IOptions, type ITag, type INativeTagDict, type ICommonTagsResult, type IFormat, type IPicture, type IRatio, type IChapter, type ILyricsTag, LyricsContentType, TimestampFormat, IMetadataEventTag, IMetadataEvent } from './type.js';
+export type * from './ParseError.js';
 /**
  * Parse Web API File
  * Requires Blob to be able to stream using a ReadableStreamBYOBReader, only available since Node.js ≥ 20
@@ -22,7 +23,7 @@ export declare function parseBlob(blob: Blob, options?: IOptions): Promise<IAudi
  */
 export declare function parseWebStream(webStream: AnyWebByteStream, fileInfo?: IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
 /**
- * Parse audio from Node Buffer
+ * Parse audio from memory
  * @param uint8Array - Uint8Array holding audio data
  * @param fileInfo - File information object or MIME-type string
  * @param options - Parsing options
@@ -56,3 +57,4 @@ export declare function ratingToStars(rating: number | undefined): number;
  */
 export declare function selectCover(pictures?: IPicture[]): IPicture | null;
 export declare function scanAppendingHeaders(randomReader: IRandomReader, options?: IPrivateOptions): Promise<void>;
+export declare function loadMusicMetadata(): Promise<typeof import('music-metadata')>;

package/lib/core.js

@@ -33,7 +33,7 @@ export function parseWebStream(webStream, fileInfo, options = {}) {
     return parseFromTokenizer(fromWebStream(webStream, { fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo }), options);
 }
 /**
- * Parse audio from Node Buffer
+ * Parse audio from memory
  * @param uint8Array - Uint8Array holding audio data
  * @param fileInfo - File information object or MIME-type string
  * @param options - Parsing options

package/lib/default.cjs

@@ -0,0 +1,5 @@
+// CommonJS core (default) entry point
+"use strict";
+module.exports = {
+  loadMusicMetadata: () => import('./core.js'),
+};

package/lib/dsdiff/DsdiffParser.d.ts

@@ -1,4 +1,18 @@
 import { BasicParser } from '../common/BasicParser.js';
+declare const DsdiffContentParseError_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 DsdiffContentParseError extends DsdiffContentParseError_base {
+}
 /**
  * DSDIFF - Direct Stream Digital Interchange File Format (Phillips)
  *
@@ -12,3 +26,4 @@ export declare class DsdiffParser extends BasicParser {
     private handleSoundPropertyChunks;
     private handleChannelChunks;
 }
+export {};

package/lib/dsdiff/DsdiffParser.js

@@ -5,7 +5,10 @@ import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
 import { ChunkHeader64 } from './DsdiffToken.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:parser:aiff');
+export class DsdiffContentParseError extends makeUnexpectedFileContentError('DSDIFF') {
+}
 /**
  * DSDIFF - Direct Stream Digital Interchange File Format (Phillips)
  *
@@ -16,7 +19,7 @@ export class DsdiffParser extends BasicParser {
     async parse() {
         const header = await this.tokenizer.readToken(ChunkHeader64);
         if (header.chunkID !== 'FRM8')
-            throw new Error('Unexpected chunk-ID');
+            throw new DsdiffContentParseError('Unexpected chunk-ID');
         const type = (await this.tokenizer.readToken(FourCcToken)).trim();
         switch (type) {
             case 'DSD':
@@ -24,7 +27,7 @@ export class DsdiffParser extends BasicParser {
                 this.metadata.setFormat('lossless', true);
                 return this.readFmt8Chunks(header.chunkSize - BigInt(FourCcToken.len));
             default:
-                throw new Error(`Unsupported DSDIFF type: ${type}`);
+                throw new DsdiffContentParseError(`Unsupported DSDIFF type: ${type}`);
         }
     }
     async readFmt8Chunks(remainingSize) {
@@ -48,7 +51,7 @@ export class DsdiffParser extends BasicParser {
             case 'PROP': { // 3.2 PROPERTY CHUNK
                 const propType = await this.tokenizer.readToken(FourCcToken);
                 if (propType !== 'SND ')
-                    throw new Error('Unexpected PROP-chunk ID');
+                    throw new DsdiffContentParseError('Unexpected PROP-chunk ID');
                 await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCcToken.len));
                 break;
             }

package/lib/dsf/DsfParser.d.ts

@@ -1,4 +1,18 @@
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+declare const DsdContentParseError_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 DsdContentParseError extends DsdContentParseError_base {
+}
 /**
  * DSF (dsd stream file) File Parser
  * Ref: https://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf
@@ -7,3 +21,4 @@ export declare class DsfParser extends AbstractID3Parser {
     postId3v2Parse(): Promise<void>;
     private parseChunks;
 }
+export {};

package/lib/dsf/DsfParser.js

@@ -2,7 +2,10 @@ import initDebug from 'debug';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
 import { ChunkHeader, DsdChunk, FormatChunk } from './DsfChunk.js';
 import { ID3v2Parser } from "../id3v2/ID3v2Parser.js";
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:parser:DSF');
+export class DsdContentParseError extends makeUnexpectedFileContentError('DSD') {
+}
 /**
  * DSF (dsd stream file) File Parser
  * Ref: https://dsd-guide.com/sites/default/files/white-papers/DSFFileFormatSpec_E.pdf
@@ -12,7 +15,7 @@ export class DsfParser extends AbstractID3Parser {
         const p0 = this.tokenizer.position; // mark start position, normally 0
         const chunkHeader = await this.tokenizer.readToken(ChunkHeader);
         if (chunkHeader.id !== 'DSD ')
-            throw new Error('Invalid chunk signature');
+            throw new DsdContentParseError('Invalid chunk signature');
         this.metadata.setFormat('container', 'DSF');
         this.metadata.setFormat('lossless', true);
         const dsdChunk = await this.tokenizer.readToken(DsdChunk);

package/lib/ebml/EbmlIterator.d.ts

@@ -1,5 +1,19 @@
 import { type ITokenizer } from 'strtok3';
 import { type IElementType, type ITree, type ValueType } from './types.js';
+declare const EbmlContentError_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 EbmlContentError extends EbmlContentError_base {
+}
 export interface ILinkedElementType extends IElementType {
     id: number;
     parent: ILinkedElementType | undefined;
@@ -50,3 +64,4 @@ export declare class EbmlIterator {
     private readBuffer;
 }
 export declare function getElementPath(element: ILinkedElementType): string;
+export {};