music-metadata 8.2.0 → 9.0.0

package/lib/asf/AsfObject.d.ts

@@ -1,6 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-import { IGetToken, ITokenizer } from 'strtok3/core';
-import { Buffer } from 'node:buffer';
+import type { IGetToken, ITokenizer } from 'strtok3';
 import { IPicture, ITag } from '../type.js';
 import GUID from './GUID.js';
 /**
@@ -56,21 +54,21 @@ export interface IAsfTopLevelObjectHeader extends IAsfObjectHeader {
  * 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 declare const TopLevelHeaderObjectToken: IGetToken<IAsfTopLevelObjectHeader, Buffer>;
+export declare const TopLevelHeaderObjectToken: IGetToken<IAsfTopLevelObjectHeader, Uint8Array>;
 /**
  * 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 declare const HeaderObjectToken: IGetToken<IAsfObjectHeader, Buffer>;
+export declare const HeaderObjectToken: IGetToken<IAsfObjectHeader, Uint8Array>;
 export declare abstract class State<T> implements IGetToken<T> {
     len: number;
     constructor(header: IAsfObjectHeader);
-    abstract get(buf: Buffer, off: number): T;
+    abstract get(buf: Uint8Array, off: number): T;
     protected postProcessTag(tags: ITag[], name: string, valueType: number, data: any): void;
 }
 export declare class IgnoreObjectState extends State<any> {
     constructor(header: IAsfObjectHeader);
-    get(buf: Buffer, off: number): null;
+    get(buf: Uint8Array, off: number): null;
 }
 /**
  * Interface for: 3.2: File Properties Object (mandatory, one only)
@@ -176,7 +174,7 @@ export interface IFilePropertiesObject {
 export declare class FilePropertiesObject extends State<IFilePropertiesObject> {
     static guid: GUID;
     constructor(header: IAsfObjectHeader);
-    get(buf: Buffer, off: number): IFilePropertiesObject;
+    get(buf: Uint8Array, off: number): IFilePropertiesObject;
 }
 /**
  * Interface for: 3.3 Stream Properties Object (mandatory, one per stream)
@@ -198,7 +196,7 @@ export interface IStreamPropertiesObject {
 export declare class StreamPropertiesObject extends State<IStreamPropertiesObject> {
     static guid: GUID;
     constructor(header: IAsfObjectHeader);
-    get(buf: Buffer, off: number): IStreamPropertiesObject;
+    get(buf: Uint8Array, off: number): IStreamPropertiesObject;
 }
 export interface IHeaderExtensionObject {
     reserved1: GUID;
@@ -213,7 +211,7 @@ export declare class HeaderExtensionObject implements IGetToken<IHeaderExtension
     static guid: GUID;
     len: number;
     constructor();
-    get(buf: Buffer, off: number): IHeaderExtensionObject;
+    get(buf: Uint8Array, off: number): IHeaderExtensionObject;
 }
 export interface ICodecEntry {
     type: {
@@ -222,7 +220,7 @@ export interface ICodecEntry {
     };
     codecName: string;
     description: string;
-    information: Buffer;
+    information: Uint8Array;
 }
 /**
  * 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.
@@ -237,7 +235,7 @@ export declare class ContentDescriptionObjectState extends State<ITag[]> {
     static guid: GUID;
     private static contentDescTags;
     constructor(header: IAsfObjectHeader);
-    get(buf: Buffer, off: number): ITag[];
+    get(buf: Uint8Array, off: number): ITag[];
 }
 /**
  * 3.11 Extended Content Description Object (optional, one only)
@@ -246,7 +244,7 @@ export declare class ContentDescriptionObjectState extends State<ITag[]> {
 export declare class ExtendedContentDescriptionObjectState extends State<ITag[]> {
     static guid: GUID;
     constructor(header: IAsfObjectHeader);
-    get(buf: Buffer, off: number): ITag[];
+    get(buf: Uint8Array, off: number): ITag[];
 }
 export interface IStreamName {
     streamLanguageId: number;
@@ -286,7 +284,7 @@ export interface IExtendedStreamPropertiesObject {
 export declare class ExtendedStreamPropertiesObjectState extends State<IExtendedStreamPropertiesObject> {
     static guid: GUID;
     constructor(header: IAsfObjectHeader);
-    get(buf: Buffer, off: number): IExtendedStreamPropertiesObject;
+    get(buf: Uint8Array, off: number): IExtendedStreamPropertiesObject;
 }
 /**
  * 4.7  Metadata Object (optional, 0 or 1)
@@ -306,7 +304,7 @@ export interface IWmPicture extends IPicture {
     format: string;
     description: string;
     size: number;
-    data: Buffer;
+    data: Uint8Array;
 }
 /**
  * Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/dd757977(v=vs.85).aspx
@@ -314,7 +312,7 @@ export interface IWmPicture extends IPicture {
 export declare class WmPictureToken implements IGetToken<IWmPicture> {
     len: any;
     static fromBase64(base64str: string): IPicture;
-    static fromBuffer(buffer: Buffer): IWmPicture;
+    static fromBuffer(buffer: Uint8Array): IWmPicture;
     constructor(len: any);
-    get(buffer: Buffer, offset: number): IWmPicture;
+    get(buffer: Uint8Array, offset: number): IWmPicture;
 }

package/lib/asf/AsfObject.js

@@ -1,10 +1,10 @@
 // ASF Objects
 import * as Token from 'token-types';
-import { Buffer } from 'node:buffer';
 import * as util from '../common/Util.js';
 import GUID from './GUID.js';
 import { AsfUtil } from './AsfUtil.js';
 import { AttachedPictureType } from '../id3v2/ID3v2Token.js';
+import { base64ToUint8Array } from 'uint8array-extras';
 /**
  * Data Type: Specifies the type of information being stored. The following values are recognized.
  */
@@ -43,7 +43,7 @@ export const TopLevelHeaderObjectToken = {
     len: 30,
     get: (buf, off) => {
         return {
-            objectId: GUID.fromBin(new Token.BufferType(16).get(buf, off)),
+            objectId: GUID.fromBin(buf, off),
             objectSize: Number(Token.UINT64_LE.get(buf, off + 16)),
             numberOfHeaderObjects: Token.UINT32_LE.get(buf, off + 24)
             // Reserved: 2 bytes
@@ -58,7 +58,7 @@ export const HeaderObjectToken = {
     len: 24,
     get: (buf, off) => {
         return {
-            objectId: GUID.fromBin(new Token.BufferType(16).get(buf, off)),
+            objectId: GUID.fromBin(buf, off),
             objectSize: Number(Token.UINT64_LE.get(buf, off + 16))
         };
     }
@@ -144,10 +144,11 @@ export class HeaderExtensionObject {
         this.len = 22;
     }
     get(buf, off) {
+        const view = new DataView(buf.buffer, off);
         return {
             reserved1: GUID.fromBin(buf, off),
-            reserved2: buf.readUInt16LE(off + 16),
-            extensionDataSize: buf.readUInt32LE(off + 18)
+            reserved2: view.getUint16(16, true),
+            extensionDataSize: view.getUint16(18, true)
         };
     }
 }
@@ -159,14 +160,15 @@ HeaderExtensionObject.guid = GUID.HeaderExtensionObject;
 const CodecListObjectHeader = {
     len: 20,
     get: (buf, off) => {
+        const view = new DataView(buf.buffer, off);
         return {
-            entryCount: buf.readUInt16LE(off + 16)
+            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, 'utf16le'))).replace('\0', '');
+    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.
@@ -182,7 +184,7 @@ export async function readCodecEntries(tokenizer) {
 }
 async function readInformation(tokenizer) {
     const length = await tokenizer.readNumber(Token.UINT16_LE);
-    const buf = Buffer.alloc(length);
+    const buf = new Uint8Array(length);
     await tokenizer.readBuffer(buf);
     return buf;
 }
@@ -212,13 +214,14 @@ export class ContentDescriptionObjectState extends State {
     }
     get(buf, off) {
         const tags = [];
-        let pos = off + 10;
+        const view = new DataView(buf.buffer, off);
+        let pos = 10;
         for (let i = 0; i < ContentDescriptionObjectState.contentDescTags.length; ++i) {
-            const length = buf.readUInt16LE(off + i * 2);
+            const length = view.getUint16(i * 2, true);
             if (length > 0) {
                 const tagName = ContentDescriptionObjectState.contentDescTags[i];
                 const end = pos + length;
-                tags.push({ id: tagName, value: AsfUtil.parseUnicodeAttr(buf.slice(pos, end)) });
+                tags.push({ id: tagName, value: AsfUtil.parseUnicodeAttr(buf.slice(off + pos, off + end)) });
                 pos = end;
             }
         }
@@ -237,18 +240,19 @@ export class ExtendedContentDescriptionObjectState extends State {
     }
     get(buf, off) {
         const tags = [];
-        const attrCount = buf.readUInt16LE(off);
-        let pos = off + 2;
+        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 = buf.readUInt16LE(pos);
+            const nameLen = view.getUint16(pos, true);
             pos += 2;
-            const name = AsfUtil.parseUnicodeAttr(buf.slice(pos, pos + nameLen));
+            const name = AsfUtil.parseUnicodeAttr(buf.slice(off + pos, off + pos + nameLen));
             pos += nameLen;
-            const valueType = buf.readUInt16LE(pos);
+            const valueType = view.getUint16(pos, true);
             pos += 2;
-            const valueLen = buf.readUInt16LE(pos);
+            const valueLen = view.getUint16(pos, true);
             pos += 2;
-            const value = buf.slice(pos, pos + valueLen);
+            const value = buf.slice(off + pos, off + pos + valueLen);
             pos += valueLen;
             this.postProcessTag(tags, name, valueType, value);
         }
@@ -265,28 +269,29 @@ export class ExtendedStreamPropertiesObjectState extends State {
         super(header);
     }
     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: buf.readInt32LE(off + 12),
-            bufferSize: buf.readInt32LE(off + 16),
-            initialBufferFullness: buf.readInt32LE(off + 20),
-            alternateDataBitrate: buf.readInt32LE(off + 24),
-            alternateBufferSize: buf.readInt32LE(off + 28),
-            alternateInitialBufferFullness: buf.readInt32LE(off + 32),
-            maximumObjectSize: buf.readInt32LE(off + 36),
+            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: buf.readInt16LE(off + 42),
-            streamLanguageId: buf.readInt16LE(off + 44),
-            averageTimePerFrame: buf.readInt32LE(off + 52),
-            streamNameCount: buf.readInt32LE(off + 54),
-            payloadExtensionSystems: buf.readInt32LE(off + 56),
-            streamNames: [],
+            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
         };
     }
@@ -302,20 +307,20 @@ export class MetadataObjectState extends State {
     }
     get(uint8Array, off) {
         const tags = [];
-        const buf = Buffer.from(uint8Array);
-        const descriptionRecordsCount = buf.readUInt16LE(off);
-        let pos = off + 2;
+        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 = buf.readUInt16LE(pos);
+            const nameLen = view.getUint16(pos, true);
             pos += 2;
-            const dataType = buf.readUInt16LE(pos);
+            const dataType = view.getUint16(pos, true);
             pos += 2;
-            const dataLen = buf.readUInt32LE(pos);
+            const dataLen = view.getUint32(pos, true);
             pos += 4;
-            const name = AsfUtil.parseUnicodeAttr(buf.slice(pos, pos + nameLen));
+            const name = AsfUtil.parseUnicodeAttr(uint8Array.slice(off + pos, off + pos + nameLen));
             pos += nameLen;
-            const data = buf.slice(pos, pos + dataLen);
+            const data = uint8Array.slice(off + pos, off + pos + dataLen);
             pos += dataLen;
             this.postProcessTag(tags, name, dataType, data);
         }
@@ -335,7 +340,7 @@ MetadataLibraryObjectState.guid = GUID.MetadataLibraryObject;
  */
 export class WmPictureToken {
     static fromBase64(base64str) {
-        return this.fromBuffer(Buffer.from(base64str, 'base64'));
+        return this.fromBuffer(base64ToUint8Array(base64str));
     }
     static fromBuffer(buffer) {
         const pic = new WmPictureToken(buffer.length);
@@ -345,17 +350,18 @@ export class WmPictureToken {
         this.len = len;
     }
     get(buffer, offset) {
-        const typeId = buffer.readUInt8(offset++);
-        const size = buffer.readInt32LE(offset);
+        const view = new DataView(buffer.buffer, offset);
+        const typeId = view.getUint8(0);
+        const size = view.getInt32(1, true);
         let index = 5;
-        while (buffer.readUInt16BE(index) !== 0) {
+        while (view.getUint16(index) !== 0) {
             index += 2;
         }
-        const format = buffer.slice(5, index).toString('utf16le');
-        while (buffer.readUInt16BE(index) !== 0) {
+        const format = new Token.StringType(index - 5, 'utf-16le').get(buffer, 5);
+        while (view.getUint16(index) !== 0) {
             index += 2;
         }
-        const description = buffer.slice(5, index).toString('utf16le');
+        const description = new Token.StringType(index - 5, 'utf-16le').get(buffer, 5);
         return {
             type: AttachedPictureType[typeId],
             format,

package/lib/asf/AsfParser.js

@@ -51,11 +51,11 @@ export class AsfParser extends BasicParser {
                     break;
                 case AsfObject.ContentDescriptionObjectState.guid.str: // 3.10
                     tags = await this.tokenizer.readToken(new AsfObject.ContentDescriptionObjectState(header));
-                    this.addTags(tags);
+                    await this.addTags(tags);
                     break;
                 case AsfObject.ExtendedContentDescriptionObjectState.guid.str: // 3.11
                     tags = await this.tokenizer.readToken(new AsfObject.ExtendedContentDescriptionObjectState(header));
-                    this.addTags(tags);
+                    await this.addTags(tags);
                     break;
                 case GUID.CodecListObject.str:
                     const codecs = await AsfObject.readCodecEntries(this.tokenizer);
@@ -85,10 +85,8 @@ export class AsfParser extends BasicParser {
         } while (--numberOfObjectHeaders);
         // done
     }
-    addTags(tags) {
-        tags.forEach(tag => {
-            this.metadata.addTag(headerType, tag.id, tag.value);
-        });
+    async addTags(tags) {
+        await Promise.all(tags.map(({ id, value }) => this.metadata.addTag(headerType, id, value)));
     }
     async parseExtensionObject(extensionSize) {
         do {
@@ -103,11 +101,11 @@ export class AsfParser extends BasicParser {
                     break;
                 case AsfObject.MetadataObjectState.guid.str: // 4.7
                     const moTags = await this.tokenizer.readToken(new AsfObject.MetadataObjectState(header));
-                    this.addTags(moTags);
+                    await this.addTags(moTags);
                     break;
                 case AsfObject.MetadataLibraryObjectState.guid.str: // 4.8
                     const mlTags = await this.tokenizer.readToken(new AsfObject.MetadataLibraryObjectState(header));
-                    this.addTags(mlTags);
+                    await this.addTags(mlTags);
                     break;
                 case GUID.PaddingObject.str:
                     // ToDo: register bytes pad

package/lib/asf/AsfTagMapper.js

@@ -8,7 +8,7 @@ const asfTagMap = {
     Author: 'artist',
     'WM/AlbumArtist': 'albumartist',
     'WM/AlbumTitle': 'album',
-    'WM/Year': 'date',
+    'WM/Year': 'date', // changed to 'year' to 'date' based on Picard mappings; ToDo: check me
     'WM/OriginalReleaseTime': 'originaldate',
     'WM/OriginalReleaseYear': 'originalyear',
     Description: 'comment',

package/lib/asf/AsfUtil.d.ts

@@ -1,7 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-import { Buffer } from 'node:buffer';
 import { DataType } from './AsfObject.js';
-export type AttributeParser = (buf: Buffer) => boolean | string | number | bigint | Buffer;
+export type AttributeParser = (buf: Uint8Array) => boolean | string | number | bigint | Uint8Array;
 export declare class AsfUtil {
     static getParserForAttr(i: DataType): AttributeParser;
     static parseUnicodeAttr(uint8Array: Uint8Array): string;

package/lib/asf/AsfUtil.js

@@ -1,27 +1,26 @@
 import * as Token from 'token-types';
-import { Buffer } from 'node:buffer';
 import * as util from '../common/Util.js';
 export class AsfUtil {
     static getParserForAttr(i) {
         return AsfUtil.attributeParsers[i];
     }
     static parseUnicodeAttr(uint8Array) {
-        return util.stripNulls(util.decodeString(uint8Array, 'utf16le'));
+        return util.stripNulls(util.decodeString(uint8Array, 'utf-16le'));
     }
     static parseByteArrayAttr(buf) {
-        return Buffer.from(buf);
+        return new Uint8Array(buf);
     }
     static parseBoolAttr(buf, offset = 0) {
         return AsfUtil.parseWordAttr(buf, offset) === 1;
     }
     static parseDWordAttr(buf, offset = 0) {
-        return buf.readUInt32LE(offset);
+        return Token.UINT32_LE.get(buf, offset);
     }
     static parseQWordAttr(buf, offset = 0) {
         return Token.UINT64_LE.get(buf, offset);
     }
     static parseWordAttr(buf, offset = 0) {
-        return buf.readUInt16LE(offset);
+        return Token.UINT16_LE.get(buf, offset);
     }
 }
 AsfUtil.attributeParsers = [

package/lib/asf/GUID.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 /**
  * Ref:
  * - https://tools.ietf.org/html/draft-fleischman-asf-01, Appendix A: ASF GUIDs
@@ -58,14 +57,14 @@ export default class GUID {
     static FileTransferMedia: GUID;
     static BinaryMedia: GUID;
     static ASF_Index_Placeholder_Object: GUID;
-    static fromBin(bin: Buffer, offset?: number): GUID;
+    static fromBin(bin: Uint8Array, offset?: number): GUID;
     /**
      * Decode GUID in format like "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
      * @param objectId Binary GUID
      * @param offset Read offset in bytes, default 0
      * @returns GUID as dashed hexadecimal representation
      */
-    static decode(objectId: Buffer, offset?: number): string;
+    static decode(objectId: Uint8Array, offset?: number): string;
     /**
      * Decode stream type
      * @param mediaType Media type GUID
@@ -77,8 +76,8 @@ export default class GUID {
      * @param guid GUID like: "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
      * @returns Encoded Binary GUID
      */
-    static encode(str: string): Buffer;
+    static encode(str: string): Uint8Array;
     constructor(str: string);
     equals(guid: GUID): boolean;
-    toBin(): Buffer;
+    toBin(): Uint8Array;
 }

package/lib/asf/GUID.js

@@ -1,3 +1,4 @@
+import { hexToUint8Array, uint8ArrayToHex } from 'uint8array-extras';
 /**
  * Ref:
  * - https://tools.ietf.org/html/draft-fleischman-asf-01, Appendix A: ASF GUIDs
@@ -23,11 +24,12 @@ class GUID {
      * @returns GUID as dashed hexadecimal representation
      */
     static decode(objectId, offset = 0) {
-        const guid = objectId.readUInt32LE(offset).toString(16) + "-" +
-            objectId.readUInt16LE(offset + 4).toString(16) + "-" +
-            objectId.readUInt16LE(offset + 6).toString(16) + "-" +
-            objectId.readUInt16BE(offset + 8).toString(16) + "-" +
-            objectId.slice(offset + 10, offset + 16).toString('hex');
+        const view = new DataView(objectId.buffer, offset);
+        const guid = view.getUint32(0, true).toString(16) + "-" +
+            view.getUint16(4, true).toString(16) + "-" +
+            view.getUint16(6, true).toString(16) + "-" +
+            view.getUint16(8).toString(16) + "-" +
+            uint8ArrayToHex(objectId.slice(offset + 10, offset + 16));
         return guid.toUpperCase();
     }
     /**
@@ -51,12 +53,13 @@ class GUID {
      * @returns Encoded Binary GUID
      */
     static encode(str) {
-        const bin = Buffer.alloc(16);
-        bin.writeUInt32LE(parseInt(str.slice(0, 8), 16), 0);
-        bin.writeUInt16LE(parseInt(str.slice(9, 13), 16), 4);
-        bin.writeUInt16LE(parseInt(str.slice(14, 18), 16), 6);
-        Buffer.from(str.slice(19, 23), "hex").copy(bin, 8);
-        Buffer.from(str.slice(24), "hex").copy(bin, 10);
+        const bin = new Uint8Array(16);
+        const view = new DataView(bin.buffer);
+        view.setUint32(0, parseInt(str.slice(0, 8), 16), true);
+        view.setUint16(4, parseInt(str.slice(9, 13), 16), true);
+        view.setUint16(6, parseInt(str.slice(14, 18), 16), true);
+        bin.set(hexToUint8Array(str.slice(19, 23)), 8);
+        bin.set(hexToUint8Array(str.slice(24)), 10);
         return bin;
     }
     constructor(str) {

package/lib/common/BasicParser.d.ts

@@ -1,4 +1,4 @@
-import { ITokenizer } from 'strtok3/core';
+import type { ITokenizer } from 'strtok3';
 import { ITokenParser } from '../ParserFactory.js';
 import { IOptions, IPrivateOptions } from '../type.js';
 import { INativeMetadataCollector } from './MetadataCollector.js';

package/lib/common/FourCC.d.ts

@@ -1,4 +1,4 @@
-import { IToken } from 'strtok3/core';
+import { IToken } from 'strtok3';
 /**
  * Token for read FourCC
  * Ref: https://en.wikipedia.org/wiki/FourCC

package/lib/common/FourCC.js

@@ -1,3 +1,4 @@
+import { stringToUint8Array, uint8ArrayToString } from 'uint8array-extras';
 import * as util from './Util.js';
 const validFourCC = /^[\x21-\x7e©][\x20-\x7e\x00()]{3}/;
 /**
@@ -7,17 +8,18 @@ const validFourCC = /^[\x21-\x7e©][\x20-\x7e\x00()]{3}/;
 export const FourCcToken = {
     len: 4,
     get: (buf, off) => {
-        const id = buf.toString('binary', off, off + FourCcToken.len);
+        const id = uint8ArrayToString(buf.slice(off, off + FourCcToken.len), 'latin1');
         if (!id.match(validFourCC)) {
             throw new Error(`FourCC contains invalid characters: ${util.a2hex(id)} "${id}"`);
         }
         return id;
     },
     put: (buffer, offset, id) => {
-        const str = Buffer.from(id, 'binary');
+        const str = stringToUint8Array(id);
         if (str.length !== 4)
             throw new Error('Invalid length');
-        return str.copy(buffer, offset);
+        buffer.set(str, offset);
+        return offset + 4;
     }
 };
 //# sourceMappingURL=FourCC.js.map

package/lib/common/MetadataCollector.d.ts

@@ -22,7 +22,7 @@ export interface INativeMetadataCollector extends IWarningCollector {
      */
     hasAny(): boolean;
     setFormat(key: FormatId, value: any): void;
-    addTag(tagType: TagType, tagId: string, value: any): void;
+    addTag(tagType: TagType, tagId: string, value: any): Promise<void>;
     addStreamInfo(streamInfo: ITrackInfo): void;
 }
 /**
@@ -51,9 +51,9 @@ export declare class MetadataCollector implements INativeMetadataCollector {
     hasAny(): boolean;
     addStreamInfo(streamInfo: ITrackInfo): void;
     setFormat(key: FormatId, value: any): void;
-    addTag(tagType: TagType, tagId: string, value: any): void;
+    addTag(tagType: TagType, tagId: string, value: any): Promise<void>;
     addWarning(warning: string): void;
-    postMap(tagType: TagType | 'artificial', tag: IGenericTag): any;
+    postMap(tagType: TagType | 'artificial', tag: IGenericTag): Promise<void>;
     /**
      * Convert native tags to common tags
      * @returns {IAudioMetadata} Native + common tags

package/lib/common/MetadataCollector.js

@@ -60,19 +60,19 @@ export class MetadataCollector {
             this.opts.observer({ metadata: this, tag: { type: 'format', id: key, value } });
         }
     }
-    addTag(tagType, tagId, value) {
+    async addTag(tagType, tagId, value) {
         debug(`tag ${tagType}.${tagId} = ${value}`);
         if (!this.native[tagType]) {
             this.format.tagTypes.push(tagType);
             this.native[tagType] = [];
         }
         this.native[tagType].push({ id: tagId, value });
-        this.toCommon(tagType, tagId, value);
+        await this.toCommon(tagType, tagId, value);
     }
     addWarning(warning) {
         this.quality.warnings.push({ message: warning });
     }
-    postMap(tagType, tag) {
+    async postMap(tagType, tag) {
         // Common tag (alias) found
         // check if we need to do something special with common tag
         // if the event has been aliased then we need to clean it before
@@ -100,13 +100,12 @@ export class MetadataCollector {
                 }
                 break;
             case 'picture':
-                this.postFixPicture(tag.value).then(picture => {
+                return this.postFixPicture(tag.value).then(picture => {
                     if (picture !== null) {
                         tag.value = picture;
                         this.setGenericTag(tagType, tag);
                     }
                 });
-                return;
             case 'totaltracks':
                 this.common.track.of = CommonTagMapper.toIntOrNull(tag.value);
                 return;
@@ -194,7 +193,7 @@ export class MetadataCollector {
     async postFixPicture(picture) {
         if (picture.data && picture.data.length > 0) {
             if (!picture.format) {
-                const fileType = await fileTypeFromBuffer(picture.data);
+                const fileType = await fileTypeFromBuffer(Uint8Array.from(picture.data)); // ToDO: remove Buffer
                 if (fileType) {
                     picture.format = fileType.mime;
                 }
@@ -215,11 +214,11 @@ export class MetadataCollector {
     /**
      * Convert native tag to common tags
      */
-    toCommon(tagType, tagId, value) {
+    async toCommon(tagType, tagId, value) {
         const tag = { id: tagId, value };
         const genericTag = this.tagMapper.mapTag(tagType, tag, this);
         if (genericTag) {
-            this.postMap(tagType, genericTag);
+            await this.postMap(tagType, genericTag);
         }
     }
     /**

package/lib/common/RandomFileReader.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 import { IRandomReader } from '../type.js';
 /**
  * Provides abstract file access via the IRandomRead interface

package/lib/common/Util.d.ts

@@ -1,5 +1,5 @@
 import { IRatio } from '../type.js';
-export type StringEncoding = 'ascii' | 'utf8' | 'utf16le' | 'ucs2' | 'base64url' | 'latin1' | 'hex';
+export type StringEncoding = 'ascii' | 'utf8' | 'utf-16le' | 'ucs2' | 'base64url' | 'latin1' | 'hex';
 export interface ITextEncoding {
     encoding: StringEncoding;
     bom?: boolean;