music-metadata 8.3.0 → 9.0.1

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
@@ -10,13 +9,13 @@ export declare class RandomFileReader implements IRandomReader {
     private constructor();
     /**
      * Read from a given position of an abstracted file or buffer.
-     * @param buffer {Buffer} is the buffer that the data will be written to.
+     * @param buffer {Uint8Array} is the buffer that the data will be written to.
      * @param offset {number} is the offset in the buffer to start writing at.
      * @param length {number}is an integer specifying the number of bytes to read.
      * @param position {number} is an argument specifying where to begin reading from in the file.
      * @return {Promise<number>} bytes read
      */
-    randomRead(buffer: Buffer, offset: number, length: number, position: number): Promise<number>;
+    randomRead(buffer: Uint8Array, offset: number, length: number, position: number): Promise<number>;
     close(): Promise<void>;
     static init(filePath: string, fileSize: number): Promise<RandomFileReader>;
 }

package/lib/common/RandomFileReader.js

@@ -10,7 +10,7 @@ export class RandomFileReader {
     }
     /**
      * Read from a given position of an abstracted file or buffer.
-     * @param buffer {Buffer} is the buffer that the data will be written to.
+     * @param buffer {Uint8Array} is the buffer that the data will be written to.
      * @param offset {number} is the offset in the buffer to start writing at.
      * @param length {number}is an integer specifying the number of bytes to read.
      * @param position {number} is an argument specifying where to begin reading from in the file.

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;

package/lib/common/Util.js

@@ -1,3 +1,4 @@
+import { StringType } from 'token-types';
 export function getBit(buf, off, bit) {
     return (buf[off] & (1 << bit)) !== 0;
 }
@@ -11,7 +12,7 @@ export function getBit(buf, off, bit) {
  */
 export function findZero(uint8Array, start, end, encoding) {
     let i = start;
-    if (encoding === 'utf16le') {
+    if (encoding === 'utf-16le') {
         while (uint8Array[i] !== 0 || uint8Array[i + 1] !== 0) {
             if (i >= end)
                 return end;
@@ -52,13 +53,13 @@ export function decodeString(uint8Array, encoding) {
     if (uint8Array[0] === 0xFF && uint8Array[1] === 0xFE) { // little endian
         return decodeString(uint8Array.subarray(2), encoding);
     }
-    else if (encoding === 'utf16le' && uint8Array[0] === 0xFE && uint8Array[1] === 0xFF) {
+    else if (encoding === 'utf-16le' && uint8Array[0] === 0xFE && uint8Array[1] === 0xFF) {
         // BOM, indicating big endian decoding
         if ((uint8Array.length & 1) !== 0)
             throw new Error('Expected even number of octets for 16-bit unicode string');
         return decodeString(swapBytes(uint8Array), encoding);
     }
-    return Buffer.from(uint8Array).toString(encoding);
+    return new StringType(uint8Array.length, encoding).get(uint8Array, 0);
 }
 export function stripNulls(str) {
     str = str.replace(/^\x00+/g, '');

package/lib/core.d.ts

@@ -1,16 +1,24 @@
-/// <reference types="node" resolution-mode="require"/>
-import { Readable } from 'stream';
-import * as strtok3 from 'strtok3/core';
-import { IAudioMetadata, INativeTagDict, IOptions, IPicture, IPrivateOptions, IRandomReader, ITag } from './type.js';
-export { IFileInfo } from 'strtok3/core';
+import * as strtok3 from 'strtok3';
+import type { IAudioMetadata, INativeTagDict, IOptions, IPicture, IPrivateOptions, IRandomReader, ITag } from './type.js';
+import type { ReadableStream as NodeReadableStream } from 'node:stream/web';
+export { IFileInfo } from 'strtok3';
+export type AnyWebStream<G> = NodeReadableStream<G> | ReadableStream<G>;
 /**
- * Parse audio from Node Stream.Readable
- * @param stream - Stream to read the audio track from
+ * Parse Web API File
+ * Requires Blob to be able to stream using a ReadableStreamBYOBReader, only available since Node.js ≥ 20
+ * @param blob - Blob to parse
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export declare function parseBlob(blob: Blob, options?: IOptions): Promise<IAudioMetadata>;
+/**
+ * Parse audio from Web Stream.Readable
+ * @param webStream - WebStream to read the audio track from
  * @param options - Parsing options
  * @param fileInfo - File information object or MIME-type string
  * @returns Metadata
  */
-export declare function parseStream(stream: Readable, fileInfo?: strtok3.IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
+export declare function parseWebStream(webStream: AnyWebStream<Uint8Array>, fileInfo?: strtok3.IFileInfo | string, options?: IOptions): Promise<IAudioMetadata>;
 /**
  * Parse audio from Node Buffer
  * @param uint8Array - Uint8Array holding audio data

package/lib/core.js

@@ -1,18 +1,32 @@
-import * as strtok3 from 'strtok3/core';
+import * as strtok3 from 'strtok3';
 import { ParserFactory } from './ParserFactory.js';
 import { RandomUint8ArrayReader } from './common/RandomUint8ArrayReader.js';
 import { APEv2Parser } from './apev2/APEv2Parser.js';
 import { hasID3v1Header } from './id3v1/ID3v1Parser.js';
 import { getLyricsHeaderLength } from './lyrics3/Lyrics3.js';
 /**
- * Parse audio from Node Stream.Readable
- * @param stream - Stream to read the audio track from
+ * Parse Web API File
+ * Requires Blob to be able to stream using a ReadableStreamBYOBReader, only available since Node.js ≥ 20
+ * @param blob - Blob to parse
+ * @param options - Parsing options
+ * @returns Metadata
+ */
+export async function parseBlob(blob, options = {}) {
+    const fileInfo = { mimeType: blob.type, size: blob.size };
+    if (blob instanceof File) {
+        fileInfo.path = blob.name;
+    }
+    return parseWebStream(blob.stream(), fileInfo, options);
+}
+/**
+ * Parse audio from Web Stream.Readable
+ * @param webStream - WebStream to read the audio track from
  * @param options - Parsing options
  * @param fileInfo - File information object or MIME-type string
  * @returns Metadata
  */
-export function parseStream(stream, fileInfo, options = {}) {
-    return parseFromTokenizer(strtok3.fromStream(stream, typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo), options);
+export function parseWebStream(webStream, fileInfo, options = {}) {
+    return parseFromTokenizer(strtok3.fromWebStream(webStream, typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo), options);
 }
 /**
  * Parse audio from Node Buffer

package/lib/dsdiff/DsdiffParser.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 { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';

package/lib/dsdiff/DsdiffToken.d.ts

@@ -1,4 +1,4 @@
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 import { IChunkHeader64 } from '../iff/index.js';
 export { IChunkHeader64 } from '../iff/index.js';
 /**

package/lib/dsf/DsfChunk.d.ts

@@ -1,4 +1,4 @@
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 /**
  * Common interface for the common chunk DSD header
  */

package/lib/flac/FlacParser.d.ts

@@ -1,4 +1,4 @@
-import { ITokenizer } from 'strtok3/core';
+import type { ITokenizer } from 'strtok3';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
 import { INativeMetadataCollector } from '../common/MetadataCollector.js';
 import { IOptions } from '../type.js';

package/lib/flac/FlacParser.js

@@ -54,7 +54,7 @@ export class FlacParser extends AbstractID3Parser {
             this.metadata.setFormat('bitrate', 8 * dataSize / this.metadata.format.duration);
         }
     }
-    parseDataBlock(blockHeader) {
+    async parseDataBlock(blockHeader) {
         debug(`blockHeader type=${blockHeader.type}, length=${blockHeader.length}`);
         switch (blockHeader.type) {
             case BlockType.STREAMINFO:
@@ -71,7 +71,8 @@ export class FlacParser extends AbstractID3Parser {
             case BlockType.CUESHEET:
                 break;
             case BlockType.PICTURE:
-                return this.parsePicture(blockHeader.length).then();
+                await this.parsePicture(blockHeader.length);
+                return;
             default:
                 this.metadata.addWarning('Unknown block type: ' + blockHeader.type);
         }
@@ -104,10 +105,11 @@ export class FlacParser extends AbstractID3Parser {
         const decoder = new VorbisDecoder(data, 0);
         decoder.readStringUtf8(); // vendor (skip)
         const commentListLength = decoder.readInt32();
+        const tags = new Array(commentListLength);
         for (let i = 0; i < commentListLength; i++) {
-            const tag = decoder.parseUserComment();
-            this.vorbisParser.addTag(tag.key, tag.value);
+            tags[i] = decoder.parseUserComment();
         }
+        await Promise.all(tags.map(tag => this.vorbisParser.addTag(tag.key, tag.value)));
     }
     async parsePicture(dataLen) {
         if (this.options.skipCovers) {

package/lib/id3v1/ID3v1Parser.js

@@ -68,7 +68,7 @@ const Iid3v1Token = {
 };
 class Id3v1StringType extends StringType {
     constructor(len) {
-        super(len, 'binary');
+        super(len, 'latin1');
     }
     get(buf, off) {
         let value = super.get(buf, off);
@@ -105,25 +105,25 @@ export class ID3v1Parser extends BasicParser {
             debug('ID3v1 header found at: pos=%s', this.tokenizer.fileInfo.size - Iid3v1Token.len);
             for (const id of ['title', 'artist', 'album', 'comment', 'track', 'year']) {
                 if (header[id] && header[id] !== '')
-                    this.addTag(id, header[id]);
+                    await this.addTag(id, header[id]);
             }
             const genre = ID3v1Parser.getGenre(header.genre);
             if (genre)
-                this.addTag('genre', genre);
+                await this.addTag('genre', genre);
         }
         else {
             debug('ID3v1 header not found at: pos=%s', this.tokenizer.fileInfo.size - Iid3v1Token.len);
         }
     }
-    addTag(id, value) {
-        this.metadata.addTag('ID3v1', id, value);
+    async addTag(id, value) {
+        await this.metadata.addTag('ID3v1', id, value);
     }
 }
 export async function hasID3v1Header(reader) {
     if (reader.fileSize >= 128) {
-        const tag = Buffer.alloc(3);
+        const tag = new Uint8Array(3);
         await reader.randomRead(tag, 0, tag.length, reader.fileSize - 128);
-        return tag.toString('binary') === 'TAG';
+        return new TextDecoder('latin1').decode(tag) === 'TAG';
     }
     return false;
 }

package/lib/id3v2/AbstractID3Parser.d.ts

@@ -1,4 +1,4 @@
-import { ITokenizer } from 'strtok3/core';
+import { ITokenizer } from 'strtok3';
 import { BasicParser } from '../common/BasicParser.js';
 /**
  * Abstract parser which tries take ID3v2 and ID3v1 headers.

package/lib/id3v2/AbstractID3Parser.js

@@ -1,4 +1,4 @@
-import { EndOfStreamError } from 'strtok3/core';
+import { EndOfStreamError } from 'strtok3';
 import initDebug from 'debug';
 import { ID3v2Header } from './ID3v2Token.js';
 import { ID3v2Parser } from './ID3v2Parser.js';

package/lib/id3v2/FrameParser.js

@@ -159,7 +159,7 @@ export class FrameParser {
                     fzero = util.findZero(uint8Array, offset, length, encoding);
                     pic.description = util.decodeString(uint8Array.slice(offset, fzero), encoding);
                     offset = fzero + nullTerminatorLength;
-                    pic.data = Buffer.from(uint8Array.slice(offset, length));
+                    pic.data = uint8Array.slice(offset, length);
                     output = pic;
                 }
                 break;
@@ -246,7 +246,7 @@ export class FrameParser {
                 // Decode URL
                 fzero = util.findZero(uint8Array, offset + 1, length, encoding);
                 const description = util.decodeString(uint8Array.slice(offset + 1, fzero), encoding);
-                offset = fzero + (encoding === 'utf16le' ? 2 : 1);
+                offset = fzero + (encoding === 'utf-16le' ? 2 : 1);
                 output = { description, url: util.decodeString(uint8Array.slice(offset, length), defaultEnc) };
                 break;
             }
@@ -320,6 +320,6 @@ export class FrameParser {
         return { id, data: uint8Array.slice(offset, length) };
     }
     static getNullTerminatorLength(enc) {
-        return enc === 'utf16le' ? 2 : 1;
+        return enc === 'utf-16le' ? 2 : 1;
     }
 }

package/lib/id3v2/ID3v24TagMapper.d.ts

@@ -1,6 +1,6 @@
 import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
-import { INativeMetadataCollector } from '../common/MetadataCollector.js';
-import { IRating, ITag } from '../type.js';
+import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import type { IRating, ITag } from '../type.js';
 export declare class ID3v24TagMapper extends CaseInsensitiveTagMap {
     static toRating(popm: any): IRating;
     constructor();
@@ -8,7 +8,6 @@ export declare class ID3v24TagMapper extends CaseInsensitiveTagMap {
      * Handle post mapping exceptions / correction
      * @param tag to post map
      * @param warnings Wil be used to register (collect) warnings
-     * @return Common value e.g. "Buena Vista Social Club"
      */
     protected postMap(tag: ITag, warnings: INativeMetadataCollector): void;
 }

package/lib/id3v2/ID3v24TagMapper.js

@@ -1,6 +1,7 @@
+import { UINT32_LE } from 'token-types';
 import { CommonTagMapper } from '../common/GenericTagMapper.js';
 import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
-import * as util from '../common/Util.js';
+import { decodeString } from '../common/Util.js';
 /**
  * ID3v2.3/ID3v2.4 tag mappings
  */
@@ -152,7 +153,6 @@ export class ID3v24TagMapper extends CaseInsensitiveTagMap {
      * Handle post mapping exceptions / correction
      * @param tag to post map
      * @param warnings Wil be used to register (collect) warnings
-     * @return Common value e.g. "Buena Vista Social Club"
      */
     postMap(tag, warnings) {
         var _a, _b;
@@ -160,7 +160,7 @@ export class ID3v24TagMapper extends CaseInsensitiveTagMap {
             case 'UFID': // decode MusicBrainz Recording Id
                 if (tag.value.owner_identifier === 'http://musicbrainz.org') {
                     tag.id += ':' + tag.value.owner_identifier;
-                    tag.value = util.decodeString(tag.value.identifier, 'latin1'); // latin1 == iso-8859-1
+                    tag.value = decodeString(tag.value.identifier, 'latin1'); // latin1 == iso-8859-1
                 }
                 break;
             case 'PRIV':
@@ -169,7 +169,7 @@ export class ID3v24TagMapper extends CaseInsensitiveTagMap {
                     case 'AverageLevel':
                     case 'PeakValue':
                         tag.id += ':' + tag.value.owner_identifier;
-                        tag.value = tag.value.data.length === 4 ? tag.value.data.readUInt32LE(0) : null;
+                        tag.value = tag.value.data.length === 4 ? UINT32_LE.get(tag.value.data, 0) : null;
                         if (tag.value === null) {
                             warnings.addWarning(`Failed to parse PRIV:PeakValue`);
                         }

package/lib/id3v2/ID3v2Parser.d.ts

@@ -1,4 +1,4 @@
-import { ITokenizer } from 'strtok3/core';
+import type { ITokenizer } from 'strtok3';
 import { IOptions } from '../type.js';
 import { INativeMetadataCollector } from '../common/MetadataCollector.js';
 export declare class ID3v2Parser {

package/lib/id3v2/ID3v2Parser.js

@@ -2,6 +2,7 @@ import * as Token from 'token-types';
 import * as util from '../common/Util.js';
 import { FrameParser } from './FrameParser.js';
 import { ExtendedHeader, ID3v2Header, UINT32SYNCSAFE } from './ID3v2Token.js';
+const asciiDecoder = new TextDecoder('ascii');
 export class ID3v2Parser {
     static removeUnsyncBytes(buffer) {
         let readI = 0;
@@ -98,33 +99,25 @@ export class ID3v2Parser {
         for (const tag of this.parseMetadata(uint8Array)) {
             if (tag.id === 'TXXX') {
                 if (tag.value) {
-                    for (const text of tag.value.text) {
-                        this.addTag(ID3v2Parser.makeDescriptionTagName(tag.id, tag.value.description), text);
-                    }
+                    await Promise.all(tag.value.text.map(text => this.addTag(ID3v2Parser.makeDescriptionTagName(tag.id, tag.value.description), text)));
                 }
             }
             else if (tag.id === 'COM') {
-                for (const value of tag.value) {
-                    this.addTag(ID3v2Parser.makeDescriptionTagName(tag.id, value.description), value.text);
-                }
+                await Promise.all(tag.value.map(value => this.addTag(ID3v2Parser.makeDescriptionTagName(tag.id, value.description), value.text)));
             }
             else if (tag.id === 'COMM') {
-                for (const value of tag.value) {
-                    this.addTag(ID3v2Parser.makeDescriptionTagName(tag.id, value.description), value);
-                }
+                await Promise.all(tag.value.map(value => this.addTag(ID3v2Parser.makeDescriptionTagName(tag.id, value.description), value)));
             }
             else if (Array.isArray(tag.value)) {
-                for (const value of tag.value) {
-                    this.addTag(tag.id, value);
-                }
+                await Promise.all(tag.value.map(value => this.addTag(tag.id, value)));
             }
             else {
-                this.addTag(tag.id, tag.value);
+                await this.addTag(tag.id, tag.value);
             }
         }
     }
-    addTag(id, value) {
-        this.metadata.addTag(this.headerType, id, value);
+    async addTag(id, value) {
+        await this.metadata.addTag(this.headerType, id, value);
     }
     parseMetadata(data) {
         let offset = 0;
@@ -152,7 +145,7 @@ export class ID3v2Parser {
         switch (majorVer) {
             case 2:
                 header = {
-                    id: Buffer.from(uint8Array.slice(0, 3)).toString('ascii'),
+                    id: asciiDecoder.decode(uint8Array.slice(0, 3)),
                     length: Token.UINT24_BE.get(uint8Array, 3)
                 };
                 if (!header.id.match(/[A-Z0-9]{3}/g)) {
@@ -162,7 +155,7 @@ export class ID3v2Parser {
             case 3:
             case 4:
                 header = {
-                    id: Buffer.from(uint8Array.slice(0, 4)).toString('ascii'),
+                    id: asciiDecoder.decode(uint8Array.slice(0, 4)),
                     length: (majorVer === 4 ? UINT32SYNCSAFE : Token.UINT32_BE).get(uint8Array, 4),
                     flags: ID3v2Parser.readFrameFlags(uint8Array.slice(8, 10))
                 };

package/lib/id3v2/ID3v2Token.d.ts

@@ -1,4 +1,4 @@
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 import * as util from '../common/Util.js';
 /**
  * The picture type according to the ID3v2 APIC frame

package/lib/id3v2/ID3v2Token.js

@@ -91,9 +91,9 @@ export const TextEncodingToken = {
             case 0x00:
                 return { encoding: 'latin1' }; // binary
             case 0x01:
-                return { encoding: 'utf16le', bom: true };
+                return { encoding: 'utf-16le', bom: true };
             case 0x02:
-                return { encoding: 'utf16le', bom: false };
+                return { encoding: 'utf-16le', bom: false };
             case 0x03:
                 return { encoding: 'utf8', bom: false };
             default:

package/lib/iff/index.d.ts

@@ -1,4 +1,4 @@
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 /**
  * "EA IFF 85" Standard for Interchange Format Files
  * Ref: http://www.martinreddy.net/gfx/2d/IFF.txt

package/lib/index.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" resolution-mode="require"/>
 import * as Stream from 'stream';
 import * as strtok3 from 'strtok3';
 import { IAudioMetadata, IOptions } from './type.js';
 export { IAudioMetadata, IOptions, ITag, INativeTagDict, ICommonTagsResult, IFormat, IPicture, IRatio, IChapter } from './type.js';
-export { parseFromTokenizer, parseBuffer, selectCover, orderTags, ratingToStars, IFileInfo } from './core.js';
+export { parseFromTokenizer, parseBuffer, parseBlob, selectCover, orderTags, ratingToStars, IFileInfo } from './core.js';
 /**
  * Parse audio from Node Stream.Readable
  * @param stream - Stream to read the audio track from

package/lib/index.js

@@ -3,7 +3,7 @@ import initDebug from 'debug';
 import { parseFromTokenizer, scanAppendingHeaders } from './core.js';
 import { ParserFactory } from './ParserFactory.js';
 import { RandomFileReader } from './common/RandomFileReader.js';
-export { parseFromTokenizer, parseBuffer, selectCover, orderTags, ratingToStars } from './core.js';
+export { parseFromTokenizer, parseBuffer, parseBlob, selectCover, orderTags, ratingToStars } from './core.js';
 const debug = initDebug('music-metadata:parser');
 /**
  * Parse audio from Node Stream.Readable