music-metadata 10.0.1 → 10.1.0

package/lib/dsf/DsfParser.js

@@ -17,7 +17,7 @@ export class DsfParser extends AbstractID3Parser {
         this.metadata.setFormat('lossless', true);
         const dsdChunk = await this.tokenizer.readToken(DsdChunk);
         if (dsdChunk.metadataPointer === BigInt(0)) {
-            debug(`No ID3v2 tag present`);
+            debug("No ID3v2 tag present");
         }
         else {
             debug(`expect ID3v2 at offset=${dsdChunk.metadataPointer}`);
@@ -32,7 +32,7 @@ export class DsfParser extends AbstractID3Parser {
             const chunkHeader = await this.tokenizer.readToken(ChunkHeader);
             debug(`Parsing chunk name=${chunkHeader.id} size=${chunkHeader.size}`);
             switch (chunkHeader.id) {
-                case 'fmt ':
+                case 'fmt ': {
                     const formatChunk = await this.tokenizer.readToken(FormatChunk);
                     this.metadata.setFormat('numberOfChannels', formatChunk.channelNum);
                     this.metadata.setFormat('sampleRate', formatChunk.samplingFrequency);
@@ -42,6 +42,7 @@ export class DsfParser extends AbstractID3Parser {
                     const bitrate = formatChunk.bitsPerSample * formatChunk.samplingFrequency * formatChunk.channelNum;
                     this.metadata.setFormat('bitrate', bitrate);
                     return; // We got what we want, stop further processing of chunks
+                }
                 default:
                     this.tokenizer.ignore(Number(chunkHeader.size) - ChunkHeader.len);
                     break;
@@ -50,3 +51,4 @@ export class DsfParser extends AbstractID3Parser {
         }
     }
 }
+//# sourceMappingURL=DsfParser.js.map

package/lib/flac/FlacParser.d.ts

@@ -1,8 +1,8 @@
 import type { ITokenizer } from 'strtok3';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import { INativeMetadataCollector } from '../common/MetadataCollector.js';
-import { IOptions } from '../type.js';
-import { ITokenParser } from '../ParserFactory.js';
+import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import type { IOptions } from '../type.js';
+import type { ITokenParser } from '../ParserFactory.js';
 export declare class FlacParser extends AbstractID3Parser {
     private vorbisParser;
     private padding;

package/lib/flac/FlacParser.js

@@ -45,7 +45,7 @@ export class FlacParser extends AbstractID3Parser {
         let blockHeader;
         do {
             // Read block header
-            blockHeader = await this.tokenizer.readToken(Metadata.BlockHeader);
+            blockHeader = await this.tokenizer.readToken(BlockHeader);
             // Parse block data
             await this.parseDataBlock(blockHeader);
         } while (!blockHeader.lastBlock);
@@ -74,7 +74,7 @@ export class FlacParser extends AbstractID3Parser {
                 await this.parsePicture(blockHeader.length);
                 return;
             default:
-                this.metadata.addWarning('Unknown block type: ' + blockHeader.type);
+                this.metadata.addWarning(`Unknown block type: ${blockHeader.type}`);
         }
         // Ignore data block
         return this.tokenizer.ignore(blockHeader.length).then();
@@ -83,9 +83,9 @@ export class FlacParser extends AbstractID3Parser {
      * Parse STREAMINFO
      */
     async parseBlockStreamInfo(dataLen) {
-        if (dataLen !== Metadata.BlockStreamInfo.len)
+        if (dataLen !== BlockStreamInfo.len)
             throw new Error('Unexpected block-stream-info length');
-        const streamInfo = await this.tokenizer.readToken(Metadata.BlockStreamInfo);
+        const streamInfo = await this.tokenizer.readToken(BlockStreamInfo);
         this.metadata.setFormat('container', 'FLAC');
         this.metadata.setFormat('codec', 'FLAC');
         this.metadata.setFormat('lossless', true);
@@ -115,15 +115,11 @@ export class FlacParser extends AbstractID3Parser {
         if (this.options.skipCovers) {
             return this.tokenizer.ignore(dataLen);
         }
-        else {
-            const picture = await this.tokenizer.readToken(new VorbisPictureToken(dataLen));
-            this.vorbisParser.addTag('METADATA_BLOCK_PICTURE', picture);
-        }
+        const picture = await this.tokenizer.readToken(new VorbisPictureToken(dataLen));
+        this.vorbisParser.addTag('METADATA_BLOCK_PICTURE', picture);
     }
 }
-class Metadata {
-}
-Metadata.BlockHeader = {
+const BlockHeader = {
     len: 4,
     get: (buf, off) => {
         return {
@@ -137,7 +133,7 @@ Metadata.BlockHeader = {
  * METADATA_BLOCK_DATA
  * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
  */
-Metadata.BlockStreamInfo = {
+const BlockStreamInfo = {
     len: 34,
     get: (buf, off) => {
         return {
@@ -171,3 +167,4 @@ Metadata.BlockStreamInfo = {
         };
     }
 };
+//# sourceMappingURL=FlacParser.js.map

package/lib/id3v1/ID3v1Parser.d.ts

@@ -1,5 +1,5 @@
 import { BasicParser } from '../common/BasicParser.js';
-import { IRandomReader } from '../type.js';
+import type { IRandomReader } from '../type.js';
 /**
  * ID3v1 Genre mappings
  * Ref: https://de.wikipedia.org/wiki/Liste_der_ID3v1-Genres

package/lib/id3v1/ID3v1Parser.js

@@ -66,12 +66,13 @@ const Iid3v1Token = {
         } : null;
     }
 };
-class Id3v1StringType extends StringType {
+class Id3v1StringType {
     constructor(len) {
-        super(len, 'latin1');
+        this.len = len;
+        this.stringType = new StringType(len, 'latin1');
     }
     get(buf, off) {
-        let value = super.get(buf, off);
+        let value = this.stringType.get(buf, off);
         value = util.trimRightNull(value);
         value = value.trim();
         return value.length > 0 ? value : undefined;
@@ -103,7 +104,8 @@ export class ID3v1Parser extends BasicParser {
         const header = await this.tokenizer.readToken(Iid3v1Token, offset);
         if (header) {
             debug('ID3v1 header found at: pos=%s', this.tokenizer.fileInfo.size - Iid3v1Token.len);
-            for (const id of ['title', 'artist', 'album', 'comment', 'track', 'year']) {
+            const props = ['title', 'artist', 'album', 'comment', 'track', 'year'];
+            for (const id of props) {
                 if (header[id] && header[id] !== '')
                     await this.addTag(id, header[id]);
             }
@@ -127,3 +129,4 @@ export async function hasID3v1Header(reader) {
     }
     return false;
 }
+//# sourceMappingURL=ID3v1Parser.js.map

package/lib/id3v2/AbstractID3Parser.d.ts

@@ -1,4 +1,4 @@
-import { ITokenizer } from 'strtok3';
+import { type ITokenizer } from 'strtok3';
 import { BasicParser } from '../common/BasicParser.js';
 /**
  * Abstract parser which tries take ID3v2 and ID3v1 headers.

package/lib/id3v2/AbstractID3Parser.js

@@ -22,7 +22,7 @@ export class AbstractID3Parser extends BasicParser {
         }
         catch (err) {
             if (err instanceof EndOfStreamError) {
-                debug(`End-of-stream`);
+                debug("End-of-stream");
             }
             else {
                 throw err;
@@ -54,3 +54,4 @@ export class AbstractID3Parser extends BasicParser {
         }
     }
 }
+//# sourceMappingURL=AbstractID3Parser.js.map

package/lib/id3v2/FrameParser.d.ts

@@ -1,5 +1,29 @@
-import { ID3v2MajorVersion, ITextEncoding } from './ID3v2Token.js';
-import { IWarningCollector } from '../common/MetadataCollector.js';
+import { type ID3v2MajorVersion, type ITextEncoding } from './ID3v2Token.js';
+import type { IWarningCollector } from '../common/MetadataCollector.js';
+interface ICustomTag {
+    owner_identifier: string;
+}
+export interface ICustomDataTag extends ICustomTag {
+    data: Uint8Array;
+}
+export interface IIdentifierTag extends ICustomTag {
+    identifier: Uint8Array;
+}
+export interface ITextTag {
+    description: string;
+    text: string[];
+}
+export interface IPopularimeter {
+    email: string;
+    rating: number;
+    counter: number;
+}
+export interface IGeneralEncapsulatedObject {
+    type: string;
+    filename: string;
+    description: string;
+    data: Uint8Array;
+}
 export declare function parseGenre(origVal: string): string[];
 export declare class FrameParser {
     private major;
@@ -10,7 +34,7 @@ export declare class FrameParser {
      * @param warningCollector - Used to collect decode issue
      */
     constructor(major: ID3v2MajorVersion, warningCollector: IWarningCollector);
-    readData(uint8Array: Uint8Array, type: string, includeCovers: boolean): any;
+    readData(uint8Array: Uint8Array, type: string, includeCovers: boolean): unknown;
     protected static readNullTerminatedString(uint8Array: Uint8Array, encoding: ITextEncoding): {
         text: string;
         len: number;
@@ -33,3 +57,4 @@ export declare class FrameParser {
     private static readIdentifierAndData;
     private static getNullTerminatorLength;
 }
+export {};

package/lib/id3v2/FrameParser.js

@@ -1,7 +1,7 @@
 import initDebug from 'debug';
 import * as Token from 'token-types';
 import * as util from '../common/Util.js';
-import { AttachedPictureType, TextEncodingToken, SyncTextHeader, TextHeader } from './ID3v2Token.js';
+import { AttachedPictureType, SyncTextHeader, TextEncodingToken, TextHeader } from './ID3v2Token.js';
 import { Genres } from '../id3v1/ID3v1Parser.js';
 const debug = initDebug('music-metadata:id3v2:frame-parser');
 const defaultEnc = 'latin1'; // latin1 == iso-8859-1;
@@ -39,9 +39,11 @@ export function parseGenre(origVal) {
     }
     if (word) {
         if (genres.length === 0 && word.match(/^\d*$/)) {
-            word = Genres[word];
+            word = parseGenreCode(word);
+        }
+        if (word) {
+            genres.push(word);
         }
-        genres.push(word);
     }
     return genres;
 }
@@ -51,7 +53,7 @@ function parseGenreCode(code) {
     if (code === 'CR')
         return 'Cover';
     if (code.match(/^\d*$/)) {
-        return Genres[code];
+        return Genres[Number.parseInt(code)];
     }
 }
 export class FrameParser {
@@ -83,20 +85,23 @@ export class FrameParser {
             case 'MVIN':
             case 'MVNM':
             case 'PCS':
-            case 'PCST':
+            case 'PCST': {
                 let text;
                 try {
                     text = util.decodeString(uint8Array.slice(1), encoding).replace(/\x00+$/, '');
                 }
                 catch (error) {
-                    this.warningCollector.addWarning(`id3v2.${this.major} type=${type} header has invalid string value: ${error.message}`);
+                    if (error instanceof Error) {
+                        this.warningCollector.addWarning(`id3v2.${this.major} type=${type} header has invalid string value: ${error.message}`);
+                        break;
+                    }
+                    throw error;
                 }
                 switch (type) {
                     case 'TMCL': // Musician credits list
                     case 'TIPL': // Involved people list
                     case 'IPLS': // Involved people list
-                        output = this.splitValue(type, text);
-                        output = FrameParser.functionList(output);
+                        output = FrameParser.functionList(this.splitValue(type, text));
                         break;
                     case 'TRK':
                     case 'TRCK':
@@ -126,13 +131,16 @@ export class FrameParser {
                         output = this.major >= 4 ? this.splitValue(type, text) : [text];
                 }
                 break;
-            case 'TXXX':
-                output = FrameParser.readIdentifierAndData(uint8Array, offset + 1, length, encoding);
-                output = {
-                    description: output.id,
-                    text: this.splitValue(type, util.decodeString(output.data, encoding).replace(/\x00+$/, ''))
+            }
+            case 'TXXX': {
+                const idAndData = FrameParser.readIdentifierAndData(uint8Array, offset + 1, length, encoding);
+                const textTag = {
+                    description: idAndData.id,
+                    text: this.splitValue(type, util.decodeString(idAndData.data, encoding).replace(/\x00+$/, ''))
                 };
+                output = textTag;
                 break;
+            }
             case 'PIC':
             case 'APIC':
                 if (includeCovers) {
@@ -150,7 +158,7 @@ export class FrameParser {
                             offset = fzero + 1;
                             break;
                         default:
-                            throw new Error('Warning: unexpected major versionIndex: ' + this.major);
+                            throw new Error(`Warning: unexpected major versionIndex: ${this.major}`);
                     }
                     pic.format = FrameParser.fixPictureMimeType(pic.format);
                     pic.type = AttachedPictureType[uint8Array[offset]];
@@ -166,7 +174,7 @@ export class FrameParser {
             case 'PCNT':
                 output = Token.UINT32_BE.get(uint8Array, 0);
                 break;
-            case 'SYLT':
+            case 'SYLT': {
                 const syltHeader = SyncTextHeader.get(uint8Array, 0);
                 offset += SyncTextHeader.len;
                 const result = {
@@ -195,10 +203,11 @@ export class FrameParser {
                 }
                 output = result;
                 break;
+            }
             case 'ULT':
             case 'USLT':
             case 'COM':
-            case 'COMM':
+            case 'COMM': {
                 const textHeader = TextHeader.get(uint8Array, offset);
                 offset += TextHeader.len;
                 const descriptorStr = FrameParser.readNullTerminatedString(uint8Array.subarray(offset), textHeader.encoding);
@@ -211,15 +220,18 @@ export class FrameParser {
                 };
                 output = comment;
                 break;
-            case 'UFID':
-                output = FrameParser.readIdentifierAndData(uint8Array, offset, length, defaultEnc);
-                output = { owner_identifier: output.id, identifier: output.data };
+            }
+            case 'UFID': {
+                const ufid = FrameParser.readIdentifierAndData(uint8Array, offset, length, defaultEnc);
+                output = { owner_identifier: ufid.id, identifier: ufid.data };
                 break;
-            case 'PRIV': // private frame
-                output = FrameParser.readIdentifierAndData(uint8Array, offset, length, defaultEnc);
-                output = { owner_identifier: output.id, data: output.data };
+            }
+            case 'PRIV': { // private frame
+                const priv = FrameParser.readIdentifierAndData(uint8Array, offset, length, defaultEnc);
+                output = { owner_identifier: priv.id, data: priv.data };
                 break;
-            case 'POPM': // Popularimeter
+            }
+            case 'POPM': { // Popularimeter
                 fzero = util.findZero(uint8Array, offset, length, defaultEnc);
                 const email = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
                 offset = fzero + 1;
@@ -230,6 +242,7 @@ export class FrameParser {
                     counter: dataLen >= 5 ? Token.UINT32_BE.get(uint8Array, offset + 1) : undefined
                 };
                 break;
+            }
             case 'GEOB': { // General encapsulated object
                 fzero = util.findZero(uint8Array, offset + 1, length, encoding);
                 const mimeType = util.decodeString(uint8Array.slice(offset + 1, fzero), defaultEnc);
@@ -239,12 +252,13 @@ export class FrameParser {
                 offset = fzero + 1;
                 fzero = util.findZero(uint8Array, offset, length - offset, encoding);
                 const description = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
-                output = {
+                const geob = {
                     type: mimeType,
                     filename,
                     description,
                     data: uint8Array.slice(offset + 1, length)
                 };
+                output = geob;
                 break;
             }
             // W-Frames:
@@ -257,6 +271,7 @@ export class FrameParser {
             case 'WPAY':
             case 'WPUB':
                 // Decode URL
+                fzero = util.findZero(uint8Array, offset + 1, length, encoding);
                 output = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
                 break;
             case 'WXXX': {
@@ -277,15 +292,21 @@ export class FrameParser {
                 break;
             }
             default:
-                debug('Warning: unsupported id3v2-tag-type: ' + type);
+                debug(`Warning: unsupported id3v2-tag-type: ${type}`);
                 break;
         }
         return output;
     }
     static readNullTerminatedString(uint8Array, encoding) {
         let offset = encoding.bom ? 2 : 0;
-        const txt = uint8Array.slice(offset, offset = util.findZero(uint8Array, offset, uint8Array.length, encoding.encoding));
-        offset += encoding.encoding === 'utf-16le' ? 2 : 1;
+        const zeroIndex = util.findZero(uint8Array, offset, uint8Array.length, encoding.encoding);
+        const txt = uint8Array.slice(offset, zeroIndex);
+        if (encoding.encoding === 'utf-16le') {
+            offset = zeroIndex + 2;
+        }
+        else {
+            offset = zeroIndex + 1;
+        }
         return {
             text: util.decodeString(txt, encoding.encoding),
             len: offset
@@ -309,7 +330,7 @@ export class FrameParser {
         const res = {};
         for (let i = 0; i + 1 < entries.length; i += 2) {
             const names = entries[i + 1].split(',');
-            res[entries[i]] = res.hasOwnProperty(entries[i]) ? res[entries[i]].concat(names) : names;
+            res[entries[i]] = res[entries[i]] ? res[entries[i]].concat(names) : names;
         }
         return res;
     }
@@ -349,3 +370,4 @@ export class FrameParser {
         return enc === 'utf-16le' ? 2 : 1;
     }
 }
+//# sourceMappingURL=FrameParser.js.map

package/lib/id3v2/ID3v22TagMapper.d.ts

@@ -1,4 +1,4 @@
-import { INativeTagMap } from '../common/GenericTagTypes.js';
+import type { INativeTagMap } from '../common/GenericTagTypes.js';
 import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
 /**
  * ID3v2.2 tag mappings

package/lib/id3v2/ID3v24TagMapper.d.ts

@@ -1,8 +1,9 @@
 import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
 import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
 import type { IRating, ITag } from '../type.js';
+import type { IPopularimeter } from './FrameParser.js';
 export declare class ID3v24TagMapper extends CaseInsensitiveTagMap {
-    static toRating(popm: any): IRating;
+    static toRating(popm: IPopularimeter): IRating;
     constructor();
     /**
      * Handle post mapping exceptions / correction

package/lib/id3v2/ID3v24TagMapper.js

@@ -156,25 +156,32 @@ export class ID3v24TagMapper extends CaseInsensitiveTagMap {
      */
     postMap(tag, warnings) {
         switch (tag.id) {
-            case 'UFID': // decode MusicBrainz Recording Id
-                if (tag.value.owner_identifier === 'http://musicbrainz.org') {
-                    tag.id += ':' + tag.value.owner_identifier;
-                    tag.value = decodeString(tag.value.identifier, 'latin1'); // latin1 == iso-8859-1
+            case 'UFID':
+                {
+                    // decode MusicBrainz Recording Id
+                    const idTag = tag.value;
+                    if (idTag.owner_identifier === 'http://musicbrainz.org') {
+                        tag.id += `:${idTag.owner_identifier}`;
+                        tag.value = decodeString(idTag.identifier, 'latin1'); // latin1 == iso-8859-1
+                    }
                 }
                 break;
             case 'PRIV':
-                switch (tag.value.owner_identifier) {
-                    // decode Windows Media Player
-                    case 'AverageLevel':
-                    case 'PeakValue':
-                        tag.id += ':' + tag.value.owner_identifier;
-                        tag.value = tag.value.data.length === 4 ? UINT32_LE.get(tag.value.data, 0) : null;
-                        if (tag.value === null) {
-                            warnings.addWarning(`Failed to parse PRIV:PeakValue`);
-                        }
-                        break;
-                    default:
-                        warnings.addWarning(`Unknown PRIV owner-identifier: ${tag.value.owner_identifier}`);
+                {
+                    const customTag = tag.value;
+                    switch (customTag.owner_identifier) {
+                        // decode Windows Media Player
+                        case 'AverageLevel':
+                        case 'PeakValue':
+                            tag.id += `:${customTag.owner_identifier}`;
+                            tag.value = customTag.data.length === 4 ? UINT32_LE.get(customTag.data, 0) : null;
+                            if (tag.value === null) {
+                                warnings.addWarning('Failed to parse PRIV:PeakValue');
+                            }
+                            break;
+                        default:
+                            warnings.addWarning(`Unknown PRIV owner-identifier: ${customTag.data}`);
+                    }
                 }
                 break;
             case 'POPM':

package/lib/id3v2/ID3v2Parser.d.ts

@@ -1,6 +1,6 @@
 import type { ITokenizer } from 'strtok3';
-import { IOptions } from '../type.js';
-import { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import type { IOptions } from '../type.js';
+import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
 export declare class ID3v2Parser {
     static removeUnsyncBytes(buffer: Uint8Array): Uint8Array;
     private static getFrameHeaderLength;

package/lib/id3v2/ID3v2Parser.js

@@ -4,6 +4,13 @@ import { FrameParser } from './FrameParser.js';
 import { ExtendedHeader, ID3v2Header, UINT32SYNCSAFE } from './ID3v2Token.js';
 const asciiDecoder = new TextDecoder('ascii');
 export class ID3v2Parser {
+    constructor() {
+        this.tokenizer = undefined;
+        this.id3Header = undefined;
+        this.metadata = undefined;
+        this.headerType = undefined;
+        this.options = undefined;
+    }
     static removeUnsyncBytes(buffer) {
         let readI = 0;
         let writeI = 0;
@@ -47,21 +54,22 @@ export class ID3v2Parser {
         };
     }
     static readFrameData(uint8Array, frameHeader, majorVer, includeCovers, warningCollector) {
+        var _a, _b;
         const frameParser = new FrameParser(majorVer, warningCollector);
         switch (majorVer) {
             case 2:
                 return frameParser.readData(uint8Array, frameHeader.id, includeCovers);
             case 3:
             case 4:
-                if (frameHeader.flags.format.unsynchronisation) {
+                if ((_a = frameHeader.flags) === null || _a === void 0 ? void 0 : _a.format.unsynchronisation) {
                     uint8Array = ID3v2Parser.removeUnsyncBytes(uint8Array);
                 }
-                if (frameHeader.flags.format.data_length_indicator) {
+                if ((_b = frameHeader.flags) === null || _b === void 0 ? void 0 : _b.format.data_length_indicator) {
                     uint8Array = uint8Array.slice(4, uint8Array.length);
                 }
                 return frameParser.readData(uint8Array, frameHeader.id, includeCovers);
             default:
-                throw new Error('Unexpected majorVer: ' + majorVer);
+                throw new Error(`Unexpected majorVer: ${majorVer}`);
         }
     }
     /**
@@ -71,7 +79,7 @@ export class ID3v2Parser {
      * @returns string e.g. COM:iTunPGAP
      */
     static makeDescriptionTagName(tag, description) {
-        return tag + (description ? ':' + description : '');
+        return tag + (description ? `:${description}` : '');
     }
     async parse(metadata, tokenizer, options) {
         this.tokenizer = tokenizer;
@@ -82,7 +90,7 @@ export class ID3v2Parser {
             throw new Error('expected ID3-header file-identifier \'ID3\' was not found');
         }
         this.id3Header = id3Header;
-        this.headerType = ('ID3v2.' + id3Header.version.major);
+        this.headerType = (`ID3v2.${id3Header.version.major}`);
         return id3Header.flags.isExtendedHeader ? this.parseExtendedHeader() : this.parseId3Data(id3Header.size);
     }
     async parseExtendedHeader() {
@@ -125,9 +133,11 @@ export class ID3v2Parser {
                 this.metadata.addWarning('Illegal ID3v2 tag length');
                 break;
             }
-            const frameHeaderBytes = data.slice(offset, offset += frameHeaderLength);
+            const frameHeaderBytes = data.slice(offset, offset + frameHeaderLength);
+            offset += frameHeaderLength;
             const frameHeader = this.readFrameHeader(frameHeaderBytes, this.id3Header.version.major);
-            const frameDataBytes = data.slice(offset, offset += frameHeader.length);
+            const frameDataBytes = data.slice(offset, offset + frameHeader.length);
+            offset += frameHeader.length;
             const values = ID3v2Parser.readFrameData(frameDataBytes, frameHeader, this.id3Header.version.major, !this.options.skipCovers, this.metadata);
             if (values) {
                 tags.push({ id: frameHeader.id, value: values });
@@ -159,8 +169,9 @@ export class ID3v2Parser {
                 }
                 break;
             default:
-                throw new Error('Unexpected majorVer: ' + majorVer);
+                throw new Error(`Unexpected majorVer: ${majorVer}`);
         }
         return header;
     }
 }
+//# sourceMappingURL=ID3v2Parser.js.map

package/lib/iff/index.js

@@ -14,3 +14,4 @@ export const Header = {
         };
     }
 };
+//# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -1,11 +1,10 @@
 /**
  * Node.js specific entry point.
  */
-import * as Stream from 'stream';
-import * as strtok3 from 'strtok3';
-import { IAudioMetadata, IOptions } from './type.js';
-export { IAudioMetadata, IOptions, ITag, INativeTagDict, ICommonTagsResult, IFormat, IPicture, IRatio, IChapter, ILyricsTag, LyricsContentType, TimestampFormat } from './type.js';
-export { parseFromTokenizer, parseBuffer, parseBlob, parseWebStream, selectCover, orderTags, ratingToStars, IFileInfo } from './core.js';
+import type { Readable } from 'node:stream';
+import { type IFileInfo } from 'strtok3';
+import type { IAudioMetadata, IOptions } from './type.js';
+export * from './core.js';
 /**
  * Parse audio from Node Stream.Readable
  * @param stream - Stream to read the audio track from
@@ -13,7 +12,7 @@ export { parseFromTokenizer, parseBuffer, parseBlob, parseWebStream, selectCover
  * @param options - Parsing options
  * @returns Metadata
  */
-export declare function parseStream(stream: Stream.Readable, fileInfo?: strtok3.IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
+export declare function parseStream(stream: Readable, fileInfo?: IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
 /**
  * Parse audio from Node file
  * @param filePath - Media file to read meta-data from