valley-baileys 1.0.0

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

@@ -0,0 +1,17 @@
+import { CommonTagMapper } from './GenericTagMapper.js';
+export class CaseInsensitiveTagMap extends CommonTagMapper {
+    constructor(tagTypes, tagMap) {
+        const upperCaseMap = {};
+        for (const tag of Object.keys(tagMap)) {
+            upperCaseMap[tag.toUpperCase()] = tagMap[tag];
+        }
+        super(tagTypes, upperCaseMap);
+    }
+    /**
+     * @tag  Native header tag
+     * @return common tag name (alias)
+     */
+    getCommonName(tag) {
+        return this.tagMap[tag.toUpperCase()];
+    }
+}

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

@@ -0,0 +1,19 @@
+import type { IGenericTag, TagType } from './GenericTagTypes.js';
+import type { IGenericTagMapper } from './GenericTagMapper.js';
+import type { ITag } from '../type.js';
+import type { INativeMetadataCollector } from './MetadataCollector.js';
+export declare class CombinedTagMapper {
+    tagMappers: {
+        [index: string]: IGenericTagMapper;
+    };
+    constructor();
+    /**
+     * Convert native to generic (common) tags
+     * @param tagType Originating tag format
+     * @param tag     Native tag to map to a generic tag id
+     * @param warnings
+     * @return Generic tag result (output of this function)
+     */
+    mapTag(tagType: TagType, tag: ITag, warnings: INativeMetadataCollector): IGenericTag | null;
+    private registerTagMapper;
+}

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

@@ -0,0 +1,50 @@
+import { ID3v1TagMapper } from '../id3v1/ID3v1TagMap.js';
+import { ID3v24TagMapper } from '../id3v2/ID3v24TagMapper.js';
+import { AsfTagMapper } from '../asf/AsfTagMapper.js';
+import { ID3v22TagMapper } from '../id3v2/ID3v22TagMapper.js';
+import { APEv2TagMapper } from '../apev2/APEv2TagMapper.js';
+import { MP4TagMapper } from '../mp4/MP4TagMapper.js';
+import { VorbisTagMapper } from '../ogg/vorbis/VorbisTagMapper.js';
+import { RiffInfoTagMapper } from '../riff/RiffInfoTagMap.js';
+import { MatroskaTagMapper } from '../matroska/MatroskaTagMapper.js';
+import { AiffTagMapper } from '../aiff/AiffTagMap.js';
+import { InternalParserError } from '../ParseError.js';
+export class CombinedTagMapper {
+    constructor() {
+        this.tagMappers = {};
+        [
+            new ID3v1TagMapper(),
+            new ID3v22TagMapper(),
+            new ID3v24TagMapper(),
+            new MP4TagMapper(),
+            new MP4TagMapper(),
+            new VorbisTagMapper(),
+            new APEv2TagMapper(),
+            new AsfTagMapper(),
+            new RiffInfoTagMapper(),
+            new MatroskaTagMapper(),
+            new AiffTagMapper()
+        ].forEach(mapper => {
+            this.registerTagMapper(mapper);
+        });
+    }
+    /**
+     * Convert native to generic (common) tags
+     * @param tagType Originating tag format
+     * @param tag     Native tag to map to a generic tag id
+     * @param warnings
+     * @return Generic tag result (output of this function)
+     */
+    mapTag(tagType, tag, warnings) {
+        const tagMapper = this.tagMappers[tagType];
+        if (tagMapper) {
+            return this.tagMappers[tagType].mapGenericTag(tag, warnings);
+        }
+        throw new InternalParserError(`No generic tag mapper defined for tag-format: ${tagType}`);
+    }
+    registerTagMapper(genericTagMapper) {
+        for (const tagType of genericTagMapper.tagTypes) {
+            this.tagMappers[tagType] = genericTagMapper;
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { IToken } from 'strtok3';
+/**
+ * Token for read FourCC
+ * Ref: https://en.wikipedia.org/wiki/FourCC
+ */
+export declare const FourCcToken: IToken<string>;

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

@@ -0,0 +1,25 @@
+import { textDecode, textEncode } from '@borewit/text-codec';
+import * as util from './Util.js';
+import { InternalParserError, FieldDecodingError } from '../ParseError.js';
+const validFourCC = /^[\x21-\x7e©][\x20-\x7e\x00()]{3}/;
+/**
+ * Token for read FourCC
+ * Ref: https://en.wikipedia.org/wiki/FourCC
+ */
+export const FourCcToken = {
+    len: 4,
+    get: (buf, off) => {
+        const id = textDecode(buf.subarray(off, off + FourCcToken.len), 'latin1');
+        if (!id.match(validFourCC)) {
+            throw new FieldDecodingError(`FourCC contains invalid characters: ${util.a2hex(id)} "${id}"`);
+        }
+        return id;
+    },
+    put: (buffer, offset, id) => {
+        const str = textEncode(id, 'latin1');
+        if (str.length !== 4)
+            throw new InternalParserError('Invalid length');
+        buffer.set(str, offset);
+        return offset + 4;
+    }
+};

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

@@ -0,0 +1,51 @@
+import type * as generic from './GenericTagTypes.js';
+import type { ITag } from '../type.js';
+import type { INativeMetadataCollector, IWarningCollector } from './MetadataCollector.js';
+export interface IGenericTagMapper {
+    /**
+     * Which tagType is able to map to the generic mapping format
+     */
+    tagTypes: generic.TagType[];
+    /**
+     * Basic tag map
+     */
+    tagMap: generic.INativeTagMap;
+    /**
+     * Map native tag to generic tag
+     * @param tag       Native tag
+     * @param warnings  Register warnings
+     * @return Generic tag, if native tag could be mapped
+     */
+    mapGenericTag(tag: ITag, warnings: INativeMetadataCollector): generic.IGenericTag | null;
+}
+export declare class CommonTagMapper implements IGenericTagMapper {
+    static maxRatingScore: number;
+    static toIntOrNull(str: string): number | null;
+    static normalizeTrack(origVal: number | string): {
+        no: number | null;
+        of: number | null;
+    };
+    tagTypes: generic.TagType[];
+    tagMap: generic.INativeTagMap;
+    constructor(tagTypes: generic.TagType[], tagMap: generic.INativeTagMap);
+    /**
+     * Process and set common tags
+     * write common tags to
+     * @param tag Native tag
+     * @param warnings Register warnings
+     * @return common name
+     */
+    mapGenericTag(tag: ITag, warnings: IWarningCollector): generic.IGenericTag | null;
+    /**
+     * Convert native tag key to common tag key
+     * @param tag Native header tag
+     * @return common tag name (alias)
+     */
+    protected getCommonName(tag: string): generic.GenericTagId;
+    /**
+     * Handle post mapping exceptions / correction
+     * @param tag Tag e.g. {"©alb", "Buena Vista Social Club")
+     * @param warnings Used to register warnings
+     */
+    protected postMap(_tag: ITag, _warnings: IWarningCollector): void;
+}

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

@@ -0,0 +1,51 @@
+export class CommonTagMapper {
+    static toIntOrNull(str) {
+        const cleaned = Number.parseInt(str, 10);
+        return Number.isNaN(cleaned) ? null : cleaned;
+    }
+    // TODO: a string of 1of1 would fail to be converted
+    // converts 1/10 to no : 1, of : 10
+    // or 1 to no : 1, of : 0
+    static normalizeTrack(origVal) {
+        const split = origVal.toString().split('/');
+        return {
+            no: Number.parseInt(split[0], 10) || null,
+            of: Number.parseInt(split[1], 10) || null
+        };
+    }
+    constructor(tagTypes, tagMap) {
+        this.tagTypes = tagTypes;
+        this.tagMap = tagMap;
+    }
+    /**
+     * Process and set common tags
+     * write common tags to
+     * @param tag Native tag
+     * @param warnings Register warnings
+     * @return common name
+     */
+    mapGenericTag(tag, warnings) {
+        tag = { id: tag.id, value: tag.value }; // clone object
+        this.postMap(tag, warnings);
+        // Convert native tag event to generic 'alias' tag
+        const id = this.getCommonName(tag.id);
+        return id ? { id, value: tag.value } : null;
+    }
+    /**
+     * Convert native tag key to common tag key
+     * @param tag Native header tag
+     * @return common tag name (alias)
+     */
+    getCommonName(tag) {
+        return this.tagMap[tag];
+    }
+    /**
+     * Handle post mapping exceptions / correction
+     * @param tag Tag e.g. {"©alb", "Buena Vista Social Club")
+     * @param warnings Used to register warnings
+     */
+    postMap(_tag, _warnings) {
+        return;
+    }
+}
+CommonTagMapper.maxRatingScore = 1;

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

@@ -0,0 +1,34 @@
+import type { AnyTagValue, ICommonTagsResult } from '../type.js';
+export type TagType = 'vorbis' | 'ID3v1' | 'ID3v2.2' | 'ID3v2.3' | 'ID3v2.4' | 'APEv2' | 'asf' | 'iTunes' | 'exif' | 'matroska' | 'AIFF';
+export interface IGenericTag {
+    id: keyof ICommonTagsResult;
+    value: AnyTagValue;
+}
+export type GenericTagId = 'track' | 'disk' | 'year' | 'title' | 'artist' | 'artists' | 'albumartist' | 'albumartists' | 'album' | 'date' | 'originaldate' | 'originalyear' | 'releasedate' | 'comment' | 'genre' | 'picture' | 'composer' | 'lyrics' | 'albumsort' | 'titlesort' | 'work' | 'artistsort' | 'albumartistsort' | 'composersort' | 'lyricist' | 'writer' | 'conductor' | 'remixer' | 'arranger' | 'engineer' | 'technician' | 'producer' | 'djmixer' | 'mixer' | 'publisher' | 'label' | 'grouping' | 'subtitle' | 'discsubtitle' | 'totaltracks' | 'totaldiscs' | 'compilation' | 'rating' | 'bpm' | 'mood' | 'media' | 'catalognumber' | 'tvShow' | 'tvShowSort' | 'tvEpisode' | 'tvEpisodeId' | 'tvNetwork' | 'tvSeason' | 'podcast' | 'podcasturl' | 'releasestatus' | 'releasetype' | 'releasecountry' | 'script' | 'language' | 'copyright' | 'license' | 'encodedby' | 'encodersettings' | 'gapless' | 'barcode' | 'isrc' | 'asin' | 'musicbrainz_recordingid' | 'musicbrainz_trackid' | 'musicbrainz_albumid' | 'musicbrainz_artistid' | 'musicbrainz_albumartistid' | 'musicbrainz_releasegroupid' | 'musicbrainz_workid' | 'musicbrainz_trmid' | 'musicbrainz_discid' | 'acoustid_id' | 'acoustid_fingerprint' | 'musicip_puid' | 'musicip_fingerprint' | 'website' | 'performer:instrument' | 'peakLevel' | 'averageLevel' | 'notes' | 'key' | 'originalalbum' | 'originalartist' | 'discogs_artist_id' | 'discogs_label_id' | 'discogs_master_release_id' | 'discogs_rating' | 'discogs_release_id' | 'discogs_votes' | 'replaygain_track_gain' | 'replaygain_track_peak' | 'replaygain_album_gain' | 'replaygain_album_peak' | 'replaygain_track_minmax' | 'replaygain_album_minmax' | 'replaygain_undo' | 'description' | 'longDescription' | 'category' | 'hdVideo' | 'keywords' | 'movement' | 'movementIndex' | 'movementTotal' | 'podcastId' | 'showMovement' | 'stik' | 'playCounter';
+export interface INativeTagMap {
+    [index: string]: GenericTagId;
+}
+export interface ITagInfo {
+    /**
+     * True if result is an array
+     */
+    multiple: boolean;
+    /**
+     * True if the result is an array and each value in the array should be unique
+     */
+    unique?: boolean;
+}
+export interface ITagInfoMap {
+    [index: string]: ITagInfo;
+}
+export declare const commonTagsKeys: (keyof ICommonTagsResult)[];
+/**
+ * @param alias Name of common tag
+ * @returns {boolean|*} true if given alias is mapped as a singleton', otherwise false
+ */
+export declare function isSingleton(alias: keyof ICommonTagsResult): boolean;
+/**
+ * @param alias Common (generic) tag
+ * @returns {boolean|*} true if given alias is a singleton or explicitly marked as unique
+ */
+export declare function isUnique(alias: keyof ICommonTagsResult): boolean;

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

@@ -0,0 +1,133 @@
+const defaultTagInfo = {
+    multiple: false,
+};
+const commonTags = {
+    year: defaultTagInfo,
+    track: defaultTagInfo,
+    disk: defaultTagInfo,
+    title: defaultTagInfo,
+    artist: defaultTagInfo,
+    artists: { multiple: true, unique: true },
+    albumartist: defaultTagInfo,
+    albumartists: { multiple: true, unique: true },
+    album: defaultTagInfo,
+    date: defaultTagInfo,
+    originaldate: defaultTagInfo,
+    originalyear: defaultTagInfo,
+    releasedate: defaultTagInfo,
+    comment: { multiple: true, unique: false },
+    genre: { multiple: true, unique: true },
+    picture: { multiple: true, unique: true },
+    composer: { multiple: true, unique: true },
+    lyrics: { multiple: true, unique: false },
+    albumsort: { multiple: false, unique: true },
+    titlesort: { multiple: false, unique: true },
+    work: { multiple: false, unique: true },
+    artistsort: { multiple: false, unique: true },
+    albumartistsort: { multiple: false, unique: true },
+    composersort: { multiple: false, unique: true },
+    lyricist: { multiple: true, unique: true },
+    writer: { multiple: true, unique: true },
+    conductor: { multiple: true, unique: true },
+    remixer: { multiple: true, unique: true },
+    arranger: { multiple: true, unique: true },
+    engineer: { multiple: true, unique: true },
+    producer: { multiple: true, unique: true },
+    technician: { multiple: true, unique: true },
+    djmixer: { multiple: true, unique: true },
+    mixer: { multiple: true, unique: true },
+    label: { multiple: true, unique: true },
+    grouping: defaultTagInfo,
+    subtitle: { multiple: true },
+    discsubtitle: defaultTagInfo,
+    totaltracks: defaultTagInfo,
+    totaldiscs: defaultTagInfo,
+    compilation: defaultTagInfo,
+    rating: { multiple: true },
+    bpm: defaultTagInfo,
+    mood: defaultTagInfo,
+    media: defaultTagInfo,
+    catalognumber: { multiple: true, unique: true },
+    tvShow: defaultTagInfo,
+    tvShowSort: defaultTagInfo,
+    tvSeason: defaultTagInfo,
+    tvEpisode: defaultTagInfo,
+    tvEpisodeId: defaultTagInfo,
+    tvNetwork: defaultTagInfo,
+    podcast: defaultTagInfo,
+    podcasturl: defaultTagInfo,
+    releasestatus: defaultTagInfo,
+    releasetype: { multiple: true },
+    releasecountry: defaultTagInfo,
+    script: defaultTagInfo,
+    language: defaultTagInfo,
+    copyright: defaultTagInfo,
+    license: defaultTagInfo,
+    encodedby: defaultTagInfo,
+    encodersettings: defaultTagInfo,
+    gapless: defaultTagInfo,
+    barcode: defaultTagInfo,
+    isrc: { multiple: true },
+    asin: defaultTagInfo,
+    musicbrainz_recordingid: defaultTagInfo,
+    musicbrainz_trackid: defaultTagInfo,
+    musicbrainz_albumid: defaultTagInfo,
+    musicbrainz_artistid: { multiple: true },
+    musicbrainz_albumartistid: { multiple: true },
+    musicbrainz_releasegroupid: defaultTagInfo,
+    musicbrainz_workid: defaultTagInfo,
+    musicbrainz_trmid: defaultTagInfo,
+    musicbrainz_discid: defaultTagInfo,
+    acoustid_id: defaultTagInfo,
+    acoustid_fingerprint: defaultTagInfo,
+    musicip_puid: defaultTagInfo,
+    musicip_fingerprint: defaultTagInfo,
+    website: defaultTagInfo,
+    'performer:instrument': { multiple: true, unique: true },
+    averageLevel: defaultTagInfo,
+    peakLevel: defaultTagInfo,
+    notes: { multiple: true, unique: false },
+    key: defaultTagInfo,
+    originalalbum: defaultTagInfo,
+    originalartist: defaultTagInfo,
+    discogs_artist_id: { multiple: true, unique: true },
+    discogs_release_id: defaultTagInfo,
+    discogs_label_id: defaultTagInfo,
+    discogs_master_release_id: defaultTagInfo,
+    discogs_votes: defaultTagInfo,
+    discogs_rating: defaultTagInfo,
+    replaygain_track_peak: defaultTagInfo,
+    replaygain_track_gain: defaultTagInfo,
+    replaygain_album_peak: defaultTagInfo,
+    replaygain_album_gain: defaultTagInfo,
+    replaygain_track_minmax: defaultTagInfo,
+    replaygain_album_minmax: defaultTagInfo,
+    replaygain_undo: defaultTagInfo,
+    description: { multiple: true },
+    longDescription: defaultTagInfo,
+    category: { multiple: true },
+    hdVideo: defaultTagInfo,
+    keywords: { multiple: true },
+    movement: defaultTagInfo,
+    movementIndex: defaultTagInfo,
+    movementTotal: defaultTagInfo,
+    podcastId: defaultTagInfo,
+    showMovement: defaultTagInfo,
+    stik: defaultTagInfo,
+    playCounter: defaultTagInfo
+};
+export const commonTagsKeys = /* @__PURE__ */ Object.keys(commonTags);
+/**
+ * @param alias Name of common tag
+ * @returns {boolean|*} true if given alias is mapped as a singleton', otherwise false
+ */
+export function isSingleton(alias) {
+    return commonTags[alias] && !commonTags[alias].multiple;
+}
+/**
+ * @param alias Common (generic) tag
+ * @returns {boolean|*} true if given alias is a singleton or explicitly marked as unique
+ */
+export function isUnique(alias) {
+    return !commonTags[alias].multiple || commonTags[alias].unique || false;
+}

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

@@ -0,0 +1,86 @@
+import { type FormatId, type IAudioMetadata, type ICommonTagsResult, type IFormat, type INativeTags, type IOptions, type IQualityInformation, type ITrackInfo, type AnyTagValue } from '../type.js';
+import { type IGenericTag, type TagType } from './GenericTagTypes.js';
+/**
+ * Combines all generic-tag-mappers for each tag type
+ */
+export interface IWarningCollector {
+    /**
+     * Register parser warning
+     * @param warning
+     */
+    addWarning(warning: string): void;
+}
+export interface INativeMetadataCollector extends IWarningCollector {
+    /**
+     * Only use this for reading
+     */
+    readonly format: IFormat;
+    readonly native: INativeTags;
+    readonly quality: IQualityInformation;
+    /**
+     * @returns {boolean} true if one or more tags have been found
+     */
+    hasAny(): boolean;
+    setFormat(key: FormatId, value: AnyTagValue): void;
+    addTag(tagType: TagType, tagId: string, value: AnyTagValue): Promise<void>;
+    addStreamInfo(streamInfo: ITrackInfo): void;
+    setAudioOnly(): void;
+}
+/**
+ * Provided to the parser to uodate the metadata result.
+ * Responsible for triggering async updates
+ */
+export declare class MetadataCollector implements INativeMetadataCollector {
+    readonly format: IFormat;
+    readonly native: INativeTags;
+    readonly common: ICommonTagsResult;
+    readonly quality: IQualityInformation;
+    /**
+     * Keeps track of origin priority for each mapped id
+     */
+    private readonly commonOrigin;
+    /**
+     * Maps a tag type to a priority
+     */
+    private readonly originPriority;
+    private tagMapper;
+    private opts?;
+    constructor(opts?: IOptions);
+    /**
+     * @returns {boolean} true if one or more tags have been found
+     */
+    hasAny(): boolean;
+    addStreamInfo(streamInfo: ITrackInfo): void;
+    setFormat(key: FormatId, value: AnyTagValue): void;
+    setAudioOnly(): void;
+    addTag(tagType: TagType, tagId: string, value: AnyTagValue): Promise<void>;
+    addWarning(warning: string): void;
+    postMap(tagType: TagType | 'artificial', tag: IGenericTag): Promise<void>;
+    /**
+     * Convert native tags to common tags
+     * @returns {IAudioMetadata} Native + common tags
+     */
+    toCommonMetadata(): IAudioMetadata;
+    /**
+     * Handle singular artist tags (artist, albumartist) and cross-populate to plural form
+     */
+    private handleSingularArtistTag;
+    /**
+     * Handle plural artist tags (artists, albumartists) and cross-populate to singular form
+     */
+    private handlePluralArtistTag;
+    /**
+     * Fix some common issues with picture object
+     * @param picture Picture
+     */
+    private postFixPicture;
+    /**
+     * Convert native tag to common tags
+     */
+    private toCommon;
+    /**
+     * Set generic tag
+     */
+    private setGenericTag;
+}
+export declare function joinArtists(artists: string[]): string;