valley-baileys 1.0.0

package/node_modules/music-metadata/lib/ogg/theora/Theora.js

@@ -0,0 +1,20 @@
+import * as Token from 'token-types';
+/**
+ * 6.2 Identification Header
+ * Ref: https://theora.org/doc/Theora.pdf: 6.2 Identification Header Decode
+ */
+export const IdentificationHeader = {
+    len: 42,
+    get: (buf, off) => {
+        return {
+            id: new Token.StringType(7, 'ascii').get(buf, off),
+            vmaj: Token.UINT8.get(buf, off + 7),
+            vmin: Token.UINT8.get(buf, off + 8),
+            vrev: Token.UINT8.get(buf, off + 9),
+            vmbw: Token.UINT16_BE.get(buf, off + 10),
+            vmbh: Token.UINT16_BE.get(buf, off + 17),
+            nombr: Token.UINT24_BE.get(buf, off + 37),
+            nqual: Token.UINT8.get(buf, off + 40)
+        };
+    }
+};

package/node_modules/music-metadata/lib/ogg/theora/TheoraStream.d.ts

@@ -0,0 +1,25 @@
+import type { ITokenizer } from 'strtok3';
+import type * as Ogg from '../OggToken.js';
+import type { IOptions } from '../../type.js';
+import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+/**
+ * Ref:
+ * - https://theora.org/doc/Theora.pdf
+ */
+export declare class TheoraStream implements Ogg.IPageConsumer {
+    private metadata;
+    durationOnLastPage: boolean;
+    constructor(metadata: INativeMetadataCollector, _options: IOptions, _tokenizer: ITokenizer);
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    parsePage(header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
+    calculateDuration(): void;
+    /**
+     * Parse first Theora Ogg page. the initial identification header packet
+     */
+    protected parseFirstPage(_header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
+    flush(): Promise<void>;
+}

package/node_modules/music-metadata/lib/ogg/theora/TheoraStream.js

@@ -0,0 +1,39 @@
+import initDebug from 'debug';
+import { IdentificationHeader } from './Theora.js';
+const debug = initDebug('music-metadata:parser:ogg:theora');
+/**
+ * Ref:
+ * - https://theora.org/doc/Theora.pdf
+ */
+export class TheoraStream {
+    constructor(metadata, _options, _tokenizer) {
+        this.durationOnLastPage = false;
+        this.metadata = metadata;
+    }
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    async parsePage(header, pageData) {
+        if (header.headerType.firstPage) {
+            await this.parseFirstPage(header, pageData);
+        }
+    }
+    calculateDuration() {
+        debug('duration calculation not implemented');
+    }
+    /**
+     * Parse first Theora Ogg page. the initial identification header packet
+     */
+    async parseFirstPage(_header, pageData) {
+        debug('First Ogg/Theora page');
+        this.metadata.setFormat('codec', 'Theora');
+        const idHeader = IdentificationHeader.get(pageData, 0);
+        this.metadata.setFormat('bitrate', idHeader.nombr);
+        this.metadata.setFormat('hasVideo', true);
+    }
+    flush() {
+        return Promise.resolve();
+    }
+}

package/node_modules/music-metadata/lib/ogg/vorbis/Vorbis.d.ts

@@ -0,0 +1,68 @@
+import type { IPicture } from '../../type.js';
+import type { IGetToken } from 'strtok3';
+/**
+ * Interface to parsed result of METADATA_BLOCK_PICTURE
+ * Ref: https://wiki.xiph.org/VorbisComment#METADATA_BLOCK_PICTURE
+ * Ref: https://xiph.org/flac/format.html#metadata_block_picture
+ */
+export interface IVorbisPicture extends IPicture {
+    type: string;
+    description: string;
+    width: number;
+    height: number;
+    colour_depth: number;
+    indexed_color: number;
+}
+/**
+ * Parse the METADATA_BLOCK_PICTURE
+ * Ref: https://wiki.xiph.org/VorbisComment#METADATA_BLOCK_PICTURE
+ * Ref: https://xiph.org/flac/format.html#metadata_block_picture
+ * // ToDo: move to ID3 / APIC?
+ */
+export declare class VorbisPictureToken implements IGetToken<IVorbisPicture> {
+    static fromBase64(base64str: string): IVorbisPicture;
+    static fromBuffer(buffer: Uint8Array): IVorbisPicture;
+    len: number;
+    constructor(len: number);
+    get(buffer: Uint8Array, offset: number): IVorbisPicture;
+}
+/**
+ * Vorbis 1 decoding tokens
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-620004.2.1
+ */
+/**
+ * Comment header interface
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-620004.2.1
+ */
+export interface ICommonHeader {
+    /**
+     * Packet Type
+     */
+    packetType: number;
+    /**
+     * Should be 'vorbis'
+     */
+    vorbis: string;
+}
+/**
+ * Comment header decoder
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-620004.2.1
+ */
+export declare const CommonHeader: IGetToken<ICommonHeader>;
+/**
+ * Identification header interface
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-630004.2.2
+ */
+export interface IFormatInfo {
+    version: number;
+    channelMode: number;
+    sampleRate: number;
+    bitrateMax: number;
+    bitrateNominal: number;
+    bitrateMin: number;
+}
+/**
+ * Identification header decoder
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-630004.2.2
+ */
+export declare const IdentificationHeader: IGetToken<IFormatInfo>;

package/node_modules/music-metadata/lib/ogg/vorbis/Vorbis.js

@@ -0,0 +1,83 @@
+import * as Token from 'token-types';
+import { AttachedPictureType } from '../../id3v2/ID3v2Token.js';
+/**
+ * Parse the METADATA_BLOCK_PICTURE
+ * Ref: https://wiki.xiph.org/VorbisComment#METADATA_BLOCK_PICTURE
+ * Ref: https://xiph.org/flac/format.html#metadata_block_picture
+ * // ToDo: move to ID3 / APIC?
+ */
+export class VorbisPictureToken {
+    static fromBase64(base64str) {
+        return VorbisPictureToken.fromBuffer(Uint8Array.from(atob(base64str), c => c.charCodeAt(0)));
+    }
+    static fromBuffer(buffer) {
+        const pic = new VorbisPictureToken(buffer.length);
+        return pic.get(buffer, 0);
+    }
+    constructor(len) {
+        this.len = len;
+    }
+    get(buffer, offset) {
+        const type = AttachedPictureType[Token.UINT32_BE.get(buffer, offset)];
+        offset += 4;
+        const mimeLen = Token.UINT32_BE.get(buffer, offset);
+        offset += 4;
+        const format = new Token.StringType(mimeLen, 'utf-8').get(buffer, offset);
+        offset += mimeLen;
+        const descLen = Token.UINT32_BE.get(buffer, offset);
+        offset += 4;
+        const description = new Token.StringType(descLen, 'utf-8').get(buffer, offset);
+        offset += descLen;
+        const width = Token.UINT32_BE.get(buffer, offset);
+        offset += 4;
+        const height = Token.UINT32_BE.get(buffer, offset);
+        offset += 4;
+        const colour_depth = Token.UINT32_BE.get(buffer, offset);
+        offset += 4;
+        const indexed_color = Token.UINT32_BE.get(buffer, offset);
+        offset += 4;
+        const picDataLen = Token.UINT32_BE.get(buffer, offset);
+        offset += 4;
+        const data = buffer.slice(offset, offset + picDataLen);
+        return {
+            type,
+            format,
+            description,
+            width,
+            height,
+            colour_depth,
+            indexed_color,
+            data
+        };
+    }
+}
+/**
+ * Comment header decoder
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-620004.2.1
+ */
+export const CommonHeader = {
+    len: 7,
+    get: (buf, off) => {
+        return {
+            packetType: Token.UINT8.get(buf, off),
+            vorbis: new Token.StringType(6, 'ascii').get(buf, off + 1)
+        };
+    }
+};
+/**
+ * Identification header decoder
+ * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-630004.2.2
+ */
+export const IdentificationHeader = {
+    len: 23,
+    get: (uint8Array, off) => {
+        return {
+            version: Token.UINT32_LE.get(uint8Array, off + 0),
+            channelMode: Token.UINT8.get(uint8Array, off + 4),
+            sampleRate: Token.UINT32_LE.get(uint8Array, off + 5),
+            bitrateMax: Token.UINT32_LE.get(uint8Array, off + 9),
+            bitrateNominal: Token.UINT32_LE.get(uint8Array, off + 13),
+            bitrateMin: Token.UINT32_LE.get(uint8Array, off + 17)
+        };
+    }
+};

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisDecoder.d.ts

@@ -0,0 +1,12 @@
+export declare class VorbisDecoder {
+    private readonly data;
+    private offset;
+    constructor(data: Uint8Array, offset: number);
+    readInt32(): number;
+    readStringUtf8(): string;
+    parseUserComment(): {
+        key: string;
+        value: string;
+        len: number;
+    };
+}

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisDecoder.js

@@ -0,0 +1,29 @@
+import * as Token from 'token-types';
+import { textDecode } from '@borewit/text-codec';
+export class VorbisDecoder {
+    constructor(data, offset) {
+        this.data = data;
+        this.offset = offset;
+    }
+    readInt32() {
+        const value = Token.UINT32_LE.get(this.data, this.offset);
+        this.offset += 4;
+        return value;
+    }
+    readStringUtf8() {
+        const len = this.readInt32();
+        const value = textDecode(this.data.subarray(this.offset, this.offset + len), 'utf-8');
+        this.offset += len;
+        return value;
+    }
+    parseUserComment() {
+        const offset0 = this.offset;
+        const v = this.readStringUtf8();
+        const idx = v.indexOf('=');
+        return {
+            key: v.substring(0, idx).toUpperCase(),
+            value: v.substring(idx + 1),
+            len: this.offset - offset0
+        };
+    }
+}

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisStream.d.ts

@@ -0,0 +1,53 @@
+import { type IVorbisPicture } from './Vorbis.js';
+import type { IPageConsumer, IPageHeader } from '../OggToken.js';
+import type { IOptions } from '../../type.js';
+import type { INativeMetadataCollector } from '../../common/MetadataCollector.js';
+declare const VorbisContentError_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 VorbisContentError extends VorbisContentError_base {
+}
+/**
+ * Vorbis 1 Parser.
+ * Used by OggStream
+ */
+export declare class VorbisStream implements IPageConsumer {
+    private pageSegments;
+    protected metadata: INativeMetadataCollector;
+    protected options: IOptions;
+    protected lastPageHeader?: IPageHeader;
+    durationOnLastPage: boolean;
+    constructor(metadata: INativeMetadataCollector, options: IOptions);
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    parsePage(header: IPageHeader, pageData: Uint8Array): Promise<void>;
+    private static mergeUint8Arrays;
+    flush(): Promise<void>;
+    parseUserComment(pageData: Uint8Array, offset: number): Promise<number>;
+    addTag(id: string, value: string | IVorbisPicture): Promise<void>;
+    calculateDuration(enfOfStream: boolean): void;
+    /**
+     * Parse first Ogg/Vorbis page
+     * @param _header
+     * @param pageData
+     */
+    protected parseFirstPage(_header: IPageHeader, pageData: Uint8Array): void;
+    protected parseFullPage(pageData: Uint8Array): Promise<void>;
+    /**
+     * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-840005.2
+     */
+    protected parseUserCommentList(pageData: Uint8Array, offset: number): Promise<void>;
+}
+export {};

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisStream.js

@@ -0,0 +1,136 @@
+import * as Token from 'token-types';
+import debugInit from 'debug';
+import { VorbisDecoder } from './VorbisDecoder.js';
+import { CommonHeader, IdentificationHeader, VorbisPictureToken } from './Vorbis.js';
+import { makeUnexpectedFileContentError } from '../../ParseError.js';
+const debug = debugInit('music-metadata:parser:ogg:vorbis1');
+export class VorbisContentError extends makeUnexpectedFileContentError('Vorbis') {
+}
+/**
+ * Vorbis 1 Parser.
+ * Used by OggStream
+ */
+export class VorbisStream {
+    constructor(metadata, options) {
+        this.pageSegments = [];
+        this.durationOnLastPage = true;
+        this.metadata = metadata;
+        this.options = options;
+    }
+    /**
+     * Vorbis 1 parser
+     * @param header Ogg Page Header
+     * @param pageData Page data
+     */
+    async parsePage(header, pageData) {
+        this.lastPageHeader = header;
+        if (header.headerType.firstPage) {
+            this.parseFirstPage(header, pageData);
+        }
+        else {
+            if (header.headerType.continued) {
+                if (this.pageSegments.length === 0) {
+                    throw new VorbisContentError('Cannot continue on previous page');
+                }
+                this.pageSegments.push(pageData);
+            }
+            if (header.headerType.lastPage || !header.headerType.continued) {
+                // Flush page segments
+                if (this.pageSegments.length > 0) {
+                    const fullPage = VorbisStream.mergeUint8Arrays(this.pageSegments);
+                    await this.parseFullPage(fullPage);
+                }
+                // Reset page segments
+                this.pageSegments = header.headerType.lastPage ? [] : [pageData];
+            }
+        }
+    }
+    static mergeUint8Arrays(arrays) {
+        const totalSize = arrays.reduce((acc, e) => acc + e.length, 0);
+        const merged = new Uint8Array(totalSize);
+        arrays.forEach((array, i, _arrays) => {
+            const offset = _arrays.slice(0, i).reduce((acc, e) => acc + e.length, 0);
+            merged.set(array, offset);
+        });
+        return merged;
+    }
+    async flush() {
+        await this.parseFullPage(VorbisStream.mergeUint8Arrays(this.pageSegments));
+    }
+    async parseUserComment(pageData, offset) {
+        const decoder = new VorbisDecoder(pageData, offset);
+        const tag = decoder.parseUserComment();
+        await this.addTag(tag.key, tag.value);
+        return tag.len;
+    }
+    async addTag(id, value) {
+        if (id === 'METADATA_BLOCK_PICTURE' && (typeof value === 'string')) {
+            if (this.options.skipCovers) {
+                debug("Ignore picture");
+                return;
+            }
+            value = VorbisPictureToken.fromBase64(value);
+            debug(`Push picture: id=${id}, format=${value.format}`);
+        }
+        else {
+            debug(`Push tag: id=${id}, value=${value}`);
+        }
+        await this.metadata.addTag('vorbis', id, value);
+    }
+    calculateDuration(enfOfStream) {
+        if (this.lastPageHeader && (enfOfStream || this.lastPageHeader.headerType.lastPage) && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
+            // Calculate duration
+            this.metadata.setFormat('numberOfSamples', this.lastPageHeader.absoluteGranulePosition);
+            this.metadata.setFormat('duration', this.lastPageHeader.absoluteGranulePosition / this.metadata.format.sampleRate);
+        }
+    }
+    /**
+     * Parse first Ogg/Vorbis page
+     * @param _header
+     * @param pageData
+     */
+    parseFirstPage(_header, pageData) {
+        this.metadata.setFormat('codec', 'Vorbis I');
+        this.metadata.setFormat('hasAudio', true);
+        debug('Parse first page');
+        // Parse  Vorbis common header
+        const commonHeader = CommonHeader.get(pageData, 0);
+        if (commonHeader.vorbis !== 'vorbis')
+            throw new VorbisContentError('Metadata does not look like Vorbis');
+        if (commonHeader.packetType === 1) {
+            const idHeader = IdentificationHeader.get(pageData, CommonHeader.len);
+            this.metadata.setFormat('sampleRate', idHeader.sampleRate);
+            this.metadata.setFormat('bitrate', idHeader.bitrateNominal);
+            this.metadata.setFormat('numberOfChannels', idHeader.channelMode);
+            debug('sample-rate=%s[hz], bitrate=%s[b/s], channel-mode=%s', idHeader.sampleRate, idHeader.bitrateNominal, idHeader.channelMode);
+        }
+        else
+            throw new VorbisContentError('First Ogg page should be type 1: the identification header');
+    }
+    async parseFullPage(pageData) {
+        // New page
+        const commonHeader = CommonHeader.get(pageData, 0);
+        debug('Parse full page: type=%s, byteLength=%s', commonHeader.packetType, pageData.byteLength);
+        switch (commonHeader.packetType) {
+            case 3: //  type 3: comment header
+                return this.parseUserCommentList(pageData, CommonHeader.len);
+            case 1: // type 1: the identification header
+            case 5: // type 5: setup header type
+                break; // ignore
+        }
+    }
+    /**
+     * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-840005.2
+     */
+    async parseUserCommentList(pageData, offset) {
+        const strLen = Token.UINT32_LE.get(pageData, offset);
+        offset += 4;
+        // const vendorString = new Token.StringType(strLen, 'utf-8').get(pageData, offset);
+        offset += strLen;
+        let userCommentListLength = Token.UINT32_LE.get(pageData, offset);
+        offset += 4;
+        while (userCommentListLength-- > 0) {
+            offset += (await this.parseUserComment(pageData, offset));
+        }
+    }
+}

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisTagMapper.d.ts

@@ -0,0 +1,7 @@
+import { CommonTagMapper } from '../../common/GenericTagMapper.js';
+import type { IRating, ITag } from '../../type.js';
+export declare class VorbisTagMapper extends CommonTagMapper {
+    static toRating(email: string | undefined | null, rating: string, maxScore: number): IRating;
+    constructor();
+    protected postMap(tag: ITag): void;
+}

package/node_modules/music-metadata/lib/ogg/vorbis/VorbisTagMapper.js

@@ -0,0 +1,133 @@
+import { CommonTagMapper } from '../../common/GenericTagMapper.js';
+/**
+ * Vorbis tag mappings
+ *
+ * Mapping from native header format to one or possibly more 'common' entries
+ * The common entries aim to read the same information from different media files
+ * independent of the underlying format
+ */
+const vorbisTagMap = {
+    TITLE: 'title',
+    ARTIST: 'artist',
+    ARTISTS: 'artists',
+    ALBUMARTIST: 'albumartist',
+    'ALBUM ARTIST': 'albumartist',
+    ALBUM: 'album',
+    DATE: 'date',
+    ORIGINALDATE: 'originaldate',
+    ORIGINALYEAR: 'originalyear',
+    RELEASEDATE: 'releasedate',
+    COMMENT: 'comment',
+    TRACKNUMBER: 'track',
+    DISCNUMBER: 'disk',
+    GENRE: 'genre',
+    METADATA_BLOCK_PICTURE: 'picture',
+    COMPOSER: 'composer',
+    LYRICS: 'lyrics',
+    ALBUMSORT: 'albumsort',
+    TITLESORT: 'titlesort',
+    WORK: 'work',
+    ARTISTSORT: 'artistsort',
+    ALBUMARTISTSORT: 'albumartistsort',
+    COMPOSERSORT: 'composersort',
+    LYRICIST: 'lyricist',
+    WRITER: 'writer',
+    CONDUCTOR: 'conductor',
+    // 'PERFORMER=artist (instrument)': 'performer:instrument', // ToDo
+    REMIXER: 'remixer',
+    ARRANGER: 'arranger',
+    ENGINEER: 'engineer',
+    PRODUCER: 'producer',
+    DJMIXER: 'djmixer',
+    MIXER: 'mixer',
+    LABEL: 'label',
+    GROUPING: 'grouping',
+    SUBTITLE: 'subtitle',
+    DISCSUBTITLE: 'discsubtitle',
+    TRACKTOTAL: 'totaltracks',
+    DISCTOTAL: 'totaldiscs',
+    COMPILATION: 'compilation',
+    RATING: 'rating',
+    BPM: 'bpm',
+    KEY: 'key',
+    MOOD: 'mood',
+    MEDIA: 'media',
+    CATALOGNUMBER: 'catalognumber',
+    RELEASESTATUS: 'releasestatus',
+    RELEASETYPE: 'releasetype',
+    RELEASECOUNTRY: 'releasecountry',
+    SCRIPT: 'script',
+    LANGUAGE: 'language',
+    COPYRIGHT: 'copyright',
+    LICENSE: 'license',
+    ENCODEDBY: 'encodedby',
+    ENCODERSETTINGS: 'encodersettings',
+    BARCODE: 'barcode',
+    ISRC: 'isrc',
+    ASIN: 'asin',
+    MUSICBRAINZ_TRACKID: 'musicbrainz_recordingid',
+    MUSICBRAINZ_RELEASETRACKID: 'musicbrainz_trackid',
+    MUSICBRAINZ_ALBUMID: 'musicbrainz_albumid',
+    MUSICBRAINZ_ARTISTID: 'musicbrainz_artistid',
+    MUSICBRAINZ_ALBUMARTISTID: 'musicbrainz_albumartistid',
+    MUSICBRAINZ_RELEASEGROUPID: 'musicbrainz_releasegroupid',
+    MUSICBRAINZ_WORKID: 'musicbrainz_workid',
+    MUSICBRAINZ_TRMID: 'musicbrainz_trmid',
+    MUSICBRAINZ_DISCID: 'musicbrainz_discid',
+    ACOUSTID_ID: 'acoustid_id',
+    ACOUSTID_ID_FINGERPRINT: 'acoustid_fingerprint',
+    MUSICIP_PUID: 'musicip_puid',
+    // 'FINGERPRINT=MusicMagic Fingerprint {fingerprint}': 'musicip_fingerprint', // ToDo
+    WEBSITE: 'website',
+    NOTES: 'notes',
+    TOTALTRACKS: 'totaltracks',
+    TOTALDISCS: 'totaldiscs',
+    // Discogs
+    DISCOGS_ARTIST_ID: 'discogs_artist_id',
+    DISCOGS_ARTISTS: 'artists',
+    DISCOGS_ARTIST_NAME: 'artists',
+    DISCOGS_ALBUM_ARTISTS: 'albumartist',
+    DISCOGS_CATALOG: 'catalognumber',
+    DISCOGS_COUNTRY: 'releasecountry',
+    DISCOGS_DATE: 'originaldate',
+    DISCOGS_LABEL: 'label',
+    DISCOGS_LABEL_ID: 'discogs_label_id',
+    DISCOGS_MASTER_RELEASE_ID: 'discogs_master_release_id',
+    DISCOGS_RATING: 'discogs_rating',
+    DISCOGS_RELEASED: 'date',
+    DISCOGS_RELEASE_ID: 'discogs_release_id',
+    DISCOGS_VOTES: 'discogs_votes',
+    CATALOGID: 'catalognumber',
+    STYLE: 'genre',
+    //
+    REPLAYGAIN_TRACK_GAIN: 'replaygain_track_gain',
+    REPLAYGAIN_TRACK_PEAK: 'replaygain_track_peak',
+    REPLAYGAIN_ALBUM_GAIN: 'replaygain_album_gain',
+    REPLAYGAIN_ALBUM_PEAK: 'replaygain_album_peak',
+    // To Sure if these (REPLAYGAIN_MINMAX, REPLAYGAIN_ALBUM_MINMAX & REPLAYGAIN_UNDO) are used for Vorbis:
+    REPLAYGAIN_MINMAX: 'replaygain_track_minmax',
+    REPLAYGAIN_ALBUM_MINMAX: 'replaygain_album_minmax',
+    REPLAYGAIN_UNDO: 'replaygain_undo'
+};
+export class VorbisTagMapper extends CommonTagMapper {
+    static toRating(email, rating, maxScore) {
+        return {
+            source: email ? email.toLowerCase() : undefined,
+            rating: (Number.parseFloat(rating) / maxScore) * CommonTagMapper.maxRatingScore
+        };
+    }
+    constructor() {
+        super(['vorbis'], vorbisTagMap);
+    }
+    postMap(tag) {
+        if (tag.id === 'RATING') {
+            // The way Winamp 5.666 assigns rating
+            tag.value = VorbisTagMapper.toRating(undefined, tag.value, 100);
+        }
+        else if (tag.id.indexOf('RATING:') === 0) {
+            const keys = tag.id.split(':');
+            tag.value = VorbisTagMapper.toRating(keys[1], tag.value, 1);
+            tag.id = keys[0];
+        }
+    }
+}

package/node_modules/music-metadata/lib/riff/RiffChunk.d.ts

@@ -0,0 +1,16 @@
+import type { IGetToken } from 'strtok3';
+import type { IChunkHeader } from '../iff/index.js';
+export type { IChunkHeader } from '../iff/index.js';
+/**
+ * Common RIFF chunk header
+ */
+export declare const Header: IGetToken<IChunkHeader>;
+/**
+ * Token to parse RIFF-INFO tag value
+ */
+export declare class ListInfoTagValue implements IGetToken<string> {
+    len: number;
+    private tagHeader;
+    constructor(tagHeader: IChunkHeader);
+    get(buf: Uint8Array, off: number): string;
+}

package/node_modules/music-metadata/lib/riff/RiffChunk.js

@@ -0,0 +1,28 @@
+import * as Token from 'token-types';
+/**
+ * Common RIFF chunk header
+ */
+export const Header = {
+    len: 8,
+    get: (buf, off) => {
+        return {
+            // Group-ID
+            chunkID: new Token.StringType(4, 'latin1').get(buf, off),
+            // Size
+            chunkSize: Token.UINT32_LE.get(buf, off + 4)
+        };
+    }
+};
+/**
+ * Token to parse RIFF-INFO tag value
+ */
+export class ListInfoTagValue {
+    constructor(tagHeader) {
+        this.tagHeader = tagHeader;
+        this.len = tagHeader.chunkSize;
+        this.len += this.len & 1; // if it is an odd length, round up to even
+    }
+    get(buf, off) {
+        return new Token.StringType(this.tagHeader.chunkSize, 'ascii').get(buf, off);
+    }
+}

package/node_modules/music-metadata/lib/riff/RiffInfoTagMap.d.ts

@@ -0,0 +1,10 @@
+import type { INativeTagMap } from '../common/GenericTagTypes.js';
+import { CommonTagMapper } from '../common/GenericTagMapper.js';
+/**
+ * RIFF Info Tags; part of the EXIF 2.3
+ * Ref: http://owl.phy.queensu.ca/~phil/exiftool/TagNames/RIFF.html#Info
+ */
+export declare const riffInfoTagMap: INativeTagMap;
+export declare class RiffInfoTagMapper extends CommonTagMapper {
+    constructor();
+}