valley-baileys 1.0.0

package/node_modules/music-metadata/lib/common/MetadataCollector.js

@@ -0,0 +1,307 @@
+import { TrackTypeValueToKeyMap, } from '../type.js';
+import initDebug from 'debug';
+import { isSingleton, isUnique } from './GenericTagTypes.js';
+import { CombinedTagMapper } from './CombinedTagMapper.js';
+import { CommonTagMapper } from './GenericTagMapper.js';
+import { toRatio } from './Util.js';
+import { fileTypeFromBuffer } from 'file-type';
+import { parseLyrics } from '../lrc/LyricsParser.js';
+const debug = initDebug('music-metadata:collector');
+const TagPriority = ['matroska', 'APEv2', 'vorbis', 'ID3v2.4', 'ID3v2.3', 'ID3v2.2', 'exif', 'asf', 'iTunes', 'AIFF', 'ID3v1'];
+/**
+ * Provided to the parser to uodate the metadata result.
+ * Responsible for triggering async updates
+ */
+export class MetadataCollector {
+    constructor(opts) {
+        this.format = {
+            tagTypes: [],
+            trackInfo: []
+        };
+        this.native = {};
+        this.common = {
+            track: { no: null, of: null },
+            disk: { no: null, of: null },
+            movementIndex: { no: null, of: null }
+        };
+        this.quality = {
+            warnings: []
+        };
+        /**
+         * Keeps track of origin priority for each mapped id
+         */
+        this.commonOrigin = {};
+        /**
+         * Maps a tag type to a priority
+         */
+        this.originPriority = {};
+        this.tagMapper = new CombinedTagMapper();
+        this.opts = opts;
+        let priority = 1;
+        for (const tagType of TagPriority) {
+            this.originPriority[tagType] = priority++;
+        }
+        this.originPriority.artificial = 500; // Filled using alternative tags
+        this.originPriority.id3v1 = 600; // Consider as the worst because of the field length limit
+    }
+    /**
+     * @returns {boolean} true if one or more tags have been found
+     */
+    hasAny() {
+        return Object.keys(this.native).length > 0;
+    }
+    addStreamInfo(streamInfo) {
+        debug(`streamInfo: type=${streamInfo.type ? TrackTypeValueToKeyMap[streamInfo.type] : '?'}, codec=${streamInfo.codecName}`);
+        this.format.trackInfo.push(streamInfo);
+    }
+    setFormat(key, value) {
+        debug(`format: ${key} = ${value}`);
+        this.format[key] = value; // as any to override readonly
+        if (this.opts?.observer) {
+            this.opts.observer({ metadata: this, tag: { type: 'format', id: key, value } });
+        }
+    }
+    setAudioOnly() {
+        this.setFormat('hasAudio', true);
+        this.setFormat('hasVideo', false);
+    }
+    async addTag(tagType, tagId, value) {
+        debug(`tag ${tagType}.${tagId} = ${value}`);
+        if (!this.native[tagType]) {
+            this.format.tagTypes.push(tagType);
+            this.native[tagType] = [];
+        }
+        this.native[tagType].push({ id: tagId, value });
+        await this.toCommon(tagType, tagId, value);
+    }
+    addWarning(warning) {
+        this.quality.warnings.push({ message: warning });
+    }
+    async postMap(tagType, tag) {
+        // Common tag (alias) found
+        // check if we need to do something special with common tag
+        // if the event has been aliased then we need to clean it before
+        // it is emitted to the user. e.g. genre (20) -> Electronic
+        switch (tag.id) {
+            case 'artist':
+                return this.handleSingularArtistTag(tagType, tag, 'artist', 'artists');
+            case 'albumartist':
+                return this.handleSingularArtistTag(tagType, tag, 'albumartist', 'albumartists');
+            case 'artists':
+                return this.handlePluralArtistTag(tagType, tag, 'artist', 'artists');
+            case 'albumartists':
+                return this.handlePluralArtistTag(tagType, tag, 'albumartist', 'albumartists');
+            case 'picture':
+                return this.postFixPicture(tag.value).then(picture => {
+                    if (picture !== null) {
+                        tag.value = picture;
+                        this.setGenericTag(tagType, tag);
+                    }
+                });
+            case 'totaltracks':
+                this.common.track.of = CommonTagMapper.toIntOrNull(tag.value);
+                return;
+            case 'totaldiscs':
+                this.common.disk.of = CommonTagMapper.toIntOrNull(tag.value);
+                return;
+            case 'movementTotal':
+                this.common.movementIndex.of = CommonTagMapper.toIntOrNull(tag.value);
+                return;
+            case 'track':
+            case 'disk':
+            case 'movementIndex': {
+                const of = this.common[tag.id].of; // store of value, maybe maybe overwritten
+                this.common[tag.id] = CommonTagMapper.normalizeTrack(tag.value);
+                this.common[tag.id].of = of != null ? of : this.common[tag.id].of;
+                return;
+            }
+            case 'bpm':
+            case 'year':
+            case 'originalyear':
+                tag.value = Number.parseInt(tag.value, 10);
+                break;
+            case 'date': {
+                // ToDo: be more strict on 'YYYY...'
+                const year = Number.parseInt(tag.value.substr(0, 4), 10);
+                if (!Number.isNaN(year)) {
+                    this.common.year = year;
+                }
+                break;
+            }
+            case 'discogs_label_id':
+            case 'discogs_release_id':
+            case 'discogs_master_release_id':
+            case 'discogs_artist_id':
+            case 'discogs_votes':
+                tag.value = typeof tag.value === 'string' ? Number.parseInt(tag.value, 10) : tag.value;
+                break;
+            case 'replaygain_track_gain':
+            case 'replaygain_track_peak':
+            case 'replaygain_album_gain':
+            case 'replaygain_album_peak':
+                tag.value = toRatio(tag.value);
+                break;
+            case 'replaygain_track_minmax':
+                tag.value = tag.value.split(',').map(v => Number.parseInt(v, 10));
+                break;
+            case 'replaygain_undo': {
+                const minMix = tag.value.split(',').map(v => Number.parseInt(v, 10));
+                tag.value = {
+                    leftChannel: minMix[0],
+                    rightChannel: minMix[1]
+                };
+                break;
+            }
+            case 'gapless': // iTunes gap-less flag
+            case 'compilation':
+            case 'podcast':
+            case 'showMovement':
+                tag.value = tag.value === '1' || tag.value === 1; // boolean
+                break;
+            case 'isrc': { // Only keep unique values
+                const commonTag = this.common[tag.id];
+                if (commonTag && commonTag.indexOf(tag.value) !== -1)
+                    return;
+                break;
+            }
+            case 'comment':
+                if (typeof tag.value === 'string') {
+                    tag.value = { text: tag.value };
+                }
+                if (tag.value.descriptor === 'iTunPGAP') {
+                    this.setGenericTag(tagType, { id: 'gapless', value: tag.value.text === '1' });
+                }
+                break;
+            case 'lyrics':
+                if (typeof tag.value === 'string') {
+                    tag.value = parseLyrics(tag.value);
+                }
+                break;
+            default:
+            // nothing to do
+        }
+        if (tag.value !== null) {
+            this.setGenericTag(tagType, tag);
+        }
+    }
+    /**
+     * Convert native tags to common tags
+     * @returns {IAudioMetadata} Native + common tags
+     */
+    toCommonMetadata() {
+        return {
+            format: this.format,
+            native: this.native,
+            quality: this.quality,
+            common: this.common
+        };
+    }
+    /**
+     * Handle singular artist tags (artist, albumartist) and cross-populate to plural form
+     */
+    handleSingularArtistTag(tagType, tag, singularId, pluralId) {
+        if (this.commonOrigin[singularId] === this.originPriority[tagType]) {
+            // Assume the singular field is used as plural (multiple values from same source)
+            return this.postMap('artificial', { id: pluralId, value: tag.value });
+        }
+        if (!this.common[pluralId]) {
+            // Fill plural using singular source
+            this.setGenericTag('artificial', { id: pluralId, value: tag.value });
+        }
+        this.setGenericTag(tagType, tag);
+    }
+    /**
+     * Handle plural artist tags (artists, albumartists) and cross-populate to singular form
+     */
+    handlePluralArtistTag(tagType, tag, singularId, pluralId) {
+        if (!this.common[singularId] || this.commonOrigin[singularId] === this.originPriority.artificial) {
+            if (!this.common[pluralId] || this.common[pluralId].indexOf(tag.value) === -1) {
+                // Fill singular using plural source
+                const values = (this.common[pluralId] || []).concat([tag.value]);
+                const value = joinArtists(values);
+                this.setGenericTag('artificial', { id: singularId, value });
+            }
+        }
+        this.setGenericTag(tagType, tag);
+    }
+    /**
+     * Fix some common issues with picture object
+     * @param picture Picture
+     */
+    async postFixPicture(picture) {
+        if (picture.data && picture.data.length > 0) {
+            if (!picture.format) {
+                const fileType = await fileTypeFromBuffer(Uint8Array.from(picture.data)); // ToDO: remove Buffer
+                if (fileType) {
+                    picture.format = fileType.mime;
+                }
+                else {
+                    return null;
+                }
+            }
+            picture.format = picture.format.toLocaleLowerCase();
+            switch (picture.format) {
+                case 'image/jpg':
+                    picture.format = 'image/jpeg'; // ToDo: register warning
+            }
+            return picture;
+        }
+        this.addWarning("Empty picture tag found");
+        return null;
+    }
+    /**
+     * Convert native tag to common tags
+     */
+    async toCommon(tagType, tagId, value) {
+        const tag = { id: tagId, value };
+        const genericTag = this.tagMapper.mapTag(tagType, tag, this);
+        if (genericTag) {
+            await this.postMap(tagType, genericTag);
+        }
+    }
+    /**
+     * Set generic tag
+     */
+    setGenericTag(tagType, tag) {
+        debug(`common.${tag.id} = ${tag.value}`);
+        const prio0 = this.commonOrigin[tag.id] || 1000;
+        const prio1 = this.originPriority[tagType];
+        if (isSingleton(tag.id)) {
+            if (prio1 <= prio0) {
+                this.common[tag.id] = tag.value;
+                this.commonOrigin[tag.id] = prio1;
+            }
+            else {
+                return debug(`Ignore native tag (singleton): ${tagType}.${tag.id} = ${tag.value}`);
+            }
+        }
+        else {
+            if (prio1 === prio0) {
+                if (!isUnique(tag.id) || this.common[tag.id].indexOf(tag.value) === -1) {
+                    this.common[tag.id].push(tag.value);
+                }
+                else {
+                    debug(`Ignore duplicate value: ${tagType}.${tag.id} = ${tag.value}`);
+                }
+                // no effect? this.commonOrigin[tag.id] = prio1;
+            }
+            else if (prio1 < prio0) {
+                this.common[tag.id] = [tag.value];
+                this.commonOrigin[tag.id] = prio1;
+            }
+            else {
+                return debug(`Ignore native tag (list): ${tagType}.${tag.id} = ${tag.value}`);
+            }
+        }
+        if (this.opts?.observer) {
+            this.opts.observer({ metadata: this, tag: { type: 'common', id: tag.id, value: tag.value } });
+        }
+        // ToDo: trigger metadata event
+    }
+}
+export function joinArtists(artists) {
+    if (artists.length > 2) {
+        return `${artists.slice(0, artists.length - 1).join(', ')} & ${artists[artists.length - 1]}`;
+    }
+    return artists.join(' & ');
+}

package/node_modules/music-metadata/lib/common/Util.d.ts

@@ -0,0 +1,56 @@
+import type { IRatio } from '../type.js';
+export type StringEncoding = 'ascii' | 'utf8' | 'utf-16le' | 'ucs2' | 'base64url' | 'latin1' | 'hex';
+export declare function getBit(buf: Uint8Array, off: number, bit: number): boolean;
+/**
+ * Find delimiting zero in uint8Array
+ * @param uint8Array Uint8Array to find the zero delimiter in
+ * @param encoding The string encoding used
+ * @return position in uint8Array where zero found, or uint8Array.length if not found
+ */
+export declare function findZero(uint8Array: Uint8Array, encoding?: StringEncoding): number;
+export declare function trimRightNull(x: string): string;
+/**
+ * Decode string
+ */
+export declare function decodeString(uint8Array: Uint8Array, encoding: StringEncoding): string;
+export declare function stripNulls(str: string): string;
+/**
+ * Read bit-aligned number start from buffer
+ * Total offset in bits = byteOffset * 8 + bitOffset
+ * @param source Byte buffer
+ * @param byteOffset Starting offset in bytes
+ * @param bitOffset Starting offset in bits: 0 = lsb
+ * @param len Length of number in bits
+ * @return Decoded bit aligned number
+ */
+export declare function getBitAllignedNumber(source: Uint8Array, byteOffset: number, bitOffset: number, len: number): number;
+/**
+ * Read bit-aligned number start from buffer
+ * Total offset in bits = byteOffset * 8 + bitOffset
+ * @param source Byte Uint8Array
+ * @param byteOffset Starting offset in bytes
+ * @param bitOffset Starting offset in bits: 0 = most significant bit, 7 is the least significant bit
+ * @return True if bit is set
+ */
+export declare function isBitSet(source: Uint8Array, byteOffset: number, bitOffset: number): boolean;
+export declare function a2hex(str: string): string;
+/**
+ * Convert power ratio to DB
+ * ratio: [0..1]
+ */
+export declare function ratioToDb(ratio: number): number;
+/**
+ * Convert dB to ratio
+ * db Decibels
+ */
+export declare function dbToRatio(dB: number): number;
+/**
+ * Convert replay gain to ratio and Decibel
+ * @param value string holding a ratio like '0.034' or '-7.54 dB'
+ */
+export declare function toRatio(value: string): IRatio | undefined;
+/**
+ * Decode a big-endian unsigned integer from a Uint8Array.
+ * Supports dynamic length (1–8 bytes).
+ */
+export declare function decodeUintBE(uint8Array: Uint8Array): number;

package/node_modules/music-metadata/lib/common/Util.js

@@ -0,0 +1,152 @@
+import { StringType } from 'token-types';
+import { FieldDecodingError } from '../ParseError.js';
+import { getUintBE } from 'uint8array-extras';
+export function getBit(buf, off, bit) {
+    return (buf[off] & (1 << bit)) !== 0;
+}
+/**
+ * Find delimiting zero in uint8Array
+ * @param uint8Array Uint8Array to find the zero delimiter in
+ * @param encoding The string encoding used
+ * @return position in uint8Array where zero found, or uint8Array.length if not found
+ */
+export function findZero(uint8Array, encoding) {
+    const len = uint8Array.length;
+    if (encoding === 'utf-16le') {
+        // Look for 0x00 0x00 on 2-byte boundary
+        for (let i = 0; i + 1 < len; i += 2) {
+            if (uint8Array[i] === 0 && uint8Array[i + 1] === 0)
+                return i;
+        }
+        return len;
+    }
+    // latin1 / utf8 / utf16be (caller typically handles utf16be separately or via decode)
+    for (let i = 0; i < len; i++) {
+        if (uint8Array[i] === 0)
+            return i;
+    }
+    return len;
+}
+export function trimRightNull(x) {
+    const pos0 = x.indexOf('\0');
+    return pos0 === -1 ? x : x.substring(0, pos0);
+}
+function swapBytes(uint8Array) {
+    const l = uint8Array.length;
+    if ((l & 1) !== 0)
+        throw new FieldDecodingError('Buffer length must be even');
+    for (let i = 0; i < l; i += 2) {
+        const a = uint8Array[i];
+        uint8Array[i] = uint8Array[i + 1];
+        uint8Array[i + 1] = a;
+    }
+    return uint8Array;
+}
+/**
+ * Decode string
+ */
+export function decodeString(uint8Array, encoding) {
+    // annoying workaround for a double BOM issue
+    // https://github.com/leetreveil/musicmetadata/issues/84
+    if (uint8Array[0] === 0xFF && uint8Array[1] === 0xFE) { // little endian
+        return decodeString(uint8Array.subarray(2), encoding);
+    }
+    if (encoding === 'utf-16le' && uint8Array[0] === 0xFE && uint8Array[1] === 0xFF) {
+        // BOM, indicating big endian decoding
+        if ((uint8Array.length & 1) !== 0)
+            throw new FieldDecodingError('Expected even number of octets for 16-bit unicode string');
+        return decodeString(swapBytes(uint8Array), encoding);
+    }
+    return new StringType(uint8Array.length, encoding).get(uint8Array, 0);
+}
+export function stripNulls(str) {
+    str = str.replace(/^\x00+/g, '');
+    str = str.replace(/\x00+$/g, '');
+    return str;
+}
+/**
+ * Read bit-aligned number start from buffer
+ * Total offset in bits = byteOffset * 8 + bitOffset
+ * @param source Byte buffer
+ * @param byteOffset Starting offset in bytes
+ * @param bitOffset Starting offset in bits: 0 = lsb
+ * @param len Length of number in bits
+ * @return Decoded bit aligned number
+ */
+export function getBitAllignedNumber(source, byteOffset, bitOffset, len) {
+    const byteOff = byteOffset + ~~(bitOffset / 8);
+    const bitOff = bitOffset % 8;
+    let value = source[byteOff];
+    value &= 0xff >> bitOff;
+    const bitsRead = 8 - bitOff;
+    const bitsLeft = len - bitsRead;
+    if (bitsLeft < 0) {
+        value >>= (8 - bitOff - len);
+    }
+    else if (bitsLeft > 0) {
+        value <<= bitsLeft;
+        value |= getBitAllignedNumber(source, byteOffset, bitOffset + bitsRead, bitsLeft);
+    }
+    return value;
+}
+/**
+ * Read bit-aligned number start from buffer
+ * Total offset in bits = byteOffset * 8 + bitOffset
+ * @param source Byte Uint8Array
+ * @param byteOffset Starting offset in bytes
+ * @param bitOffset Starting offset in bits: 0 = most significant bit, 7 is the least significant bit
+ * @return True if bit is set
+ */
+export function isBitSet(source, byteOffset, bitOffset) {
+    return getBitAllignedNumber(source, byteOffset, bitOffset, 1) === 1;
+}
+export function a2hex(str) {
+    const arr = [];
+    for (let i = 0, l = str.length; i < l; i++) {
+        const hex = Number(str.charCodeAt(i)).toString(16);
+        arr.push(hex.length === 1 ? `0${hex}` : hex);
+    }
+    return arr.join(' ');
+}
+/**
+ * Convert power ratio to DB
+ * ratio: [0..1]
+ */
+export function ratioToDb(ratio) {
+    return 10 * Math.log10(ratio);
+}
+/**
+ * Convert dB to ratio
+ * db Decibels
+ */
+export function dbToRatio(dB) {
+    return 10 ** (dB / 10);
+}
+/**
+ * Convert replay gain to ratio and Decibel
+ * @param value string holding a ratio like '0.034' or '-7.54 dB'
+ */
+export function toRatio(value) {
+    const ps = value.split(' ').map(p => p.trim().toLowerCase());
+    if (ps.length >= 1) {
+        const v = Number.parseFloat(ps[0]);
+        return ps.length === 2 && ps[1] === 'db' ? {
+            dB: v,
+            ratio: dbToRatio(v)
+        } : {
+            dB: ratioToDb(v),
+            ratio: v
+        };
+    }
+}
+/**
+ * Decode a big-endian unsigned integer from a Uint8Array.
+ * Supports dynamic length (1–8 bytes).
+ */
+export function decodeUintBE(uint8Array) {
+    if (uint8Array.length === 0) {
+        throw new Error("decodeUintBE: empty Uint8Array");
+    }
+    const view = new DataView(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength);
+    return getUintBE(view);
+}

package/node_modules/music-metadata/lib/core.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Primary entry point, Node.js specific entry point is MusepackParser.ts
+ */
+import { type AnyWebByteStream, type IFileInfo, type ITokenizer, type IRandomAccessTokenizer } from 'strtok3';
+import type { IAudioMetadata, INativeTagDict, IOptions, IPicture, IPrivateOptions, ITag } from './type.js';
+import type { Readable } from 'node:stream';
+export type { IFileInfo } from 'strtok3';
+export { type IAudioMetadata, type IOptions, type ITag, type INativeTagDict, type ICommonTagsResult, type IFormat, type IPicture, type IRatio, type IChapter, type ILyricsTag, LyricsContentType, TimestampFormat, IMetadataEventTag, IMetadataEvent } from './type.js';
+export { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
+export * from './ParseError.js';
+/**
+ * Parse Web API File
+ * Requires Blob to be able to stream using a ReadableStreamBYOBReader, only available since Node.js ≥ 20
+ * @param blob - Blob to parse
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export declare function parseBlob(blob: Blob, options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Parse audio from Web Stream.Readable
+ * @param webStream - WebStream to read the audio track from
+ * @param options - Parsing options
+ * @param fileInfo - File information object or MIME-type string
+ * @returns Metadata
+ */
+export declare function parseWebStream(webStream: AnyWebByteStream, fileInfo?: IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Parse audio from memory
+ * @param uint8Array - Uint8Array holding audio data
+ * @param fileInfo - File information object or MIME-type string
+ * @param options - Parsing options
+ * @returns Metadata
+ * Ref: https://github.com/Borewit/strtok3/blob/e6938c81ff685074d5eb3064a11c0b03ca934c1d/src/index.ts#L15
+ */
+export declare function parseBuffer(uint8Array: Uint8Array, fileInfo?: IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Parse audio from ITokenizer source
+ * @param tokenizer - Audio source implementing the tokenizer interface
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export declare function parseFromTokenizer(tokenizer: ITokenizer, options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Create a dictionary ordered by their tag id (key)
+ * @param nativeTags list of tags
+ * @returns tags indexed by id
+ */
+export declare function orderTags(nativeTags: ITag[]): INativeTagDict;
+/**
+ * Convert rating to 1-5 star rating
+ * @param rating Normalized rating [0..1] (common.rating[n].rating)
+ * @returns Number of stars: 1, 2, 3, 4 or 5 stars
+ */
+export declare function ratingToStars(rating: number | undefined): number;
+/**
+ * Select most likely cover image.
+ * @param pictures Usually metadata.common.picture
+ * @return Cover image, if any, otherwise null
+ */
+export declare function selectCover(pictures?: IPicture[]): IPicture | null;
+export declare function scanAppendingHeaders(tokenizer: IRandomAccessTokenizer, options?: IPrivateOptions): Promise<void>;
+/**
+ * Implementation only available when loaded as Node.js
+ * This method will throw an Error, always.
+ */
+export declare function parseFile(_filePath: string, _options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Implementation only available when loaded as Node.js
+ * This method will throw an Error, always.
+ */
+export declare function parseStream(_stream: Readable, _fileInfo?: IFileInfo | string, _options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Return a list of supported mime-types
+ */
+export declare function getSupportedMimeTypes(): string[];