valley-baileys 1.0.0

package/node_modules/music-metadata/lib/mpeg/XingTag.d.ts

@@ -0,0 +1,44 @@
+import * as Token from 'token-types';
+import type { IGetToken, ITokenizer } from 'strtok3';
+import { type IExtendedLameHeader } from './ExtendedLameHeader.js';
+export interface IXingHeaderFlags {
+    frames: boolean;
+    bytes: boolean;
+    toc: boolean;
+    vbrScale: boolean;
+}
+/**
+ * Info Tag: Xing, LAME
+ */
+export declare const InfoTagHeaderTag: Token.StringType;
+/**
+ * LAME TAG value
+ * Did not find any official documentation for this
+ * Value e.g.: "3.98.4"
+ */
+export declare const LameEncoderVersion: Token.StringType;
+export interface IXingInfoTag {
+    /**
+     * total bit stream frames from Vbr header data
+     */
+    numFrames: number | null;
+    /**
+     * Actual stream size = file size - header(s) size [bytes]
+     */
+    streamSize: number | null;
+    toc?: Uint8Array;
+    /**
+     * the number of header data bytes (from original file)
+     */
+    vbrScale: number | null;
+    lame?: {
+        version: string;
+        extended?: IExtendedLameHeader;
+    };
+}
+/**
+ * Info Tag
+ * Ref: http://gabriel.mp3-tech.org/mp3infotag.html
+ */
+export declare const XingHeaderFlags: IGetToken<IXingHeaderFlags>;
+export declare function readXingHeader(tokenizer: ITokenizer): Promise<IXingInfoTag>;

package/node_modules/music-metadata/lib/mpeg/XingTag.js

@@ -0,0 +1,65 @@
+import * as Token from 'token-types';
+import * as util from '../common/Util.js';
+import { ExtendedLameHeader } from './ExtendedLameHeader.js';
+/**
+ * Info Tag: Xing, LAME
+ */
+export const InfoTagHeaderTag = new Token.StringType(4, 'ascii');
+/**
+ * LAME TAG value
+ * Did not find any official documentation for this
+ * Value e.g.: "3.98.4"
+ */
+export const LameEncoderVersion = new Token.StringType(6, 'ascii');
+/**
+ * Info Tag
+ * Ref: http://gabriel.mp3-tech.org/mp3infotag.html
+ */
+export const XingHeaderFlags = {
+    len: 4,
+    get: (buf, off) => {
+        return {
+            frames: util.isBitSet(buf, off, 31),
+            bytes: util.isBitSet(buf, off, 30),
+            toc: util.isBitSet(buf, off, 29),
+            vbrScale: util.isBitSet(buf, off, 28)
+        };
+    }
+};
+// /**
+//  * XING Header Tag
+//  * Ref: http://gabriel.mp3-tech.org/mp3infotag.html
+//  */
+export async function readXingHeader(tokenizer) {
+    const flags = await tokenizer.readToken(XingHeaderFlags);
+    const xingInfoTag = { numFrames: null, streamSize: null, vbrScale: null };
+    if (flags.frames) {
+        xingInfoTag.numFrames = await tokenizer.readToken(Token.UINT32_BE);
+    }
+    if (flags.bytes) {
+        xingInfoTag.streamSize = await tokenizer.readToken(Token.UINT32_BE);
+    }
+    if (flags.toc) {
+        xingInfoTag.toc = new Uint8Array(100);
+        await tokenizer.readBuffer(xingInfoTag.toc);
+    }
+    if (flags.vbrScale) {
+        xingInfoTag.vbrScale = await tokenizer.readToken(Token.UINT32_BE);
+    }
+    const lameTag = await tokenizer.peekToken(new Token.StringType(4, 'ascii'));
+    if (lameTag === 'LAME') {
+        await tokenizer.ignore(4);
+        xingInfoTag.lame = {
+            version: await tokenizer.readToken(new Token.StringType(5, 'ascii'))
+        };
+        const match = xingInfoTag.lame.version.match(/\d+.\d+/g);
+        if (match !== null) {
+            const majorMinorVersion = match[0]; // e.g. 3.97
+            const version = majorMinorVersion.split('.').map(n => Number.parseInt(n, 10));
+            if (version[0] >= 3 && version[1] >= 90) {
+                xingInfoTag.lame.extended = await tokenizer.readToken(ExtendedLameHeader);
+            }
+        }
+    }
+    return xingInfoTag;
+}

package/node_modules/music-metadata/lib/musepack/MusepackConentError.d.ts

@@ -0,0 +1,15 @@
+declare const MusepackContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class MusepackContentError extends MusepackContentError_base {
+}
+export {};

package/node_modules/music-metadata/lib/musepack/MusepackConentError.js

@@ -0,0 +1,3 @@
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+export class MusepackContentError extends makeUnexpectedFileContentError('Musepack') {
+}

package/node_modules/music-metadata/lib/musepack/MusepackLoader.d.ts

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

package/node_modules/music-metadata/lib/musepack/MusepackLoader.js

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

package/node_modules/music-metadata/lib/musepack/MusepackParser.d.ts

@@ -0,0 +1,4 @@
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+export declare class MusepackParser extends AbstractID3Parser {
+    postId3v2Parse(): Promise<void>;
+}

package/node_modules/music-metadata/lib/musepack/MusepackParser.js

@@ -0,0 +1,30 @@
+import initDebug from 'debug';
+import * as Token from 'token-types';
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+import { MpcSv8Parser } from './sv8/MpcSv8Parser.js';
+import { MpcSv7Parser } from './sv7/MpcSv7Parser.js';
+import { MusepackContentError } from './MusepackConentError.js';
+const debug = initDebug('music-metadata:parser:musepack');
+export class MusepackParser extends AbstractID3Parser {
+    async postId3v2Parse() {
+        const signature = await this.tokenizer.peekToken(new Token.StringType(3, 'latin1'));
+        let mpcParser;
+        switch (signature) {
+            case 'MP+': {
+                debug('Stream-version 7');
+                mpcParser = new MpcSv7Parser(this.metadata, this.tokenizer, this.options);
+                break;
+            }
+            case 'MPC': {
+                debug('Stream-version 8');
+                mpcParser = new MpcSv8Parser(this.metadata, this.tokenizer, this.options);
+                break;
+            }
+            default: {
+                throw new MusepackContentError('Invalid signature prefix');
+            }
+        }
+        this.metadata.setAudioOnly();
+        return mpcParser.parse();
+    }
+}

package/node_modules/music-metadata/lib/musepack/sv7/BitReader.d.ts

@@ -0,0 +1,13 @@
+import type { ITokenizer } from 'strtok3';
+export declare class BitReader {
+    pos: number;
+    private dword;
+    private tokenizer;
+    constructor(tokenizer: ITokenizer);
+    /**
+     *
+     * @param bits 1..30 bits
+     */
+    read(bits: number): Promise<number>;
+    ignore(bits: number): Promise<number>;
+}

package/node_modules/music-metadata/lib/musepack/sv7/BitReader.js

@@ -0,0 +1,46 @@
+import * as Token from 'token-types';
+export class BitReader {
+    constructor(tokenizer) {
+        this.pos = 0;
+        this.dword = null;
+        this.tokenizer = tokenizer;
+    }
+    /**
+     *
+     * @param bits 1..30 bits
+     */
+    async read(bits) {
+        while (this.dword === null) {
+            this.dword = await this.tokenizer.readToken(Token.UINT32_LE);
+        }
+        let out = this.dword;
+        this.pos += bits;
+        if (this.pos < 32) {
+            out >>>= (32 - this.pos);
+            return out & ((1 << bits) - 1);
+        }
+        this.pos -= 32;
+        if (this.pos === 0) {
+            this.dword = null;
+            return out & ((1 << bits) - 1);
+        }
+        this.dword = await this.tokenizer.readToken(Token.UINT32_LE);
+        if (this.pos) {
+            out <<= this.pos;
+            out |= this.dword >>> (32 - this.pos);
+        }
+        return out & ((1 << bits) - 1);
+    }
+    async ignore(bits) {
+        if (this.pos > 0) {
+            const remaining = 32 - this.pos;
+            this.dword = null;
+            bits -= remaining;
+            this.pos = 0;
+        }
+        const remainder = bits % 32;
+        const numOfWords = (bits - remainder) / 32;
+        await this.tokenizer.ignore(numOfWords * 4);
+        return this.read(remainder);
+    }
+}

package/node_modules/music-metadata/lib/musepack/sv7/MpcSv7Parser.d.ts

@@ -0,0 +1,8 @@
+import { BasicParser } from '../../common/BasicParser.js';
+export declare class MpcSv7Parser extends BasicParser {
+    private bitreader;
+    private audioLength;
+    private duration;
+    parse(): Promise<void>;
+    private skipAudioData;
+}

package/node_modules/music-metadata/lib/musepack/sv7/MpcSv7Parser.js

@@ -0,0 +1,47 @@
+import initDebug from 'debug';
+import { BasicParser } from '../../common/BasicParser.js';
+import { tryParseApeHeader } from '../../apev2/APEv2Parser.js';
+import { BitReader } from './BitReader.js';
+import * as SV7 from './StreamVersion7.js';
+import { MusepackContentError } from '../MusepackConentError.js';
+const debug = initDebug('music-metadata:parser:musepack');
+export class MpcSv7Parser extends BasicParser {
+    constructor() {
+        super(...arguments);
+        this.bitreader = null;
+        this.audioLength = 0;
+        this.duration = null;
+    }
+    async parse() {
+        const header = await this.tokenizer.readToken(SV7.Header);
+        if (header.signature !== 'MP+')
+            throw new MusepackContentError('Unexpected magic number');
+        debug(`stream-version=${header.streamMajorVersion}.${header.streamMinorVersion}`);
+        this.metadata.setFormat('container', 'Musepack, SV7');
+        this.metadata.setFormat('sampleRate', header.sampleFrequency);
+        const numberOfSamples = 1152 * (header.frameCount - 1) + header.lastFrameLength;
+        this.metadata.setFormat('numberOfSamples', numberOfSamples);
+        this.duration = numberOfSamples / header.sampleFrequency;
+        this.metadata.setFormat('duration', this.duration);
+        this.bitreader = new BitReader(this.tokenizer);
+        this.metadata.setFormat('numberOfChannels', header.midSideStereo || header.intensityStereo ? 2 : 1);
+        const version = await this.bitreader.read(8);
+        this.metadata.setFormat('codec', (version / 100).toFixed(2));
+        await this.skipAudioData(header.frameCount);
+        debug(`End of audio stream, switching to APEv2, offset=${this.tokenizer.position}`);
+        return tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+    }
+    async skipAudioData(frameCount) {
+        while (frameCount-- > 0) {
+            const frameLength = await this.bitreader.read(20);
+            this.audioLength += 20 + frameLength;
+            await this.bitreader.ignore(frameLength);
+        }
+        // last frame
+        const lastFrameLength = await this.bitreader.read(11);
+        this.audioLength += lastFrameLength;
+        if (this.duration !== null) {
+            this.metadata.setFormat('bitrate', this.audioLength / this.duration);
+        }
+    }
+}

package/node_modules/music-metadata/lib/musepack/sv7/StreamVersion7.d.ts

@@ -0,0 +1,28 @@
+import type { IGetToken } from 'strtok3';
+/**
+ * MusePack stream version 7 format specification
+ * http://trac.musepack.net/musepack/wiki/SV7Specification
+ */
+export interface IHeader {
+    signature: string;
+    streamMinorVersion: number;
+    streamMajorVersion: number;
+    frameCount: number;
+    intensityStereo: boolean;
+    midSideStereo: boolean;
+    maxBand: number;
+    profile: number;
+    link: number;
+    sampleFrequency: number;
+    maxLevel: number;
+    titleGain: number;
+    titlePeak: number;
+    albumGain: number;
+    albumPeak: number;
+    trueGapless: boolean;
+    lastFrameLength: number;
+}
+/**
+ * BASIC STRUCTURE
+ */
+export declare const Header: IGetToken<IHeader>;

package/node_modules/music-metadata/lib/musepack/sv7/StreamVersion7.js

@@ -0,0 +1,39 @@
+import * as Token from 'token-types';
+import * as util from '../../common/Util.js';
+import { textDecode } from '@borewit/text-codec';
+/**
+ * BASIC STRUCTURE
+ */
+export const Header = {
+    len: 6 * 4,
+    get: (buf, off) => {
+        const header = {
+            // word 0
+            signature: textDecode(buf.subarray(off, off + 3), 'latin1'),
+            // versionIndex number * 1000 (3.81 = 3810) (remember that 4-byte alignment causes this to take 4-bytes)
+            streamMinorVersion: util.getBitAllignedNumber(buf, off + 3, 0, 4),
+            streamMajorVersion: util.getBitAllignedNumber(buf, off + 3, 4, 4),
+            // word 1
+            frameCount: Token.UINT32_LE.get(buf, off + 4),
+            // word 2
+            maxLevel: Token.UINT16_LE.get(buf, off + 8),
+            sampleFrequency: [44100, 48000, 37800, 32000][util.getBitAllignedNumber(buf, off + 10, 0, 2)],
+            link: util.getBitAllignedNumber(buf, off + 10, 2, 2),
+            profile: util.getBitAllignedNumber(buf, off + 10, 4, 4),
+            maxBand: util.getBitAllignedNumber(buf, off + 11, 0, 6),
+            intensityStereo: util.isBitSet(buf, off + 11, 6),
+            midSideStereo: util.isBitSet(buf, off + 11, 7),
+            // word 3
+            titlePeak: Token.UINT16_LE.get(buf, off + 12),
+            titleGain: Token.UINT16_LE.get(buf, off + 14),
+            // word 4
+            albumPeak: Token.UINT16_LE.get(buf, off + 16),
+            albumGain: Token.UINT16_LE.get(buf, off + 18),
+            // word
+            lastFrameLength: (Token.UINT32_LE.get(buf, off + 20) >>> 20) & 0x7FF,
+            trueGapless: util.isBitSet(buf, off + 23, 0)
+        };
+        header.lastFrameLength = header.trueGapless ? (Token.UINT32_LE.get(buf, 20) >>> 20) & 0x7FF : 0;
+        return header;
+    }
+};

package/node_modules/music-metadata/lib/musepack/sv8/MpcSv8Parser.d.ts

@@ -0,0 +1,6 @@
+import { BasicParser } from '../../common/BasicParser.js';
+export declare class MpcSv8Parser extends BasicParser {
+    private audioLength;
+    parse(): Promise<void>;
+    private parsePacket;
+}

package/node_modules/music-metadata/lib/musepack/sv8/MpcSv8Parser.js

@@ -0,0 +1,56 @@
+import initDebug from 'debug';
+import { BasicParser } from '../../common/BasicParser.js';
+import { tryParseApeHeader } from '../../apev2/APEv2Parser.js';
+import { FourCcToken } from '../../common/FourCC.js';
+import * as SV8 from './StreamVersion8.js';
+import { MusepackContentError } from '../MusepackConentError.js';
+const debug = initDebug('music-metadata:parser:musepack');
+export class MpcSv8Parser extends BasicParser {
+    constructor() {
+        super(...arguments);
+        this.audioLength = 0;
+    }
+    async parse() {
+        const signature = await this.tokenizer.readToken(FourCcToken);
+        if (signature !== 'MPCK')
+            throw new MusepackContentError('Invalid Magic number');
+        this.metadata.setFormat('container', 'Musepack, SV8');
+        return this.parsePacket();
+    }
+    async parsePacket() {
+        const sv8reader = new SV8.StreamReader(this.tokenizer);
+        do {
+            const header = await sv8reader.readPacketHeader();
+            debug(`packet-header key=${header.key}, payloadLength=${header.payloadLength}`);
+            switch (header.key) {
+                case 'SH': { // Stream Header
+                    const sh = await sv8reader.readStreamHeader(header.payloadLength);
+                    this.metadata.setFormat('numberOfSamples', sh.sampleCount);
+                    this.metadata.setFormat('sampleRate', sh.sampleFrequency);
+                    this.metadata.setFormat('duration', sh.sampleCount / sh.sampleFrequency);
+                    this.metadata.setFormat('numberOfChannels', sh.channelCount);
+                    break;
+                }
+                case 'AP': // Audio Packet
+                    this.audioLength += header.payloadLength;
+                    await this.tokenizer.ignore(header.payloadLength);
+                    break;
+                case 'RG': // Replaygain
+                case 'EI': // Encoder Info
+                case 'SO': // Seek Table Offset
+                case 'ST': // Seek Table
+                case 'CT': // Chapter-Tag
+                    await this.tokenizer.ignore(header.payloadLength);
+                    break;
+                case 'SE': // Stream End
+                    if (this.metadata.format.duration) {
+                        this.metadata.setFormat('bitrate', this.audioLength * 8 / this.metadata.format.duration);
+                    }
+                    return tryParseApeHeader(this.metadata, this.tokenizer, this.options);
+                default:
+                    throw new MusepackContentError(`Unexpected header: ${header.key}`);
+            }
+            // biome-ignore lint/correctness/noConstantCondition: break is handled in the switch statement
+        } while (true);
+    }
+}

package/node_modules/music-metadata/lib/musepack/sv8/StreamVersion8.d.ts

@@ -0,0 +1,42 @@
+import type { ITokenizer } from 'strtok3';
+export interface IPacketHeader {
+    key: string;
+    payloadLength: number;
+}
+/**
+ * Stream Header Packet
+ * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
+ */
+interface IStreamHeader1 {
+    crc: number;
+    streamVersion: number;
+}
+/**
+ * Stream Header Packet
+ * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
+ */
+interface IStreamHeader3 {
+    sampleFrequency: number;
+    maxUsedBands: number;
+    channelCount: number;
+    msUsed: boolean;
+    audioBlockFrames: number;
+}
+/**
+ * Stream Header Packet
+ * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
+ */
+interface IStreamHeader extends IStreamHeader1, IStreamHeader3 {
+    sampleCount: number;
+    beginningOfSilence: number;
+}
+export declare class StreamReader {
+    private _tokenizer;
+    get tokenizer(): ITokenizer;
+    set tokenizer(value: ITokenizer);
+    constructor(_tokenizer: ITokenizer);
+    readPacketHeader(): Promise<IPacketHeader>;
+    readStreamHeader(size: number): Promise<IStreamHeader>;
+    private readVariableSizeField;
+}
+export {};

package/node_modules/music-metadata/lib/musepack/sv8/StreamVersion8.js

@@ -0,0 +1,82 @@
+import * as Token from 'token-types';
+import initDebug from 'debug';
+import * as util from '../../common/Util.js';
+const debug = initDebug('music-metadata:parser:musepack:sv8');
+const PacketKey = new Token.StringType(2, 'latin1');
+/**
+ * Stream Header Packet part 1
+ * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
+ */
+const SH_part1 = {
+    len: 5,
+    get: (buf, off) => {
+        return {
+            crc: Token.UINT32_LE.get(buf, off),
+            streamVersion: Token.UINT8.get(buf, off + 4)
+        };
+    }
+};
+/**
+ * Stream Header Packet part 3
+ * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket
+ */
+const SH_part3 = {
+    len: 2,
+    get: (buf, off) => {
+        return {
+            sampleFrequency: [44100, 48000, 37800, 32000][util.getBitAllignedNumber(buf, off, 0, 3)],
+            maxUsedBands: util.getBitAllignedNumber(buf, off, 3, 5),
+            channelCount: util.getBitAllignedNumber(buf, off + 1, 0, 4) + 1,
+            msUsed: util.isBitSet(buf, off + 1, 4),
+            audioBlockFrames: util.getBitAllignedNumber(buf, off + 1, 5, 3)
+        };
+    }
+};
+export class StreamReader {
+    get tokenizer() {
+        return this._tokenizer;
+    }
+    set tokenizer(value) {
+        this._tokenizer = value;
+    }
+    constructor(_tokenizer) {
+        this._tokenizer = _tokenizer;
+    }
+    async readPacketHeader() {
+        const key = await this.tokenizer.readToken(PacketKey);
+        const size = await this.readVariableSizeField();
+        return {
+            key,
+            payloadLength: size.value - 2 - size.len
+        };
+    }
+    async readStreamHeader(size) {
+        const streamHeader = {};
+        debug(`Reading SH at offset=${this.tokenizer.position}`);
+        const part1 = await this.tokenizer.readToken(SH_part1);
+        size -= SH_part1.len;
+        Object.assign(streamHeader, part1);
+        debug(`SH.streamVersion = ${part1.streamVersion}`);
+        const sampleCount = await this.readVariableSizeField();
+        size -= sampleCount.len;
+        streamHeader.sampleCount = sampleCount.value;
+        const bs = await this.readVariableSizeField();
+        size -= bs.len;
+        streamHeader.beginningOfSilence = bs.value;
+        const part3 = await this.tokenizer.readToken(SH_part3);
+        size -= SH_part3.len;
+        Object.assign(streamHeader, part3);
+        // assert.equal(size, 0);
+        await this.tokenizer.ignore(size);
+        return streamHeader;
+    }
+    async readVariableSizeField(len = 1, hb = 0) {
+        let n = await this.tokenizer.readNumber(Token.UINT8);
+        if ((n & 0x80) === 0) {
+            return { len, value: hb + n };
+        }
+        n &= 0x7F;
+        n += hb;
+        return this.readVariableSizeField(len + 1, n << 7);
+    }
+}

package/node_modules/music-metadata/lib/ogg/OggLoader.d.ts

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

package/node_modules/music-metadata/lib/ogg/OggLoader.js

@@ -0,0 +1,8 @@
+export const oggParserLoader = {
+    parserType: 'ogg',
+    extensions: ['.ogg', '.ogv', '.oga', '.ogm', '.ogx', '.opus', '.spx'],
+    mimeTypes: ['audio/ogg', 'audio/opus', 'audio/speex', 'video/ogg'], // RFC 7845, RFC 6716, RFC 5574
+    async load() {
+        return (await import('./OggParser.js')).OggParser;
+    }
+};

package/node_modules/music-metadata/lib/ogg/OggParser.d.ts

@@ -0,0 +1,27 @@
+import { BasicParser } from '../common/BasicParser.js';
+declare const OggContentError_base: {
+    new (message: string): {
+        readonly fileType: string;
+        toString(): string;
+        name: "UnexpectedFileContentError";
+        message: string;
+        stack?: string;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+};
+export declare class OggContentError extends OggContentError_base {
+}
+/**
+ * Parser for Ogg logical bitstream framing
+ */
+export declare class OggParser extends BasicParser {
+    private streams;
+    /**
+     * Parse page
+     * @returns {Promise<void>}
+     */
+    parse(): Promise<void>;
+}
+export {};