music-metadata 10.0.1 → 10.2.0

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;
@@ -53,15 +60,15 @@ export class ID3v2Parser {
                 return frameParser.readData(uint8Array, frameHeader.id, includeCovers);
             case 3:
             case 4:
-                if (frameHeader.flags.format.unsynchronisation) {
+                if (frameHeader.flags?.format.unsynchronisation) {
                     uint8Array = ID3v2Parser.removeUnsyncBytes(uint8Array);
                 }
-                if (frameHeader.flags.format.data_length_indicator) {
+                if (frameHeader.flags?.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 +78,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 +89,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 +132,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 +168,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

package/lib/index.js

@@ -1,13 +1,12 @@
 /**
  * Node.js specific entry point.
  */
-import * as strtok3 from 'strtok3';
+import { fromFile, fromStream } from 'strtok3';
 import initDebug from 'debug';
 import { parseFromTokenizer, scanAppendingHeaders } from './core.js';
-import { ParserFactory } from './ParserFactory.js';
+import { getParserIdForExtension, parse } from './ParserFactory.js';
 import { RandomFileReader } from './common/RandomFileReader.js';
-export { LyricsContentType, TimestampFormat } from './type.js';
-export { parseFromTokenizer, parseBuffer, parseBlob, parseWebStream, selectCover, orderTags, ratingToStars } from './core.js';
+export * from './core.js';
 const debug = initDebug('music-metadata:parser');
 /**
  * Parse audio from Node Stream.Readable
@@ -17,7 +16,7 @@ const debug = initDebug('music-metadata:parser');
  * @returns Metadata
  */
 export async function parseStream(stream, fileInfo, options = {}) {
-    const tokenizer = await strtok3.fromStream(stream, { fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo });
+    const tokenizer = await fromStream(stream, { fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo });
     return parseFromTokenizer(tokenizer, options);
 }
 /**
@@ -28,7 +27,7 @@ export async function parseStream(stream, fileInfo, options = {}) {
  */
 export async function parseFile(filePath, options = {}) {
     debug(`parseFile: ${filePath}`);
-    const fileTokenizer = await strtok3.fromFile(filePath);
+    const fileTokenizer = await fromFile(filePath);
     const fileReader = await RandomFileReader.init(filePath, fileTokenizer.fileInfo.size);
     try {
         await scanAppendingHeaders(fileReader, options);
@@ -37,10 +36,10 @@ export async function parseFile(filePath, options = {}) {
         await fileReader.close();
     }
     try {
-        const parserName = ParserFactory.getParserIdForExtension(filePath);
+        const parserName = getParserIdForExtension(filePath);
         if (!parserName)
             debug(' Parser could not be determined by file extension');
-        return await ParserFactory.parse(fileTokenizer, parserName, options);
+        return await parse(fileTokenizer, parserName, options);
     }
     finally {
         await fileTokenizer.close();

package/lib/lyrics3/Lyrics3.d.ts

@@ -1,3 +1,3 @@
-import { IRandomReader } from '../type.js';
+import type { IRandomReader } from '../type.js';
 export declare const endTag2 = "LYRICS200";
 export declare function getLyricsHeaderLength(reader: IRandomReader): Promise<number>;

package/lib/lyrics3/Lyrics3.js

@@ -6,7 +6,7 @@ export async function getLyricsHeaderLength(reader) {
         const txt = new TextDecoder('latin1').decode(buf);
         const tag = txt.slice(6);
         if (tag === endTag2) {
-            return parseInt(txt.slice(0, 6), 10) + 15;
+            return Number.parseInt(txt.slice(0, 6), 10) + 15;
         }
     }
     return 0;

package/lib/matroska/MatroskaDtd.d.ts

@@ -1,8 +1,8 @@
-import { IContainerType } from './types.js';
+import { type IElementType } from '../ebml/types.js';
 /**
  * Elements of document type description
  * Derived from https://github.com/tungol/EBML/blob/master/doctypes/matroska.dtd
  * Extended with:
  * - https://www.matroska.org/technical/specs/index.html
  */
-export declare const elements: IContainerType;
+export declare const matroskaDtd: IElementType;