music-metadata 10.2.0 → 10.3.0

package/lib/ebml/EbmlIterator.js

@@ -3,7 +3,10 @@ import initDebug from 'debug';
 import { EndOfStreamError } from 'strtok3';
 import { DataType } from './types.js';
 import * as Token from 'token-types';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:parser:ebml');
+export class EbmlContentError extends makeUnexpectedFileContentError('EBML') {
+}
 export var ParseAction;
 (function (ParseAction) {
     ParseAction[ParseAction["ReadNext"] = 0] = "ReadNext";
@@ -127,7 +130,7 @@ export class EbmlIterator {
         // Calculate VINT_WIDTH
         while ((msb & mask) === 0) {
             if (oc > maxLength) {
-                throw new Error('VINT value exceeding maximum size');
+                throw new EbmlContentError('VINT value exceeding maximum size');
             }
             ++oc;
             mask >>= 1;
@@ -156,7 +159,7 @@ export class EbmlIterator {
             case 10:
                 return this.tokenizer.readNumber(Float64_BE);
             default:
-                throw new Error(`Invalid IEEE-754 float length: ${e.len}`);
+                throw new EbmlContentError(`Invalid IEEE-754 float length: ${e.len}`);
         }
     }
     async readFlag(e) {

package/lib/flac/FlacParser.js

@@ -6,7 +6,10 @@ import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
 import { FourCcToken } from '../common/FourCC.js';
 import { VorbisParser } from '../ogg/vorbis/VorbisParser.js';
 import { VorbisDecoder } from '../ogg/vorbis/VorbisDecoder.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:parser:FLAC');
+class FlacContentError extends makeUnexpectedFileContentError('FLAC') {
+}
 /**
  * FLAC supports up to 128 kinds of metadata blocks; currently the following are defined:
  * ref: https://xiph.org/flac/format.html#metadata_block
@@ -40,7 +43,7 @@ export class FlacParser extends AbstractID3Parser {
     async postId3v2Parse() {
         const fourCC = await this.tokenizer.readToken(FourCcToken);
         if (fourCC.toString() !== 'fLaC') {
-            throw new Error('Invalid FLAC preamble');
+            throw new FlacContentError('Invalid FLAC preamble');
         }
         let blockHeader;
         do {
@@ -84,7 +87,7 @@ export class FlacParser extends AbstractID3Parser {
      */
     async parseBlockStreamInfo(dataLen) {
         if (dataLen !== BlockStreamInfo.len)
-            throw new Error('Unexpected block-stream-info length');
+            throw new FlacContentError('Unexpected block-stream-info length');
         const streamInfo = await this.tokenizer.readToken(BlockStreamInfo);
         this.metadata.setFormat('container', 'FLAC');
         this.metadata.setFormat('codec', 'FLAC');

package/lib/id3v2/FrameParser.d.ts

@@ -57,4 +57,18 @@ export declare class FrameParser {
     private static readIdentifierAndData;
     private static getNullTerminatorLength;
 }
+declare const Id3v2ContentError_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 Id3v2ContentError extends Id3v2ContentError_base {
+}
 export {};

package/lib/id3v2/FrameParser.js

@@ -3,6 +3,7 @@ import * as Token from 'token-types';
 import * as util from '../common/Util.js';
 import { AttachedPictureType, SyncTextHeader, TextEncodingToken, TextHeader } from './ID3v2Token.js';
 import { Genres } from '../id3v1/ID3v1Parser.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:id3v2:frame-parser');
 const defaultEnc = 'latin1'; // latin1 == iso-8859-1;
 export function parseGenre(origVal) {
@@ -158,7 +159,7 @@ export class FrameParser {
                             offset = fzero + 1;
                             break;
                         default:
-                            throw new Error(`Warning: unexpected major versionIndex: ${this.major}`);
+                            throw makeUnexpectedMajorVersionError(this.major);
                     }
                     pic.format = FrameParser.fixPictureMimeType(pic.format);
                     pic.type = AttachedPictureType[uint8Array[offset]];
@@ -370,4 +371,9 @@ export class FrameParser {
         return enc === 'utf-16le' ? 2 : 1;
     }
 }
+export class Id3v2ContentError extends makeUnexpectedFileContentError('id3v2') {
+}
+function makeUnexpectedMajorVersionError(majorVer) {
+    throw new Id3v2ContentError(`Unexpected majorVer: ${majorVer}`);
+}
 //# sourceMappingURL=FrameParser.js.map

package/lib/id3v2/ID3v2Parser.js

@@ -1,6 +1,6 @@
 import * as Token from 'token-types';
 import * as util from '../common/Util.js';
-import { FrameParser } from './FrameParser.js';
+import { FrameParser, Id3v2ContentError } from './FrameParser.js';
 import { ExtendedHeader, ID3v2Header, UINT32SYNCSAFE } from './ID3v2Token.js';
 const asciiDecoder = new TextDecoder('ascii');
 export class ID3v2Parser {
@@ -34,7 +34,7 @@ export class ID3v2Parser {
             case 4:
                 return 10;
             default:
-                throw new Error('header versionIndex is incorrect');
+                throw makeUnexpectedMajorVersionError(majorVer);
         }
     }
     static readFrameFlags(b) {
@@ -68,7 +68,7 @@ export class ID3v2Parser {
                 }
                 return frameParser.readData(uint8Array, frameHeader.id, includeCovers);
             default:
-                throw new Error(`Unexpected majorVer: ${majorVer}`);
+                throw makeUnexpectedMajorVersionError(majorVer);
         }
     }
     /**
@@ -86,7 +86,7 @@ export class ID3v2Parser {
         this.options = options;
         const id3Header = await this.tokenizer.readToken(ID3v2Header);
         if (id3Header.fileIdentifier !== 'ID3') {
-            throw new Error('expected ID3-header file-identifier \'ID3\' was not found');
+            throw new Id3v2ContentError('expected ID3-header file-identifier \'ID3\' was not found');
         }
         this.id3Header = id3Header;
         this.headerType = (`ID3v2.${id3Header.version.major}`);
@@ -168,9 +168,12 @@ export class ID3v2Parser {
                 }
                 break;
             default:
-                throw new Error(`Unexpected majorVer: ${majorVer}`);
+                throw makeUnexpectedMajorVersionError(majorVer);
         }
         return header;
     }
 }
+function makeUnexpectedMajorVersionError(majorVer) {
+    throw new Id3v2ContentError(`Unexpected majorVer: ${majorVer}`);
+}
 //# sourceMappingURL=ID3v2Parser.js.map

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);

package/lib/musepack/sv7/MpcSv7Parser.js

@@ -3,6 +3,7 @@ import { BasicParser } from '../../common/BasicParser.js';
 import { APEv2Parser } from '../../apev2/APEv2Parser.js';
 import { BitReader } from './BitReader.js';
 import * as SV7 from './StreamVersion7.js';
+import { MusepackContentError } from '../MusepackConentError.js';
 const debug = initDebug('music-metadata:parser:musepack');
 export class MpcSv7Parser extends BasicParser {
     constructor() {
@@ -14,7 +15,7 @@ export class MpcSv7Parser extends BasicParser {
     async parse() {
         const header = await this.tokenizer.readToken(SV7.Header);
         if (header.signature !== 'MP+')
-            throw new Error('Unexpected magic number');
+            throw new MusepackContentError('Unexpected magic number');
         debug(`stream-version=${header.streamMajorVersion}.${header.streamMinorVersion}`);
         this.metadata.setFormat('container', 'Musepack, SV7');
         this.metadata.setFormat('sampleRate', header.sampleFrequency);

package/lib/musepack/sv8/MpcSv8Parser.js

@@ -3,6 +3,7 @@ import { BasicParser } from '../../common/BasicParser.js';
 import { APEv2Parser } from '../../apev2/APEv2Parser.js';
 import { FourCcToken } from '../../common/FourCC.js';
 import * as SV8 from './StreamVersion8.js';
+import { MusepackContentError } from '../MusepackConentError.js';
 const debug = initDebug('music-metadata:parser:musepack');
 export class MpcSv8Parser extends BasicParser {
     constructor() {
@@ -12,7 +13,7 @@ export class MpcSv8Parser extends BasicParser {
     async parse() {
         const signature = await this.tokenizer.readToken(FourCcToken);
         if (signature !== 'MPCK')
-            throw new Error('Invalid Magic number');
+            throw new MusepackContentError('Invalid Magic number');
         this.metadata.setFormat('container', 'Musepack, SV8');
         return this.parsePacket();
     }
@@ -47,7 +48,7 @@ export class MpcSv8Parser extends BasicParser {
                     }
                     return APEv2Parser.tryParseApeHeader(this.metadata, this.tokenizer, this.options);
                 default:
-                    throw new Error(`Unexpected header: ${header.key}`);
+                    throw new MusepackContentError(`Unexpected header: ${header.key}`);
             }
         } while (true);
     }

package/lib/node.cjs

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

package/lib/ogg/OggParser.d.ts

@@ -1,6 +1,20 @@
 import { type IGetToken } from 'strtok3';
 import { BasicParser } from '../common/BasicParser.js';
 import type * as Ogg from './Ogg.js';
+declare const OggContentError_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 OggContentError extends OggContentError_base {
+}
 export declare class SegmentTable implements IGetToken<Ogg.ISegmentTable> {
     private static sum;
     len: number;
@@ -21,3 +35,4 @@ export declare class OggParser extends BasicParser {
      */
     parse(): Promise<void>;
 }
+export {};

package/lib/ogg/OggParser.js

@@ -8,6 +8,9 @@ import { VorbisParser } from './vorbis/VorbisParser.js';
 import { OpusParser } from './opus/OpusParser.js';
 import { SpeexParser } from './speex/SpeexParser.js';
 import { TheoraParser } from './theora/TheoraParser.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+export class OggContentError extends makeUnexpectedFileContentError('Ogg') {
+}
 const debug = initDebug('music-metadata:parser:ogg');
 export class SegmentTable {
     static sum(buf, off, len) {
@@ -48,7 +51,7 @@ export class OggParser extends BasicParser {
             do {
                 header = await this.tokenizer.readToken(OggParser.Header);
                 if (header.capturePattern !== 'OggS')
-                    throw new Error('Invalid Ogg capture pattern');
+                    throw new OggContentError('Invalid Ogg capture pattern');
                 this.metadata.setFormat('container', 'Ogg');
                 this.header = header;
                 this.pageNumber = header.pageSequenceNo;
@@ -78,7 +81,7 @@ export class OggParser extends BasicParser {
                             this.pageConsumer = new TheoraParser(this.metadata, this.options, this.tokenizer);
                             break;
                         default:
-                            throw new Error(`gg audio-codec not recognized (id=${id})`);
+                            throw new OggContentError(`gg audio-codec not recognized (id=${id})`);
                     }
                 }
                 await this.pageConsumer.parsePage(header, pageData);

package/lib/ogg/opus/Opus.d.ts

@@ -37,6 +37,20 @@ export interface IIdHeader {
      */
     channelMapping: number;
 }
+declare const OpusContentError_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 OpusContentError extends OpusContentError_base {
+}
 /**
  * Opus ID Header parser
  * Ref: https://wiki.xiph.org/OggOpus#ID_Header
@@ -46,3 +60,4 @@ export declare class IdHeader implements IGetToken<IIdHeader> {
     constructor(len: number);
     get(buf: Uint8Array, off: number): IIdHeader;
 }
+export {};

package/lib/ogg/opus/Opus.js

@@ -1,4 +1,7 @@
 import * as Token from 'token-types';
+import { makeUnexpectedFileContentError } from '../../ParseError.js';
+export class OpusContentError extends makeUnexpectedFileContentError('Opus') {
+}
 /**
  * Opus ID Header parser
  * Ref: https://wiki.xiph.org/OggOpus#ID_Header
@@ -7,7 +10,7 @@ export class IdHeader {
     constructor(len) {
         this.len = len;
         if (len < 19) {
-            throw new Error("ID-header-page 0 should be at least 19 bytes long");
+            throw new OpusContentError('ID-header-page 0 should be at least 19 bytes long');
         }
     }
     get(buf, off) {

package/lib/ogg/opus/OpusParser.js

@@ -1,6 +1,7 @@
 import * as Token from 'token-types';
 import { VorbisParser } from '../vorbis/VorbisParser.js';
 import * as Opus from './Opus.js';
+import { OpusContentError } from './Opus.js';
 /**
  * Opus parser
  * Internet Engineering Task Force (IETF) - RFC 6716
@@ -23,7 +24,7 @@ export class OpusParser extends VorbisParser {
         // Parse Opus ID Header
         this.idHeader = new Opus.IdHeader(pageData.length).get(pageData, 0);
         if (this.idHeader.magicSignature !== "OpusHead")
-            throw new Error("Illegal ogg/Opus magic-signature");
+            throw new OpusContentError("Illegal ogg/Opus magic-signature");
         this.metadata.setFormat('sampleRate', this.idHeader.inputSampleRate);
         this.metadata.setFormat('numberOfChannels', this.idHeader.channelCount);
     }

package/lib/ogg/vorbis/VorbisParser.d.ts

@@ -2,6 +2,20 @@ import { type IVorbisPicture } from './Vorbis.js';
 import type { IPageConsumer, IPageHeader } from '../Ogg.js';
 import type { IOptions } from '../../type.js';
 import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+declare const VorbisContentError_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 VorbisContentError extends VorbisContentError_base {
+}
 /**
  * Vorbis 1 Parser.
  * Used by OggParser
@@ -34,3 +48,4 @@ export declare class VorbisParser implements IPageConsumer {
      */
     protected parseUserCommentList(pageData: Uint8Array, offset: number): Promise<void>;
 }
+export {};

package/lib/ogg/vorbis/VorbisParser.js

@@ -2,7 +2,10 @@ import * as Token from 'token-types';
 import debugInit from 'debug';
 import { VorbisDecoder } from './VorbisDecoder.js';
 import { CommonHeader, IdentificationHeader, VorbisPictureToken } from './Vorbis.js';
+import { makeUnexpectedFileContentError } from '../../ParseError.js';
 const debug = debugInit('music-metadata:parser:ogg:vorbis1');
+export class VorbisContentError extends makeUnexpectedFileContentError('Vorbis') {
+}
 /**
  * Vorbis 1 Parser.
  * Used by OggParser
@@ -25,7 +28,7 @@ export class VorbisParser {
         else {
             if (header.headerType.continued) {
                 if (this.pageSegments.length === 0) {
-                    throw new Error('Cannot continue on previous page');
+                    throw new VorbisContentError('Cannot continue on previous page');
                 }
                 this.pageSegments.push(pageData);
             }
@@ -93,7 +96,7 @@ export class VorbisParser {
         // Parse  Vorbis common header
         const commonHeader = CommonHeader.get(pageData, 0);
         if (commonHeader.vorbis !== 'vorbis')
-            throw new Error('Metadata does not look like Vorbis');
+            throw new VorbisContentError('Metadata does not look like Vorbis');
         if (commonHeader.packetType === 1) {
             const idHeader = IdentificationHeader.get(pageData, CommonHeader.len);
             this.metadata.setFormat('sampleRate', idHeader.sampleRate);
@@ -102,7 +105,7 @@ export class VorbisParser {
             debug('sample-rate=%s[hz], bitrate=%s[b/s], channel-mode=%s', idHeader.sampleRate, idHeader.bitrateNominal, idHeader.channelMode);
         }
         else
-            throw new Error('First Ogg page should be type 1: the identification header');
+            throw new VorbisContentError('First Ogg page should be type 1: the identification header');
     }
     async parseFullPage(pageData) {
         // New page

package/lib/wav/WaveChunk.d.ts

@@ -1,5 +1,19 @@
 import type { IGetToken } from 'strtok3';
 import type { IChunkHeader } from '../iff/index.js';
+declare const WaveContentError_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 WaveContentError extends WaveContentError_base {
+}
 /**
  * Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/dd317599(v=vs.85).aspx
  */
@@ -61,3 +75,4 @@ export declare class FactChunk implements IGetToken<IFactChunk> {
     constructor(header: IChunkHeader);
     get(buf: Uint8Array, off: number): IFactChunk;
 }
+export {};

package/lib/wav/WaveChunk.js

@@ -1,4 +1,7 @@
 import * as Token from 'token-types';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+export class WaveContentError extends makeUnexpectedFileContentError('Wave') {
+}
 /**
  * Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/dd317599(v=vs.85).aspx
  */
@@ -27,7 +30,7 @@ export var WaveFormat;
 export class Format {
     constructor(header) {
         if (header.chunkSize < 16)
-            throw new Error('Invalid chunk size');
+            throw new WaveContentError('Invalid chunk size');
         this.len = header.chunkSize;
     }
     get(buf, off) {
@@ -49,7 +52,7 @@ export class Format {
 export class FactChunk {
     constructor(header) {
         if (header.chunkSize < 4) {
-            throw new Error('Invalid fact chunk size.');
+            throw new WaveContentError('Invalid fact chunk size.');
         }
         this.len = header.chunkSize;
     }