music-metadata 10.0.0 → 10.1.0

package/lib/dsdiff/DsdiffParser.js

@@ -24,7 +24,7 @@ export class DsdiffParser extends BasicParser {
                 this.metadata.setFormat('lossless', true);
                 return this.readFmt8Chunks(header.chunkSize - BigInt(FourCcToken.len));
             default:
-                throw Error(`Unsupported DSDIFF type: ${type}`);
+                throw new Error(`Unsupported DSDIFF type: ${type}`);
         }
     }
     async readFmt8Chunks(remainingSize) {
@@ -40,28 +40,35 @@ export class DsdiffParser extends BasicParser {
         debug(`Reading data of chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
         const p0 = this.tokenizer.position;
         switch (header.chunkID.trim()) {
-            case 'FVER': // 3.1 FORMAT VERSION CHUNK
+            case 'FVER': { // 3.1 FORMAT VERSION CHUNK
                 const version = await this.tokenizer.readToken(Token.UINT32_LE);
                 debug(`DSDIFF version=${version}`);
                 break;
-            case 'PROP': // 3.2 PROPERTY CHUNK
+            }
+            case 'PROP': { // 3.2 PROPERTY CHUNK
                 const propType = await this.tokenizer.readToken(FourCcToken);
                 if (propType !== 'SND ')
                     throw new Error('Unexpected PROP-chunk ID');
                 await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCcToken.len));
                 break;
-            case 'ID3': // Unofficial ID3 tag support
+            }
+            case 'ID3': { // Unofficial ID3 tag support
                 const id3_data = await this.tokenizer.readToken(new Token.Uint8ArrayType(Number(header.chunkSize)));
                 const rst = strtok3.fromBuffer(id3_data);
                 await new ID3v2Parser().parse(this.metadata, rst, this.options);
                 break;
+            }
+            case 'DSD':
+                if (this.metadata.format.numberOfChannels) {
+                    this.metadata.setFormat('numberOfSamples', Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels)));
+                }
+                if (this.metadata.format.numberOfSamples && this.metadata.format.sampleRate) {
+                    this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
+                }
+                break;
             default:
                 debug(`Ignore chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
                 break;
-            case 'DSD':
-                this.metadata.setFormat('numberOfSamples', Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels)));
-                this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
-                break;
         }
         const remaining = header.chunkSize - BigInt(this.tokenizer.position - p0);
         if (remaining > 0) {
@@ -76,16 +83,18 @@ export class DsdiffParser extends BasicParser {
             debug(`Sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
             const p0 = this.tokenizer.position;
             switch (sndPropHeader.chunkID.trim()) {
-                case 'FS': // 3.2.1 Sample Rate Chunk
+                case 'FS': { // 3.2.1 Sample Rate Chunk
                     const sampleRate = await this.tokenizer.readToken(Token.UINT32_BE);
                     this.metadata.setFormat('sampleRate', sampleRate);
                     break;
-                case 'CHNL': // 3.2.2 Channels Chunk
+                }
+                case 'CHNL': { // 3.2.2 Channels Chunk
                     const numChannels = await this.tokenizer.readToken(Token.UINT16_BE);
                     this.metadata.setFormat('numberOfChannels', numChannels);
                     await this.handleChannelChunks(sndPropHeader.chunkSize - BigInt(Token.UINT16_BE.len));
                     break;
-                case 'CMPR': // 3.2.3 Compression Type Chunk
+                }
+                case 'CMPR': { // 3.2.3 Compression Type Chunk
                     const compressionIdCode = (await this.tokenizer.readToken(FourCcToken)).trim();
                     const count = await this.tokenizer.readToken(Token.UINT8);
                     const compressionName = await this.tokenizer.readToken(new Token.StringType(count, 'ascii'));
@@ -95,18 +104,20 @@ export class DsdiffParser extends BasicParser {
                     }
                     this.metadata.setFormat('codec', `${compressionIdCode} (${compressionName})`);
                     break;
-                case 'ABSS': // 3.2.4 Absolute Start Time Chunk
+                }
+                case 'ABSS': { // 3.2.4 Absolute Start Time Chunk
                     const hours = await this.tokenizer.readToken(Token.UINT16_BE);
                     const minutes = await this.tokenizer.readToken(Token.UINT8);
                     const seconds = await this.tokenizer.readToken(Token.UINT8);
                     const samples = await this.tokenizer.readToken(Token.UINT32_BE);
                     debug(`ABSS ${hours}:${minutes}:${seconds}.${samples}`);
                     break;
-                case 'LSCO': // 3.2.5 Loudspeaker Configuration Chunk
+                }
+                case 'LSCO': { // 3.2.5 Loudspeaker Configuration Chunk
                     const lsConfig = await this.tokenizer.readToken(Token.UINT16_BE);
                     debug(`LSCO lsConfig=${lsConfig}`);
                     break;
-                case 'COMT':
+                }
                 default:
                     debug(`Unknown sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
                     await this.tokenizer.ignore(Number(sndPropHeader.chunkSize));
@@ -137,3 +148,4 @@ export class DsdiffParser extends BasicParser {
         return channels;
     }
 }
+//# sourceMappingURL=DsdiffParser.js.map

package/lib/dsdiff/DsdiffToken.d.ts

@@ -1,6 +1,6 @@
 import type { IGetToken } from 'strtok3';
-import { IChunkHeader64 } from '../iff/index.js';
-export { IChunkHeader64 } from '../iff/index.js';
+import type { IChunkHeader64 } from '../iff/index.js';
+export { type IChunkHeader64 } from '../iff/index.js';
 /**
  * DSDIFF chunk header
  * The data-size encoding is deviating from EA-IFF 85

package/lib/dsdiff/DsdiffToken.js

@@ -16,3 +16,4 @@ export const ChunkHeader64 = {
         };
     }
 };
+//# sourceMappingURL=DsdiffToken.js.map

package/lib/dsf/DsfChunk.js

@@ -49,3 +49,4 @@ export const FormatChunk = {
         };
     }
 };
+//# sourceMappingURL=DsfChunk.js.map

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;