valley-baileys 1.0.0

package/node_modules/music-metadata/lib/ebml/EbmlIterator.js

@@ -0,0 +1,218 @@
+import { Float32_BE, Float64_BE, StringType, UINT8 } from 'token-types';
+import initDebug from 'debug';
+import { EndOfStreamError } from 'strtok3';
+import { DataType } from './types.js';
+import * as Token from 'token-types';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+const debug = initDebug('music-metadata:parser:ebml');
+export class EbmlContentError extends makeUnexpectedFileContentError('EBML') {
+}
+export const ParseAction = {
+    ReadNext: 0, // Continue reading the next elements
+    IgnoreElement: 2, // Ignore (do not read) this element
+    SkipSiblings: 3, // Skip all remaining elements at the same level
+    TerminateParsing: 4, // Terminate the parsing process
+    SkipElement: 5 // Consider the element has read, assume position is at the next element
+};
+/**
+ * Extensible Binary Meta Language (EBML) iterator
+ * https://en.wikipedia.org/wiki/Extensible_Binary_Meta_Language
+ * http://matroska.sourceforge.net/technical/specs/rfc/index.html
+ *
+ * WEBM VP8 AUDIO FILE
+ */
+export class EbmlIterator {
+    /**
+     * @param {ITokenizer} tokenizer Input
+     * @param tokenizer
+     */
+    constructor(tokenizer) {
+        this.parserMap = new Map();
+        this.ebmlMaxIDLength = 4;
+        this.ebmlMaxSizeLength = 8;
+        this.tokenizer = tokenizer;
+        this.parserMap.set(DataType.uint, e => this.readUint(e));
+        this.parserMap.set(DataType.string, e => this.readString(e));
+        this.parserMap.set(DataType.binary, e => this.readBuffer(e));
+        this.parserMap.set(DataType.uid, async (e) => this.readBuffer(e));
+        this.parserMap.set(DataType.bool, e => this.readFlag(e));
+        this.parserMap.set(DataType.float, e => this.readFloat(e));
+    }
+    async iterate(dtdElement, posDone, listener) {
+        return this.parseContainer(linkParents(dtdElement), posDone, listener);
+    }
+    async parseContainer(dtdElement, posDone, listener) {
+        const tree = {};
+        while (this.tokenizer.position < posDone) {
+            let element;
+            const elementPosition = this.tokenizer.position;
+            try {
+                element = await this.readElement();
+            }
+            catch (error) {
+                if (error instanceof EndOfStreamError) {
+                    break;
+                }
+                throw error;
+            }
+            const child = dtdElement.container[element.id];
+            if (child) {
+                const action = listener.startNext(child);
+                switch (action) {
+                    case ParseAction.ReadNext:
+                        {
+                            if (element.id === 0x1F43B675) {
+                                // Hack to ignore remaining segment, when cluster element received
+                                // await this.tokenizer.ignore(posDone - this.tokenizer.position);
+                                // break;
+                            }
+                            debug(`Read element: name=${getElementPath(child)}{id=0x${element.id.toString(16)}, container=${!!child.container}} at position=${elementPosition}`);
+                            if (child.container) {
+                                const res = await this.parseContainer(child, element.len >= 0 ? this.tokenizer.position + element.len : -1, listener);
+                                if (child.multiple) {
+                                    if (!tree[child.name]) {
+                                        tree[child.name] = [];
+                                    }
+                                    tree[child.name].push(res);
+                                }
+                                else {
+                                    tree[child.name] = res;
+                                }
+                                await listener.elementValue(child, res, elementPosition);
+                            }
+                            else {
+                                const parser = this.parserMap.get(child.value);
+                                if (typeof parser === 'function') {
+                                    const value = await parser(element);
+                                    tree[child.name] = value;
+                                    await listener.elementValue(child, value, elementPosition);
+                                }
+                            }
+                        }
+                        break;
+                    case ParseAction.SkipElement:
+                        debug(`Go to next element: name=${getElementPath(child)}, element.id=0x${element.id}, container=${!!child.container} at position=${elementPosition}`);
+                        break;
+                    case ParseAction.IgnoreElement:
+                        debug(`Ignore element: name=${getElementPath(child)}, element.id=0x${element.id}, container=${!!child.container} at position=${elementPosition}`);
+                        await this.tokenizer.ignore(element.len);
+                        break;
+                    case ParseAction.SkipSiblings:
+                        debug(`Ignore remaining container, at: name=${getElementPath(child)}, element.id=0x${element.id}, container=${!!child.container} at position=${elementPosition}`);
+                        await this.tokenizer.ignore(posDone - this.tokenizer.position);
+                        break;
+                    case ParseAction.TerminateParsing:
+                        debug(`Terminate parsing at element: name=${getElementPath(child)}, element.id=0x${element.id}, container=${!!child.container} at position=${elementPosition}`);
+                        return tree;
+                }
+            }
+            else {
+                switch (element.id) {
+                    case 0xec: // void
+                        await this.tokenizer.ignore(element.len);
+                        break;
+                    default:
+                        debug(`parseEbml: parent=${getElementPath(dtdElement)}, unknown child: id=${element.id.toString(16)} at position=${elementPosition}`);
+                        await this.tokenizer.ignore(element.len);
+                }
+            }
+        }
+        return tree;
+    }
+    async readVintData(maxLength) {
+        const msb = await this.tokenizer.peekNumber(UINT8);
+        let mask = 0x80;
+        let oc = 1;
+        // Calculate VINT_WIDTH
+        while ((msb & mask) === 0) {
+            if (oc > maxLength) {
+                throw new EbmlContentError('VINT value exceeding maximum size');
+            }
+            ++oc;
+            mask >>= 1;
+        }
+        const id = new Uint8Array(oc);
+        await this.tokenizer.readBuffer(id);
+        return id;
+    }
+    async readElement() {
+        const id = await this.readVintData(this.ebmlMaxIDLength);
+        const lenField = await this.readVintData(this.ebmlMaxSizeLength);
+        lenField[0] ^= 0x80 >> (lenField.length - 1);
+        return {
+            id: readUIntBE(id, id.length),
+            len: readUIntBE(lenField, lenField.length)
+        };
+    }
+    async readFloat(e) {
+        switch (e.len) {
+            case 0:
+                return 0.0;
+            case 4:
+                return this.tokenizer.readNumber(Float32_BE);
+            case 8:
+                return this.tokenizer.readNumber(Float64_BE);
+            case 10:
+                return this.tokenizer.readNumber(Float64_BE);
+            default:
+                throw new EbmlContentError(`Invalid IEEE-754 float length: ${e.len}`);
+        }
+    }
+    async readFlag(e) {
+        return (await this.readUint(e)) === 1;
+    }
+    async readUint(e) {
+        const buf = await this.readBuffer(e);
+        return readUIntBE(buf, e.len);
+    }
+    async readString(e) {
+        const rawString = await this.tokenizer.readToken(new StringType(e.len, 'utf-8'));
+        return rawString.replace(/\x00.*$/g, '');
+    }
+    async readBuffer(e) {
+        const buf = new Uint8Array(e.len);
+        await this.tokenizer.readBuffer(buf);
+        return buf;
+    }
+}
+function readUIntBE(buf, len) {
+    return Number(readUIntBeAsBigInt(buf, len));
+}
+/**
+ * Reeds an unsigned integer from a big endian buffer of length `len`
+ * @param buf Buffer to decode from
+ * @param len Number of bytes
+ * @private
+ */
+function readUIntBeAsBigInt(buf, len) {
+    const normalizedNumber = new Uint8Array(8);
+    const cleanNumber = buf.subarray(0, len);
+    try {
+        normalizedNumber.set(cleanNumber, 8 - len);
+        return Token.UINT64_BE.get(normalizedNumber, 0);
+    }
+    catch (_error) {
+        return BigInt(-1);
+    }
+}
+function linkParents(element) {
+    if (element.container) {
+        Object.keys(element.container)
+            .map(id => {
+            const child = element.container[id];
+            child.id = Number.parseInt(id, 10);
+            return child;
+        }).forEach(child => {
+            child.parent = element;
+            linkParents(child);
+        });
+    }
+    return element;
+}
+export function getElementPath(element) {
+    let path = '';
+    if (element.parent && element.parent.name !== 'dtd') {
+        path += `${getElementPath(element.parent)}/`;
+    }
+    return path + element.name;
+}

package/node_modules/music-metadata/lib/ebml/types.d.ts

@@ -0,0 +1,37 @@
+export interface ITree {
+    [name: string]: string | number | boolean | Uint8Array | ITree | ITree[];
+}
+export declare const DataType: {
+    readonly string: 0;
+    readonly uint: 1;
+    readonly uid: 2;
+    readonly bool: 3;
+    readonly binary: 4;
+    readonly float: 5;
+};
+export type DataType = typeof DataType[keyof typeof DataType];
+export type ValueType = string | number | Uint8Array | boolean | ITree | ITree[];
+export interface IHeader {
+    id: number;
+    len: number;
+}
+export interface IEbmlElements {
+    version?: number;
+    readVersion?: number;
+    maxIDWidth?: number;
+    maxSizeWidth?: number;
+    docType?: string;
+    docTypeVersion?: number;
+    docTypeReadVersion?: number;
+}
+export interface IElementType {
+    readonly name: string;
+    readonly value?: DataType;
+    readonly container?: {
+        [id: number]: IElementType;
+    };
+    readonly multiple?: boolean;
+}
+export interface IEbmlDoc {
+    ebml: IEbmlElements;
+}

package/node_modules/music-metadata/lib/ebml/types.js

@@ -0,0 +1,8 @@
+export const DataType = {
+    string: 0,
+    uint: 1,
+    uid: 2,
+    bool: 3,
+    binary: 4,
+    float: 5,
+};

package/node_modules/music-metadata/lib/flac/FlacLoader.d.ts

@@ -0,0 +1,2 @@
+import type { IParserLoader } from '../ParserFactory.js';
+export declare const flacParserLoader: IParserLoader;

package/node_modules/music-metadata/lib/flac/FlacLoader.js

@@ -0,0 +1,8 @@
+export const flacParserLoader = {
+    parserType: 'flac',
+    extensions: ['.flac'],
+    mimeTypes: ['audio/flac'],
+    async load() {
+        return (await import('./FlacParser.js')).FlacParser;
+    }
+};

package/node_modules/music-metadata/lib/flac/FlacParser.d.ts

@@ -0,0 +1,29 @@
+import { type IVorbisPicture } from '../ogg/vorbis/Vorbis.js';
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+import type { IBlockStreamInfo } from './FlacToken.js';
+export declare class FlacParser extends AbstractID3Parser {
+    private vorbisParser;
+    postId3v2Parse(): Promise<void>;
+    private parseDataBlock;
+    /**
+     * Parse STREAMINFO
+     */
+    private readBlockStreamInfo;
+    /**
+     * Parse STREAMINFO
+     */
+    processsStreamInfo(streamInfo: IBlockStreamInfo): void;
+    /**
+     * Read VORBIS_COMMENT from tokenizer
+     * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
+     */
+    private readComment;
+    /**
+     * Parse VORBIS_COMMENT
+     * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
+     */
+    parseComment(data: Uint8Array): Promise<void>;
+    private parsePicture;
+    addPictureTag(picture: IVorbisPicture): Promise<void>;
+    private addTag;
+}

package/node_modules/music-metadata/lib/flac/FlacParser.js

@@ -0,0 +1,125 @@
+import initDebug from 'debug';
+import { Uint8ArrayType } from 'token-types';
+import { VorbisPictureToken } from '../ogg/vorbis/Vorbis.js';
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+import { FourCcToken } from '../common/FourCC.js';
+import { VorbisStream } from '../ogg/vorbis/VorbisStream.js';
+import { VorbisDecoder } from '../ogg/vorbis/VorbisDecoder.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+import * as Flac from './FlacToken.js';
+const debug = initDebug('music-metadata:parser:FLAC');
+class FlacContentError extends makeUnexpectedFileContentError('FLAC') {
+}
+export class FlacParser extends AbstractID3Parser {
+    constructor() {
+        super(...arguments);
+        this.vorbisParser = new VorbisStream(this.metadata, this.options);
+    }
+    async postId3v2Parse() {
+        const fourCC = await this.tokenizer.readToken(FourCcToken);
+        if (fourCC.toString() !== 'fLaC') {
+            throw new FlacContentError('Invalid FLAC preamble');
+        }
+        let blockHeader;
+        do {
+            // Read block header
+            blockHeader = await this.tokenizer.readToken(Flac.BlockHeader);
+            // Parse block data
+            await this.parseDataBlock(blockHeader);
+        } while (!blockHeader.lastBlock);
+        if (this.tokenizer.fileInfo.size && this.metadata.format.duration) {
+            const dataSize = this.tokenizer.fileInfo.size - this.tokenizer.position;
+            this.metadata.setFormat('bitrate', 8 * dataSize / this.metadata.format.duration);
+        }
+    }
+    async parseDataBlock(blockHeader) {
+        debug(`blockHeader type=${blockHeader.type}, length=${blockHeader.length}`);
+        switch (blockHeader.type) {
+            case Flac.BlockType.STREAMINFO:
+                return this.readBlockStreamInfo(blockHeader.length);
+            case Flac.BlockType.PADDING:
+                break;
+            case Flac.BlockType.APPLICATION:
+                break;
+            case Flac.BlockType.SEEKTABLE:
+                break;
+            case Flac.BlockType.VORBIS_COMMENT:
+                return this.readComment(blockHeader.length);
+            case Flac.BlockType.CUESHEET:
+                break;
+            case Flac.BlockType.PICTURE:
+                await this.parsePicture(blockHeader.length);
+                return;
+            default:
+                this.metadata.addWarning(`Unknown block type: ${blockHeader.type}`);
+        }
+        // Ignore data block
+        return this.tokenizer.ignore(blockHeader.length).then();
+    }
+    /**
+     * Parse STREAMINFO
+     */
+    async readBlockStreamInfo(dataLen) {
+        if (dataLen !== Flac.BlockStreamInfo.len)
+            throw new FlacContentError('Unexpected block-stream-info length');
+        const streamInfo = await this.tokenizer.readToken(Flac.BlockStreamInfo);
+        this.metadata.setFormat('container', 'FLAC');
+        this.processsStreamInfo(streamInfo);
+    }
+    /**
+     * Parse STREAMINFO
+     */
+    processsStreamInfo(streamInfo) {
+        this.metadata.setFormat('codec', 'FLAC');
+        this.metadata.setFormat('hasAudio', true);
+        this.metadata.setFormat('lossless', true);
+        this.metadata.setFormat('numberOfChannels', streamInfo.channels);
+        this.metadata.setFormat('bitsPerSample', streamInfo.bitsPerSample);
+        this.metadata.setFormat('sampleRate', streamInfo.sampleRate);
+        if (streamInfo.totalSamples > 0) {
+            this.metadata.setFormat('duration', streamInfo.totalSamples / streamInfo.sampleRate);
+        }
+    }
+    /**
+     * Read VORBIS_COMMENT from tokenizer
+     * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
+     */
+    async readComment(dataLen) {
+        const data = await this.tokenizer.readToken(new Uint8ArrayType(dataLen));
+        return this.parseComment(data);
+    }
+    /**
+     * Parse VORBIS_COMMENT
+     * Ref: https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-640004.2.3
+     */
+    async parseComment(data) {
+        const decoder = new VorbisDecoder(data, 0);
+        const vendor = decoder.readStringUtf8();
+        if (vendor.length > 0) {
+            this.metadata.setFormat('tool', vendor);
+        }
+        const commentListLength = decoder.readInt32();
+        const tags = new Array(commentListLength);
+        for (let i = 0; i < commentListLength; i++) {
+            tags[i] = decoder.parseUserComment();
+        }
+        await Promise.all(tags.map(tag => {
+            if (tag.key === 'ENCODER') {
+                this.metadata.setFormat('tool', tag.value);
+            }
+            return this.addTag(tag.key, tag.value);
+        }));
+    }
+    async parsePicture(dataLen) {
+        if (this.options.skipCovers) {
+            return this.tokenizer.ignore(dataLen);
+        }
+        return this.addPictureTag(await this.tokenizer.readToken(new VorbisPictureToken(dataLen)));
+    }
+    addPictureTag(picture) {
+        return this.addTag('METADATA_BLOCK_PICTURE', picture);
+    }
+    addTag(id, value) {
+        return this.vorbisParser.addTag(id, value);
+    }
+}

package/node_modules/music-metadata/lib/flac/FlacToken.d.ts

@@ -0,0 +1,45 @@
+import type { IGetToken } from 'strtok3';
+/**
+ * FLAC supports up to 128 kinds of metadata blocks; currently the following are defined:
+ * ref: https://xiph.org/flac/format.html#metadata_block
+ */
+export declare const BlockType: {
+    STREAMINFO: number;
+    PADDING: number;
+    APPLICATION: number;
+    SEEKTABLE: number;
+    VORBIS_COMMENT: number;
+    CUESHEET: number;
+    PICTURE: number;
+};
+export type BlockType = typeof BlockType[keyof typeof BlockType];
+/**
+ * METADATA_BLOCK_DATA
+ * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
+ */
+export interface IBlockHeader {
+    lastBlock: boolean;
+    type: BlockType;
+    length: number;
+}
+export declare const BlockHeader: IGetToken<IBlockHeader>;
+/**
+ * METADATA_BLOCK_DATA
+ * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
+ */
+export interface IBlockStreamInfo {
+    minimumBlockSize: number;
+    maximumBlockSize: number;
+    minimumFrameSize: number;
+    maximumFrameSize: number;
+    sampleRate: number;
+    channels: number;
+    bitsPerSample: number;
+    totalSamples: number;
+    fileMD5: Uint8Array;
+}
+/**
+ * METADATA_BLOCK_DATA
+ * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
+ */
+export declare const BlockStreamInfo: IGetToken<IBlockStreamInfo>;

package/node_modules/music-metadata/lib/flac/FlacToken.js

@@ -0,0 +1,63 @@
+import * as util from '../common/Util.js';
+import { UINT16_BE, UINT24_BE, Uint8ArrayType } from 'token-types';
+/**
+ * FLAC supports up to 128 kinds of metadata blocks; currently the following are defined:
+ * ref: https://xiph.org/flac/format.html#metadata_block
+ */
+export const BlockType = {
+    STREAMINFO: 0, // STREAMINFO
+    PADDING: 1, // PADDING
+    APPLICATION: 2, // APPLICATION
+    SEEKTABLE: 3, // SEEKTABLE
+    VORBIS_COMMENT: 4, // VORBIS_COMMENT
+    CUESHEET: 5, // CUESHEET
+    PICTURE: 6 // PICTURE
+};
+export const BlockHeader = {
+    len: 4,
+    get: (buf, off) => {
+        return {
+            lastBlock: util.getBit(buf, off, 7),
+            type: util.getBitAllignedNumber(buf, off, 1, 7),
+            length: UINT24_BE.get(buf, off + 1)
+        };
+    }
+};
+/**
+ * METADATA_BLOCK_DATA
+ * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo
+ */
+export const BlockStreamInfo = {
+    len: 34,
+    get: (buf, off) => {
+        return {
+            // The minimum block size (in samples) used in the stream.
+            minimumBlockSize: UINT16_BE.get(buf, off),
+            // The maximum block size (in samples) used in the stream.
+            // (Minimum blocksize == maximum blocksize) implies a fixed-blocksize stream.
+            maximumBlockSize: UINT16_BE.get(buf, off + 2) / 1000,
+            // The minimum frame size (in bytes) used in the stream.
+            // May be 0 to imply the value is not known.
+            minimumFrameSize: UINT24_BE.get(buf, off + 4),
+            // The maximum frame size (in bytes) used in the stream.
+            // May be 0 to imply the value is not known.
+            maximumFrameSize: UINT24_BE.get(buf, off + 7),
+            // Sample rate in Hz. Though 20 bits are available,
+            // the maximum sample rate is limited by the structure of frame headers to 655350Hz.
+            // Also, a value of 0 is invalid.
+            sampleRate: UINT24_BE.get(buf, off + 10) >> 4,
+            // probably slower: sampleRate: common.getBitAllignedNumber(buf, off + 10, 0, 20),
+            // (number of channels)-1. FLAC supports from 1 to 8 channels
+            channels: util.getBitAllignedNumber(buf, off + 12, 4, 3) + 1,
+            // bits per sample)-1.
+            // FLAC supports from 4 to 32 bits per sample. Currently the reference encoder and decoders only support up to 24 bits per sample.
+            bitsPerSample: util.getBitAllignedNumber(buf, off + 12, 7, 5) + 1,
+            // Total samples in stream.
+            // 'Samples' means inter-channel sample, i.e. one second of 44.1Khz audio will have 44100 samples regardless of the number of channels.
+            // A value of zero here means the number of total samples is unknown.
+            totalSamples: util.getBitAllignedNumber(buf, off + 13, 4, 36),
+            // the MD5 hash of the file (see notes for usage... it's a littly tricky)
+            fileMD5: new Uint8ArrayType(16).get(buf, off + 18)
+        };
+    }
+};

package/node_modules/music-metadata/lib/id3v1/ID3v1Parser.d.ts

@@ -0,0 +1,17 @@
+import type { IRandomAccessTokenizer, ITokenizer } from 'strtok3';
+import { BasicParser } from '../common/BasicParser.js';
+import type { IPrivateOptions } from '../type.js';
+import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
+/**
+ * ID3v1 Genre mappings
+ * Ref: https://de.wikipedia.org/wiki/Liste_der_ID3v1-Genres
+ */
+export declare const Genres: string[];
+export declare class ID3v1Parser extends BasicParser {
+    private apeHeader;
+    constructor(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IPrivateOptions);
+    private static getGenre;
+    parse(): Promise<void>;
+    private addTag;
+}
+export declare function hasID3v1Header(tokenizer: IRandomAccessTokenizer): Promise<boolean>;