valley-baileys 1.0.0

package/node_modules/music-metadata/lib/asf/AsfObject.js

@@ -0,0 +1,347 @@
+// ASF Objects
+import * as Token from 'token-types';
+import * as util from '../common/Util.js';
+import AsfGuid from './AsfGuid.js';
+import { getParserForAttr, parseUnicodeAttr } from './AsfUtil.js';
+import { AttachedPictureType } from '../id3v2/ID3v2Token.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+export class AsfContentParseError extends makeUnexpectedFileContentError('ASF') {
+}
+/**
+ * Data Type: Specifies the type of information being stored. The following values are recognized.
+ */
+export const DataType = {
+    /**
+     * Unicode string. The data consists of a sequence of Unicode characters.
+     */
+    UnicodeString: 0,
+    /**
+     * BYTE array. The type of data is implementation-specific.
+     */
+    ByteArray: 1,
+    /**
+     * BOOL. The data is 2 bytes long and should be interpreted as a 16-bit unsigned integer. Only 0x0000 or 0x0001 are permitted values.
+     */
+    Bool: 2,
+    /**
+     * DWORD. The data is 4 bytes long and should be interpreted as a 32-bit unsigned integer.
+     */
+    DWord: 3,
+    /**
+     * QWORD. The data is 8 bytes long and should be interpreted as a 64-bit unsigned integer.
+     */
+    QWord: 4,
+    /**
+     * WORD. The data is 2 bytes long and should be interpreted as a 16-bit unsigned integer.
+     */
+    Word: 5
+};
+/**
+ * Token for: 3. ASF top-level Header Object
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3
+ */
+export const TopLevelHeaderObjectToken = {
+    len: 30,
+    get: (buf, off) => {
+        return {
+            objectId: AsfGuid.fromBin(buf, off),
+            objectSize: Number(Token.UINT64_LE.get(buf, off + 16)),
+            numberOfHeaderObjects: Token.UINT32_LE.get(buf, off + 24)
+            // Reserved: 2 bytes
+        };
+    }
+};
+/**
+ * Token for: 3.1 Header Object (mandatory, one only)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_1
+ */
+export const HeaderObjectToken = {
+    len: 24,
+    get: (buf, off) => {
+        return {
+            objectId: AsfGuid.fromBin(buf, off),
+            objectSize: Number(Token.UINT64_LE.get(buf, off + 16))
+        };
+    }
+};
+export class State {
+    constructor(header) {
+        this.len = Number(header.objectSize) - HeaderObjectToken.len;
+    }
+    postProcessTag(tags, name, valueType, data) {
+        if (name === 'WM/Picture') {
+            tags.push({ id: name, value: WmPictureToken.fromBuffer(data) });
+        }
+        else {
+            const parseAttr = getParserForAttr(valueType);
+            if (!parseAttr) {
+                throw new AsfContentParseError(`unexpected value headerType: ${valueType}`);
+            }
+            tags.push({ id: name, value: parseAttr(data) });
+        }
+    }
+}
+// ToDo: use ignore type
+export class IgnoreObjectState extends State {
+    get(_buf, _off) {
+        return null;
+    }
+}
+/**
+ * Token for: 3.2: File Properties Object (mandatory, one only)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_2
+ */
+export class FilePropertiesObject extends State {
+    get(buf, off) {
+        return {
+            fileId: AsfGuid.fromBin(buf, off),
+            fileSize: Token.UINT64_LE.get(buf, off + 16),
+            creationDate: Token.UINT64_LE.get(buf, off + 24),
+            dataPacketsCount: Token.UINT64_LE.get(buf, off + 32),
+            playDuration: Token.UINT64_LE.get(buf, off + 40),
+            sendDuration: Token.UINT64_LE.get(buf, off + 48),
+            preroll: Token.UINT64_LE.get(buf, off + 56),
+            flags: {
+                broadcast: util.getBit(buf, off + 64, 24),
+                seekable: util.getBit(buf, off + 64, 25)
+            },
+            // flagsNumeric: Token.UINT32_LE.get(buf, off + 64),
+            minimumDataPacketSize: Token.UINT32_LE.get(buf, off + 68),
+            maximumDataPacketSize: Token.UINT32_LE.get(buf, off + 72),
+            maximumBitrate: Token.UINT32_LE.get(buf, off + 76)
+        };
+    }
+}
+FilePropertiesObject.guid = AsfGuid.FilePropertiesObject;
+/**
+ * Token for: 3.3 Stream Properties Object (mandatory, one per stream)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_3
+ */
+export class StreamPropertiesObject extends State {
+    get(buf, off) {
+        return {
+            streamType: AsfGuid.decodeMediaType(AsfGuid.fromBin(buf, off)),
+            errorCorrectionType: AsfGuid.fromBin(buf, off + 8)
+            // ToDo
+        };
+    }
+}
+StreamPropertiesObject.guid = AsfGuid.StreamPropertiesObject;
+/**
+ * 3.4: Header Extension Object (mandatory, one only)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_4
+ */
+export class HeaderExtensionObject {
+    constructor() {
+        this.len = 22;
+    }
+    get(buf, off) {
+        const view = new DataView(buf.buffer, off);
+        return {
+            reserved1: AsfGuid.fromBin(buf, off),
+            reserved2: view.getUint16(16, true),
+            extensionDataSize: view.getUint16(18, true)
+        };
+    }
+}
+HeaderExtensionObject.guid = AsfGuid.HeaderExtensionObject;
+/**
+ * 3.5: The Codec List Object provides user-friendly information about the codecs and formats used to encode the content found in the ASF file.
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_5
+ */
+const CodecListObjectHeader = {
+    len: 20,
+    get: (buf, off) => {
+        const view = new DataView(buf.buffer, off);
+        return {
+            entryCount: view.getUint16(16, true)
+        };
+    }
+};
+async function readString(tokenizer) {
+    const length = await tokenizer.readNumber(Token.UINT16_LE);
+    return (await tokenizer.readToken(new Token.StringType(length * 2, 'utf-16le'))).replace('\0', '');
+}
+/**
+ * 3.5: Read the Codec-List-Object, which provides user-friendly information about the codecs and formats used to encode the content found in the ASF file.
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_5
+ */
+export async function readCodecEntries(tokenizer) {
+    const codecHeader = await tokenizer.readToken(CodecListObjectHeader);
+    const entries = [];
+    for (let i = 0; i < codecHeader.entryCount; ++i) {
+        entries.push(await readCodecEntry(tokenizer));
+    }
+    return entries;
+}
+async function readInformation(tokenizer) {
+    const length = await tokenizer.readNumber(Token.UINT16_LE);
+    const buf = new Uint8Array(length);
+    await tokenizer.readBuffer(buf);
+    return buf;
+}
+/**
+ * Read Codec-Entries
+ * @param tokenizer
+ */
+async function readCodecEntry(tokenizer) {
+    const type = await tokenizer.readNumber(Token.UINT16_LE);
+    return {
+        type: {
+            videoCodec: (type & 0x0001) === 0x0001,
+            audioCodec: (type & 0x0002) === 0x0002
+        },
+        codecName: await readString(tokenizer),
+        description: await readString(tokenizer),
+        information: await readInformation(tokenizer)
+    };
+}
+/**
+ * 3.10 Content Description Object (optional, one only)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_10
+ */
+export class ContentDescriptionObjectState extends State {
+    get(buf, off) {
+        const tags = [];
+        const view = new DataView(buf.buffer, off);
+        let pos = 10;
+        for (let i = 0; i < ContentDescriptionObjectState.contentDescTags.length; ++i) {
+            const length = view.getUint16(i * 2, true);
+            if (length > 0) {
+                const tagName = ContentDescriptionObjectState.contentDescTags[i];
+                const end = pos + length;
+                tags.push({ id: tagName, value: parseUnicodeAttr(buf.subarray(off + pos, off + end)) });
+                pos = end;
+            }
+        }
+        return tags;
+    }
+}
+ContentDescriptionObjectState.guid = AsfGuid.ContentDescriptionObject;
+ContentDescriptionObjectState.contentDescTags = ['Title', 'Author', 'Copyright', 'Description', 'Rating'];
+/**
+ * 3.11 Extended Content Description Object (optional, one only)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/03_asf_top_level_header_object.html#3_11
+ */
+export class ExtendedContentDescriptionObjectState extends State {
+    get(buf, off) {
+        const tags = [];
+        const view = new DataView(buf.buffer, off);
+        const attrCount = view.getUint16(0, true);
+        let pos = 2;
+        for (let i = 0; i < attrCount; i += 1) {
+            const nameLen = view.getUint16(pos, true);
+            pos += 2;
+            const name = parseUnicodeAttr(buf.subarray(off + pos, off + pos + nameLen));
+            pos += nameLen;
+            const valueType = view.getUint16(pos, true);
+            pos += 2;
+            const valueLen = view.getUint16(pos, true);
+            pos += 2;
+            const value = buf.subarray(off + pos, off + pos + valueLen);
+            pos += valueLen;
+            this.postProcessTag(tags, name, valueType, value);
+        }
+        return tags;
+    }
+}
+ExtendedContentDescriptionObjectState.guid = AsfGuid.ExtendedContentDescriptionObject;
+/**
+ * 4.1 Extended Stream Properties Object (optional, 1 per media stream)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/04_objects_in_the_asf_header_extension_object.html#4_1
+ */
+export class ExtendedStreamPropertiesObjectState extends State {
+    get(buf, off) {
+        const view = new DataView(buf.buffer, off);
+        return {
+            startTime: Token.UINT64_LE.get(buf, off),
+            endTime: Token.UINT64_LE.get(buf, off + 8),
+            dataBitrate: view.getInt32(12, true),
+            bufferSize: view.getInt32(16, true),
+            initialBufferFullness: view.getInt32(20, true),
+            alternateDataBitrate: view.getInt32(24, true),
+            alternateBufferSize: view.getInt32(28, true),
+            alternateInitialBufferFullness: view.getInt32(32, true),
+            maximumObjectSize: view.getInt32(36, true),
+            flags: {
+                reliableFlag: util.getBit(buf, off + 40, 0),
+                seekableFlag: util.getBit(buf, off + 40, 1),
+                resendLiveCleanpointsFlag: util.getBit(buf, off + 40, 2)
+            },
+            // flagsNumeric: Token.UINT32_LE.get(buf, off + 64),
+            streamNumber: view.getInt16(42, true),
+            streamLanguageId: view.getInt16(44, true),
+            averageTimePerFrame: view.getInt32(52, true),
+            streamNameCount: view.getInt32(54, true),
+            payloadExtensionSystems: view.getInt32(56, true),
+            streamNames: [], // ToDo
+            streamPropertiesObject: null
+        };
+    }
+}
+ExtendedStreamPropertiesObjectState.guid = AsfGuid.ExtendedStreamPropertiesObject;
+/**
+ * 4.7  Metadata Object (optional, 0 or 1)
+ * Ref: http://drang.s4.xrea.com/program/tips/id3tag/wmp/04_objects_in_the_asf_header_extension_object.html#4_7
+ */
+export class MetadataObjectState extends State {
+    get(uint8Array, off) {
+        const tags = [];
+        const view = new DataView(uint8Array.buffer, off);
+        const descriptionRecordsCount = view.getUint16(0, true);
+        let pos = 2;
+        for (let i = 0; i < descriptionRecordsCount; i += 1) {
+            pos += 4;
+            const nameLen = view.getUint16(pos, true);
+            pos += 2;
+            const dataType = view.getUint16(pos, true);
+            pos += 2;
+            const dataLen = view.getUint32(pos, true);
+            pos += 4;
+            const name = parseUnicodeAttr(uint8Array.subarray(off + pos, off + pos + nameLen));
+            pos += nameLen;
+            const data = uint8Array.subarray(off + pos, off + pos + dataLen);
+            pos += dataLen;
+            this.postProcessTag(tags, name, dataType, data);
+        }
+        return tags;
+    }
+}
+MetadataObjectState.guid = AsfGuid.MetadataObject;
+// 4.8	Metadata Library Object (optional, 0 or 1)
+export class MetadataLibraryObjectState extends MetadataObjectState {
+}
+MetadataLibraryObjectState.guid = AsfGuid.MetadataLibraryObject;
+/**
+ * Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/dd757977(v=vs.85).aspx
+ */
+export class WmPictureToken {
+    static fromBuffer(buffer) {
+        const pic = new WmPictureToken(buffer.length);
+        return pic.get(buffer, 0);
+    }
+    constructor(len) {
+        this.len = len;
+    }
+    get(buffer, offset) {
+        const view = new DataView(buffer.buffer, offset);
+        const typeId = view.getUint8(0);
+        const size = view.getInt32(1, true);
+        let index = 5;
+        while (view.getUint16(index) !== 0) {
+            index += 2;
+        }
+        const format = new Token.StringType(index - 5, 'utf-16le').get(buffer, 5);
+        while (view.getUint16(index) !== 0) {
+            index += 2;
+        }
+        const description = new Token.StringType(index - 5, 'utf-16le').get(buffer, 5);
+        return {
+            type: AttachedPictureType[typeId],
+            format,
+            description,
+            size,
+            data: buffer.slice(index + 4)
+        };
+    }
+}

package/node_modules/music-metadata/lib/asf/AsfParser.d.ts

@@ -0,0 +1,17 @@
+import { BasicParser } from '../common/BasicParser.js';
+/**
+ * Windows Media Metadata Usage Guidelines
+ * - Ref: https://msdn.microsoft.com/en-us/library/ms867702.aspx
+ *
+ * Ref:
+ * - https://tools.ietf.org/html/draft-fleischman-asf-01
+ * - https://hwiegman.home.xs4all.nl/fileformats/asf/ASF_Specification.pdf
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/index.html
+ * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
+ */
+export declare class AsfParser extends BasicParser {
+    parse(): Promise<void>;
+    private parseObjectHeader;
+    private addTags;
+    private parseExtensionObject;
+}

package/node_modules/music-metadata/lib/asf/AsfParser.js

@@ -0,0 +1,134 @@
+import initDebug from 'debug';
+import { TrackType } from '../type.js';
+import AsfGuid from './AsfGuid.js';
+import * as AsfObject from './AsfObject.js';
+import { BasicParser } from '../common/BasicParser.js';
+import { AsfContentParseError } from './AsfObject.js';
+const debug = initDebug('music-metadata:parser:ASF');
+const headerType = 'asf';
+/**
+ * Windows Media Metadata Usage Guidelines
+ * - Ref: https://msdn.microsoft.com/en-us/library/ms867702.aspx
+ *
+ * Ref:
+ * - https://tools.ietf.org/html/draft-fleischman-asf-01
+ * - https://hwiegman.home.xs4all.nl/fileformats/asf/ASF_Specification.pdf
+ * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/index.html
+ * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
+ */
+export class AsfParser extends BasicParser {
+    async parse() {
+        const header = await this.tokenizer.readToken(AsfObject.TopLevelHeaderObjectToken);
+        if (!header.objectId.equals(AsfGuid.HeaderObject)) {
+            throw new AsfContentParseError(`expected asf header; but was not found; got: ${header.objectId.str}`);
+        }
+        await this.parseObjectHeader(header.numberOfHeaderObjects);
+    }
+    async parseObjectHeader(numberOfObjectHeaders) {
+        let tags;
+        do {
+            // Parse common header of the ASF Object (3.1)
+            const header = await this.tokenizer.readToken(AsfObject.HeaderObjectToken);
+            // Parse data part of the ASF Object
+            debug('header GUID=%s', header.objectId.str);
+            switch (header.objectId.str) {
+                case AsfObject.FilePropertiesObject.guid.str: { // 3.2
+                    const fpo = await this.tokenizer.readToken(new AsfObject.FilePropertiesObject(header));
+                    this.metadata.setFormat('duration', Number(fpo.playDuration / BigInt(1000)) / 10000 - Number(fpo.preroll) / 1000);
+                    this.metadata.setFormat('bitrate', fpo.maximumBitrate);
+                    break;
+                }
+                case AsfObject.StreamPropertiesObject.guid.str: { // 3.3
+                    const spo = await this.tokenizer.readToken(new AsfObject.StreamPropertiesObject(header));
+                    this.metadata.setFormat('container', `ASF/${spo.streamType}`);
+                    break;
+                }
+                case AsfObject.HeaderExtensionObject.guid.str: { // 3.4
+                    const extHeader = await this.tokenizer.readToken(new AsfObject.HeaderExtensionObject());
+                    await this.parseExtensionObject(extHeader.extensionDataSize);
+                    break;
+                }
+                case AsfObject.ContentDescriptionObjectState.guid.str: // 3.10
+                    tags = await this.tokenizer.readToken(new AsfObject.ContentDescriptionObjectState(header));
+                    await this.addTags(tags);
+                    break;
+                case AsfObject.ExtendedContentDescriptionObjectState.guid.str: // 3.11
+                    tags = await this.tokenizer.readToken(new AsfObject.ExtendedContentDescriptionObjectState(header));
+                    await this.addTags(tags);
+                    break;
+                case AsfGuid.CodecListObject.str: {
+                    const codecs = await AsfObject.readCodecEntries(this.tokenizer);
+                    codecs.forEach(codec => {
+                        this.metadata.addStreamInfo({
+                            type: codec.type.videoCodec ? TrackType.video : TrackType.audio,
+                            codecName: codec.codecName
+                        });
+                    });
+                    const audioCodecs = codecs.filter(codec => codec.type.audioCodec).map(codec => codec.codecName).join('/');
+                    this.metadata.setFormat('codec', audioCodecs);
+                    break;
+                }
+                case AsfGuid.StreamBitratePropertiesObject.str:
+                    // ToDo?
+                    await this.tokenizer.ignore(header.objectSize - AsfObject.HeaderObjectToken.len);
+                    break;
+                case AsfGuid.PaddingObject.str:
+                    // ToDo: register bytes pad
+                    debug('Padding: %s bytes', header.objectSize - AsfObject.HeaderObjectToken.len);
+                    await this.tokenizer.ignore(header.objectSize - AsfObject.HeaderObjectToken.len);
+                    break;
+                default:
+                    this.metadata.addWarning(`Ignore ASF-Object-GUID: ${header.objectId.str}`);
+                    debug('Ignore ASF-Object-GUID: %s', header.objectId.str);
+                    await this.tokenizer.readToken(new AsfObject.IgnoreObjectState(header));
+            }
+        } while (--numberOfObjectHeaders);
+        // done
+    }
+    async addTags(tags) {
+        await Promise.all(tags.map(({ id, value }) => this.metadata.addTag(headerType, id, value)));
+    }
+    async parseExtensionObject(extensionSize) {
+        do {
+            // Parse common header of the ASF Object (3.1)
+            const header = await this.tokenizer.readToken(AsfObject.HeaderObjectToken);
+            const remaining = header.objectSize - AsfObject.HeaderObjectToken.len;
+            if (remaining < 0) {
+                throw new AsfContentParseError(`Invalid ASF header object size: ${header.objectSize}`);
+            }
+            // Parse data part of the ASF Object
+            switch (header.objectId.str) {
+                case AsfObject.ExtendedStreamPropertiesObjectState.guid.str: // 4.1
+                    // ToDo: extended stream header properties are ignored
+                    await this.tokenizer.readToken(new AsfObject.ExtendedStreamPropertiesObjectState(header));
+                    break;
+                case AsfObject.MetadataObjectState.guid.str: { // 4.7
+                    const moTags = await this.tokenizer.readToken(new AsfObject.MetadataObjectState(header));
+                    await this.addTags(moTags);
+                    break;
+                }
+                case AsfObject.MetadataLibraryObjectState.guid.str: { // 4.8
+                    const mlTags = await this.tokenizer.readToken(new AsfObject.MetadataLibraryObjectState(header));
+                    await this.addTags(mlTags);
+                    break;
+                }
+                case AsfGuid.PaddingObject.str:
+                    // ToDo: register bytes pad
+                    await this.tokenizer.ignore(remaining);
+                    break;
+                case AsfGuid.CompatibilityObject.str:
+                    await this.tokenizer.ignore(remaining);
+                    break;
+                case AsfGuid.ASF_Index_Placeholder_Object.str:
+                    await this.tokenizer.ignore(remaining);
+                    break;
+                default:
+                    this.metadata.addWarning(`Ignore ASF-Object-GUID: ${header.objectId.str}`);
+                    // console.log("Ignore ASF-Object-GUID: %s", header.objectId.str);
+                    await this.tokenizer.readToken(new AsfObject.IgnoreObjectState(header));
+                    break;
+            }
+            extensionSize -= header.objectSize;
+        } while (extensionSize > 0);
+    }
+}

package/node_modules/music-metadata/lib/asf/AsfTagMapper.d.ts

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

package/node_modules/music-metadata/lib/asf/AsfTagMapper.js

@@ -0,0 +1,92 @@
+import { CommonTagMapper } from '../common/GenericTagMapper.js';
+/**
+ * ASF Metadata tag mappings.
+ * See http://msdn.microsoft.com/en-us/library/ms867702.aspx
+ */
+const asfTagMap = {
+    Title: 'title',
+    Author: 'artist',
+    'WM/AlbumArtist': 'albumartist',
+    'WM/AlbumTitle': 'album',
+    'WM/Year': 'date', // changed to 'year' to 'date' based on Picard mappings; ToDo: check me
+    'WM/OriginalReleaseTime': 'originaldate',
+    'WM/OriginalReleaseYear': 'originalyear',
+    Description: 'comment',
+    'WM/TrackNumber': 'track',
+    'WM/PartOfSet': 'disk',
+    'WM/Genre': 'genre',
+    'WM/Composer': 'composer',
+    'WM/Lyrics': 'lyrics',
+    'WM/AlbumSortOrder': 'albumsort',
+    'WM/TitleSortOrder': 'titlesort',
+    'WM/ArtistSortOrder': 'artistsort',
+    'WM/AlbumArtistSortOrder': 'albumartistsort',
+    'WM/ComposerSortOrder': 'composersort',
+    'WM/Writer': 'lyricist',
+    'WM/Conductor': 'conductor',
+    'WM/ModifiedBy': 'remixer',
+    'WM/Engineer': 'engineer',
+    'WM/Producer': 'producer',
+    'WM/DJMixer': 'djmixer',
+    'WM/Mixer': 'mixer',
+    'WM/Publisher': 'label',
+    'WM/ContentGroupDescription': 'grouping',
+    'WM/SubTitle': 'subtitle',
+    'WM/SetSubTitle': 'discsubtitle',
+    // 'WM/PartOfSet': 'totaldiscs',
+    'WM/IsCompilation': 'compilation',
+    'WM/SharedUserRating': 'rating',
+    'WM/BeatsPerMinute': 'bpm',
+    'WM/Mood': 'mood',
+    'WM/Media': 'media',
+    'WM/CatalogNo': 'catalognumber',
+    'MusicBrainz/Album Status': 'releasestatus',
+    'MusicBrainz/Album Type': 'releasetype',
+    'MusicBrainz/Album Release Country': 'releasecountry',
+    'WM/Script': 'script',
+    'WM/Language': 'language',
+    Copyright: 'copyright',
+    LICENSE: 'license',
+    'WM/EncodedBy': 'encodedby',
+    'WM/EncodingSettings': 'encodersettings',
+    'WM/Barcode': 'barcode',
+    'WM/ISRC': 'isrc',
+    'MusicBrainz/Track Id': 'musicbrainz_recordingid',
+    'MusicBrainz/Release Track Id': 'musicbrainz_trackid',
+    'MusicBrainz/Album Id': 'musicbrainz_albumid',
+    'MusicBrainz/Artist Id': 'musicbrainz_artistid',
+    'MusicBrainz/Album Artist Id': 'musicbrainz_albumartistid',
+    'MusicBrainz/Release Group Id': 'musicbrainz_releasegroupid',
+    'MusicBrainz/Work Id': 'musicbrainz_workid',
+    'MusicBrainz/TRM Id': 'musicbrainz_trmid',
+    'MusicBrainz/Disc Id': 'musicbrainz_discid',
+    'Acoustid/Id': 'acoustid_id',
+    'Acoustid/Fingerprint': 'acoustid_fingerprint',
+    'MusicIP/PUID': 'musicip_puid',
+    'WM/ARTISTS': 'artists',
+    'WM/InitialKey': 'key',
+    ASIN: 'asin',
+    'WM/Work': 'work',
+    'WM/AuthorURL': 'website',
+    'WM/Picture': 'picture'
+};
+export class AsfTagMapper extends CommonTagMapper {
+    static toRating(rating) {
+        return {
+            rating: Number.parseFloat(rating + 1) / 5
+        };
+    }
+    constructor() {
+        super(['asf'], asfTagMap);
+    }
+    postMap(tag) {
+        switch (tag.id) {
+            case 'WM/SharedUserRating': {
+                const keys = tag.id.split(':');
+                tag.value = AsfTagMapper.toRating(tag.value);
+                tag.id = keys[0];
+                break;
+            }
+        }
+    }
+}

package/node_modules/music-metadata/lib/asf/AsfUtil.d.ts

@@ -0,0 +1,4 @@
+import type { DataType } from './AsfObject.js';
+export type AttributeParser = (buf: Uint8Array) => boolean | string | number | bigint | Uint8Array;
+export declare function getParserForAttr(i: DataType): AttributeParser;
+export declare function parseUnicodeAttr(uint8Array: Uint8Array): string;

package/node_modules/music-metadata/lib/asf/AsfUtil.js

@@ -0,0 +1,32 @@
+import * as Token from 'token-types';
+import * as util from '../common/Util.js';
+export function getParserForAttr(i) {
+    return attributeParsers[i];
+}
+export function parseUnicodeAttr(uint8Array) {
+    return util.stripNulls(util.decodeString(uint8Array, 'utf-16le'));
+}
+const attributeParsers = [
+    parseUnicodeAttr,
+    parseByteArrayAttr,
+    parseBoolAttr,
+    parseDWordAttr,
+    parseQWordAttr,
+    parseWordAttr,
+    parseByteArrayAttr
+];
+function parseByteArrayAttr(buf) {
+    return new Uint8Array(buf);
+}
+function parseBoolAttr(buf, offset = 0) {
+    return parseWordAttr(buf, offset) === 1;
+}
+function parseDWordAttr(buf, offset = 0) {
+    return Token.UINT32_LE.get(buf, offset);
+}
+function parseQWordAttr(buf, offset = 0) {
+    return Token.UINT64_LE.get(buf, offset);
+}
+function parseWordAttr(buf, offset = 0) {
+    return Token.UINT16_LE.get(buf, offset);
+}

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

@@ -0,0 +1,17 @@
+import type { ITokenizer } from 'strtok3';
+import type { ITokenParser } from '../ParserFactory.js';
+import type { IOptions } from '../type.js';
+import type { INativeMetadataCollector } from './MetadataCollector.js';
+export declare abstract class BasicParser implements ITokenParser {
+    protected readonly metadata: INativeMetadataCollector;
+    protected readonly tokenizer: ITokenizer;
+    protected readonly options: IOptions;
+    /**
+     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
+     * @param {INativeMetadataCollector} metadata Output
+     * @param {ITokenizer} tokenizer Input
+     * @param {IOptions} options Parsing options
+     */
+    constructor(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions);
+    abstract parse(): Promise<void>;
+}

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

@@ -0,0 +1,13 @@
+export class BasicParser {
+    /**
+     * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
+     * @param {INativeMetadataCollector} metadata Output
+     * @param {ITokenizer} tokenizer Input
+     * @param {IOptions} options Parsing options
+     */
+    constructor(metadata, tokenizer, options) {
+        this.metadata = metadata;
+        this.tokenizer = tokenizer;
+        this.options = options;
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { INativeTagMap, TagType } from './GenericTagTypes.js';
+import { CommonTagMapper } from './GenericTagMapper.js';
+export declare class CaseInsensitiveTagMap extends CommonTagMapper {
+    constructor(tagTypes: TagType[], tagMap: INativeTagMap);
+    /**
+     * @tag  Native header tag
+     * @return common tag name (alias)
+     */
+    protected getCommonName(tag: string): import("./GenericTagTypes.js").GenericTagId;
+}