music-metadata 8.3.0 → 9.0.1

package/lib/ParserFactory.d.ts

@@ -1,6 +1,6 @@
 import { INativeMetadataCollector } from './common/MetadataCollector.js';
 import { IOptions, IAudioMetadata, ParserType } from './type.js';
-import { ITokenizer } from 'strtok3/core';
+import type { ITokenizer } from 'strtok3';
 export interface ITokenParser {
     /**
      * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).

package/lib/ParserFactory.js

@@ -2,7 +2,6 @@ import { fileTypeFromBuffer } from 'file-type';
 import ContentType from 'content-type';
 import MimeType from 'media-typer';
 import initDebug from 'debug';
-import { Buffer } from 'node:buffer';
 import { MetadataCollector } from './common/MetadataCollector.js';
 import { AIFFParser } from './aiff/AiffParser.js';
 import { APEv2Parser } from './apev2/APEv2Parser.js';
@@ -55,7 +54,7 @@ export class ParserFactory {
         if (!parserId) {
             // Parser could not be determined on MIME-type or extension
             debug('Guess parser on content...');
-            const buf = Buffer.alloc(4100);
+            const buf = new Uint8Array(4100);
             await tokenizer.peekBuffer(buf, { mayBeLess: true });
             if (tokenizer.fileInfo.path) {
                 parserId = this.getParserIdForExtension(tokenizer.fileInfo.path);

package/lib/aiff/AiffParser.js

@@ -1,6 +1,6 @@
 import * as Token from 'token-types';
 import initDebug from 'debug';
-import * as strtok3 from 'strtok3/core';
+import * as strtok3 from 'strtok3';
 import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
 import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
@@ -96,9 +96,8 @@ export class AIFFParser extends BasicParser {
     }
     async readTextChunk(header) {
         const value = await this.tokenizer.readToken(new Token.StringType(header.chunkSize, 'ascii'));
-        value.split('\0').map(v => v.trim()).filter(v => v && v.length > 0).forEach(v => {
-            this.metadata.addTag('AIFF', header.chunkID, v.trim());
-        });
+        const values = value.split('\0').map(v => v.trim()).filter(v => v && v.length);
+        await Promise.all(values.map(v => this.metadata.addTag('AIFF', header.chunkID, v)));
         return header.chunkSize;
     }
 }

package/lib/aiff/AiffToken.d.ts

@@ -1,7 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-import { Buffer } from 'node:buffer';
 import * as iff from '../iff/index.js';
-import { IGetToken } from 'strtok3';
+import type { IGetToken } from 'strtok3';
 /**
  * The Common Chunk.
  * Describes fundamental parameters of the waveform data such as sample rate, bit resolution, and how many channels of
@@ -19,5 +17,5 @@ export declare class Common implements IGetToken<ICommon> {
     private isAifc;
     len: number;
     constructor(header: iff.IChunkHeader, isAifc: boolean);
-    get(buf: Buffer, off: number): ICommon;
+    get(buf: Uint8Array, off: number): ICommon;
 }

package/lib/aiff/AiffToken.js

@@ -10,22 +10,22 @@ export class Common {
     }
     get(buf, off) {
         // see: https://cycling74.com/forums/aiffs-80-bit-sample-rate-value
-        const shift = buf.readUInt16BE(off + 8) - 16398;
-        const baseSampleRate = buf.readUInt16BE(off + 8 + 2);
+        const shift = Token.UINT16_BE.get(buf, off + 8) - 16398;
+        const baseSampleRate = Token.UINT16_BE.get(buf, off + 8 + 2);
         const res = {
-            numChannels: buf.readUInt16BE(off),
-            numSampleFrames: buf.readUInt32BE(off + 2),
-            sampleSize: buf.readUInt16BE(off + 6),
+            numChannels: Token.UINT16_BE.get(buf, off),
+            numSampleFrames: Token.UINT32_BE.get(buf, off + 2),
+            sampleSize: Token.UINT16_BE.get(buf, off + 6),
             sampleRate: shift < 0 ? baseSampleRate >> Math.abs(shift) : baseSampleRate << shift
         };
         if (this.isAifc) {
             res.compressionType = FourCcToken.get(buf, off + 18);
             if (this.len > 22) {
-                const strLen = buf.readInt8(off + 22);
+                const strLen = Token.UINT8.get(buf, off + 22);
                 if (strLen > 0) {
                     const padding = (strLen + 1) % 2;
                     if (23 + strLen + padding === this.len) {
-                        res.compressionName = new Token.StringType(strLen, 'binary').get(buf, off + 23);
+                        res.compressionName = new Token.StringType(strLen, 'latin1').get(buf, off + 23);
                     }
                     else {
                         throw new Error('Illegal pstring length');

package/lib/apev2/APEv2Parser.d.ts

@@ -1,4 +1,4 @@
-import * as strtok3 from 'strtok3/core';
+import * as strtok3 from 'strtok3';
 import { IOptions, IRandomReader, IApeHeader } from '../type.js';
 import { INativeMetadataCollector } from '../common/MetadataCollector.js';
 import { BasicParser } from '../common/BasicParser.js';

package/lib/apev2/APEv2Parser.js

@@ -1,7 +1,7 @@
 import initDebug from 'debug';
-import * as strtok3 from 'strtok3/core';
+import * as strtok3 from 'strtok3';
 import { StringType } from 'token-types';
-import { Buffer } from 'node:buffer';
+import { uint8ArrayToString } from 'uint8array-extras';
 import * as util from '../common/Util.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { DataType, DescriptorParser, Header, TagFooter, TagItemHeader } from './APEv2Token.js';
@@ -35,7 +35,7 @@ export class APEv2Parser extends BasicParser {
      */
     static async findApeFooterOffset(reader, offset) {
         // Search for APE footer header at the end of the file
-        const apeBuf = Buffer.alloc(TagFooter.len);
+        const apeBuf = new Uint8Array(TagFooter.len);
         await reader.randomRead(apeBuf, 0, TagFooter.len, offset - TagFooter.len);
         const tagFooter = TagFooter.get(apeBuf, 0);
         if (tagFooter.ID === 'APETAGEX') {
@@ -70,7 +70,7 @@ export class APEv2Parser extends BasicParser {
             if (this.tokenizer.fileInfo.size) {
                 // Try to read the APEv2 header using just the footer-header
                 const remaining = this.tokenizer.fileInfo.size - this.tokenizer.position; // ToDo: take ID3v1 into account
-                const buffer = Buffer.alloc(remaining);
+                const buffer = new Uint8Array(remaining);
                 await this.tokenizer.readBuffer(buffer);
                 return APEv2Parser.parseTagFooter(this.metadata, buffer, this.options);
             }
@@ -87,7 +87,7 @@ export class APEv2Parser extends BasicParser {
         return this.tryParseApeHeader();
     }
     async parseTags(footer) {
-        const keyBuffer = Buffer.alloc(256); // maximum tag key length
+        const keyBuffer = new Uint8Array(256); // maximum tag key length
         let bytesRemaining = footer.size - TagFooter.len;
         debug(`Parse APE tags at offset=${this.tokenizer.position}, size=${bytesRemaining}`);
         for (let i = 0; i < footer.fields; i++) {
@@ -107,9 +107,7 @@ export class APEv2Parser extends BasicParser {
                 case DataType.text_utf8: { // utf-8 text-string
                     const value = await this.tokenizer.readToken(new StringType(tagItemHeader.size, 'utf8'));
                     const values = value.split(/\x00/g);
-                    for (const val of values) {
-                        this.metadata.addTag(tagFormat, key, val);
-                    }
+                    await Promise.all(values.map(val => this.metadata.addTag(tagFormat, key, val)));
                     break;
                 }
                 case DataType.binary: // binary (probably artwork)
@@ -117,12 +115,12 @@ export class APEv2Parser extends BasicParser {
                         await this.tokenizer.ignore(tagItemHeader.size);
                     }
                     else {
-                        const picData = Buffer.alloc(tagItemHeader.size);
+                        const picData = new Uint8Array(tagItemHeader.size);
                         await this.tokenizer.readBuffer(picData);
                         zero = util.findZero(picData, 0, picData.length);
-                        const description = picData.toString('utf8', 0, zero);
-                        const data = Buffer.from(picData.slice(zero + 1));
-                        this.metadata.addTag(tagFormat, key, {
+                        const description = uint8ArrayToString(picData.slice(0, zero));
+                        const data = picData.slice(zero + 1);
+                        await this.metadata.addTag(tagFormat, key, {
                             description,
                             data
                         });

package/lib/apev2/APEv2Token.d.ts

@@ -1,5 +1,5 @@
 import * as Token from 'token-types';
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 /**
  * APETag versionIndex history / supported formats
  *

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,27 +269,28 @@ 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),
+            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/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;
 }