music-metadata 7.12.0 → 7.12.1

package/lib/asf/AsfObject.d.ts

@@ -294,7 +294,7 @@ export declare class ExtendedStreamPropertiesObjectState extends State<IExtended
 export declare class MetadataObjectState extends State<ITag[]> {
     static guid: GUID;
     constructor(header: IAsfObjectHeader);
-    get(buf: Buffer, off: number): ITag[];
+    get(uint8Array: Uint8Array, off: number): ITag[];
 }
 export declare class MetadataLibraryObjectState extends MetadataObjectState {
     static guid: GUID;

package/lib/asf/AsfObject.js

@@ -311,8 +311,9 @@ class MetadataObjectState extends State {
     constructor(header) {
         super(header);
     }
-    get(buf, off) {
+    get(uint8Array, off) {
         const tags = [];
+        const buf = Buffer.from(uint8Array);
         const descriptionRecordsCount = buf.readUInt16LE(off);
         let pos = off + 2;
         for (let i = 0; i < descriptionRecordsCount; i += 1) {
@@ -327,10 +328,6 @@ class MetadataObjectState extends State {
             pos += nameLen;
             const data = buf.slice(pos, pos + dataLen);
             pos += dataLen;
-            const parseAttr = AsfUtil_1.AsfUtil.getParserForAttr(dataType);
-            if (!parseAttr) {
-                throw new Error('unexpected value headerType: ' + dataType);
-            }
             this.postProcessTag(tags, name, dataType, data);
         }
         return tags;

package/lib/asf/AsfUtil.d.ts

@@ -3,7 +3,7 @@ import { DataType } from './AsfObject';
 export declare type AttributeParser = (buf: Buffer) => boolean | string | number | bigint | Buffer;
 export declare class AsfUtil {
     static getParserForAttr(i: DataType): AttributeParser;
-    static parseUnicodeAttr(buf: any): string;
+    static parseUnicodeAttr(uint8Array: Uint8Array): string;
     private static attributeParsers;
     private static parseByteArrayAttr;
     private static parseBoolAttr;

package/lib/asf/AsfUtil.js

@@ -7,13 +7,11 @@ class AsfUtil {
     static getParserForAttr(i) {
         return AsfUtil.attributeParsers[i];
     }
-    static parseUnicodeAttr(buf) {
-        return util.stripNulls(util.decodeString(buf, 'utf16le'));
+    static parseUnicodeAttr(uint8Array) {
+        return util.stripNulls(util.decodeString(uint8Array, 'utf16le'));
     }
     static parseByteArrayAttr(buf) {
-        const newBuf = Buffer.alloc(buf.length);
-        buf.copy(newBuf);
-        return newBuf;
+        return Buffer.from(buf);
     }
     static parseBoolAttr(buf, offset = 0) {
         return AsfUtil.parseWordAttr(buf, offset) === 1;

package/lib/common/Util.d.ts

@@ -23,22 +23,22 @@ export declare function stripNulls(str: string): string;
 /**
  * Read bit-aligned number start from buffer
  * Total offset in bits = byteOffset * 8 + bitOffset
- * @param buf Byte buffer
+ * @param source Byte buffer
  * @param byteOffset Starting offset in bytes
  * @param bitOffset Starting offset in bits: 0 = lsb
  * @param len Length of number in bits
- * @return {number} decoded bit aligned number
+ * @return Decoded bit aligned number
  */
-export declare function getBitAllignedNumber(buf: Uint8Array, byteOffset: number, bitOffset: number, len: number): number;
+export declare function getBitAllignedNumber(source: Uint8Array, byteOffset: number, bitOffset: number, len: number): number;
 /**
  * Read bit-aligned number start from buffer
  * Total offset in bits = byteOffset * 8 + bitOffset
- * @param buf Byte buffer
+ * @param source Byte Uint8Array
  * @param byteOffset Starting offset in bytes
- * @param bitOffset Starting offset in bits: 0 = most significant bit, 7 is least significant bit
- * @return {number} decoded bit aligned number
+ * @param bitOffset Starting offset in bits: 0 = most significant bit, 7 is the least significant bit
+ * @return True if bit is set
  */
-export declare function isBitSet(buf: Uint8Array, byteOffset: number, bitOffset: number): boolean;
+export declare function isBitSet(source: Uint8Array, byteOffset: number, bitOffset: number): boolean;
 export declare function a2hex(str: string): string;
 /**
  * Convert power ratio to DB

package/lib/common/Util.js

@@ -76,16 +76,16 @@ exports.stripNulls = stripNulls;
 /**
  * Read bit-aligned number start from buffer
  * Total offset in bits = byteOffset * 8 + bitOffset
- * @param buf Byte buffer
+ * @param source Byte buffer
  * @param byteOffset Starting offset in bytes
  * @param bitOffset Starting offset in bits: 0 = lsb
  * @param len Length of number in bits
- * @return {number} decoded bit aligned number
+ * @return Decoded bit aligned number
  */
-function getBitAllignedNumber(buf, byteOffset, bitOffset, len) {
+function getBitAllignedNumber(source, byteOffset, bitOffset, len) {
     const byteOff = byteOffset + ~~(bitOffset / 8);
     const bitOff = bitOffset % 8;
-    let value = buf[byteOff];
+    let value = source[byteOff];
     value &= 0xff >> bitOff;
     const bitsRead = 8 - bitOff;
     const bitsLeft = len - bitsRead;
@@ -94,7 +94,7 @@ function getBitAllignedNumber(buf, byteOffset, bitOffset, len) {
     }
     else if (bitsLeft > 0) {
         value <<= bitsLeft;
-        value |= getBitAllignedNumber(buf, byteOffset, bitOffset + bitsRead, bitsLeft);
+        value |= getBitAllignedNumber(source, byteOffset, bitOffset + bitsRead, bitsLeft);
     }
     return value;
 }
@@ -102,13 +102,13 @@ exports.getBitAllignedNumber = getBitAllignedNumber;
 /**
  * Read bit-aligned number start from buffer
  * Total offset in bits = byteOffset * 8 + bitOffset
- * @param buf Byte buffer
+ * @param source Byte Uint8Array
  * @param byteOffset Starting offset in bytes
- * @param bitOffset Starting offset in bits: 0 = most significant bit, 7 is least significant bit
- * @return {number} decoded bit aligned number
+ * @param bitOffset Starting offset in bits: 0 = most significant bit, 7 is the least significant bit
+ * @return True if bit is set
  */
-function isBitSet(buf, byteOffset, bitOffset) {
-    return getBitAllignedNumber(buf, byteOffset, bitOffset, 1) === 1;
+function isBitSet(source, byteOffset, bitOffset) {
+    return getBitAllignedNumber(source, byteOffset, bitOffset, 1) === 1;
 }
 exports.isBitSet = isBitSet;
 function a2hex(str) {

package/lib/id3v2/FrameParser.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { ID3v2MajorVersion } from './ID3v2Token';
 import { IWarningCollector } from '../common/MetadataCollector';
 export declare function parseGenre(origVal: string): string[];
@@ -11,7 +10,7 @@ export declare class FrameParser {
      * @param warningCollector - Used to collect decode issue
      */
     constructor(major: ID3v2MajorVersion, warningCollector: IWarningCollector);
-    readData(b: Buffer, type: string, includeCovers: boolean): any;
+    readData(uint8Array: Uint8Array, type: string, includeCovers: boolean): any;
     protected static fixPictureMimeType(pictureType: string): string;
     /**
      * Converts TMCL (Musician credits list) or TIPL (Involved people list)

package/lib/id3v2/FrameParser.js

@@ -68,13 +68,13 @@ class FrameParser {
         this.major = major;
         this.warningCollector = warningCollector;
     }
-    readData(b, type, includeCovers) {
-        if (b.length === 0) {
+    readData(uint8Array, type, includeCovers) {
+        if (uint8Array.length === 0) {
             this.warningCollector.addWarning(`id3v2.${this.major} header has empty tag type=${type}`);
             return;
         }
-        const { encoding, bom } = ID3v2Token_1.TextEncodingToken.get(b, 0);
-        const length = b.length;
+        const { encoding, bom } = ID3v2Token_1.TextEncodingToken.get(uint8Array, 0);
+        const length = uint8Array.length;
         let offset = 0;
         let output = []; // ToDo
         const nullTerminatorLength = FrameParser.getNullTerminatorLength(encoding);
@@ -90,7 +90,7 @@ class FrameParser {
             case 'PCST':
                 let text;
                 try {
-                    text = util.decodeString(b.subarray(1), encoding).replace(/\x00+$/, '');
+                    text = util.decodeString(uint8Array.slice(1), encoding).replace(/\x00+$/, '');
                 }
                 catch (error) {
                     this.warningCollector.addWarning(`id3v2.${this.major} type=${type} header has invalid string value: ${error.message}`);
@@ -131,7 +131,7 @@ class FrameParser {
                 }
                 break;
             case 'TXXX':
-                output = FrameParser.readIdentifierAndData(b, offset + 1, length, encoding);
+                output = FrameParser.readIdentifierAndData(uint8Array, offset + 1, length, encoding);
                 output = {
                     description: output.id,
                     text: this.splitValue(type, util.decodeString(output.data, encoding).replace(/\x00+$/, ''))
@@ -144,31 +144,31 @@ class FrameParser {
                     offset += 1;
                     switch (this.major) {
                         case 2:
-                            pic.format = util.decodeString(b.slice(offset, offset + 3), 'latin1'); // 'latin1'; // latin1 == iso-8859-1;
+                            pic.format = util.decodeString(uint8Array.slice(offset, offset + 3), 'latin1'); // 'latin1'; // latin1 == iso-8859-1;
                             offset += 3;
                             break;
                         case 3:
                         case 4:
-                            fzero = util.findZero(b, offset, length, defaultEnc);
-                            pic.format = util.decodeString(b.slice(offset, fzero), defaultEnc);
+                            fzero = util.findZero(uint8Array, offset, length, defaultEnc);
+                            pic.format = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
                             offset = fzero + 1;
                             break;
                         default:
                             throw new Error('Warning: unexpected major versionIndex: ' + this.major);
                     }
                     pic.format = FrameParser.fixPictureMimeType(pic.format);
-                    pic.type = ID3v2Token_1.AttachedPictureType[b[offset]];
+                    pic.type = ID3v2Token_1.AttachedPictureType[uint8Array[offset]];
                     offset += 1;
-                    fzero = util.findZero(b, offset, length, encoding);
-                    pic.description = util.decodeString(b.slice(offset, fzero), encoding);
+                    fzero = util.findZero(uint8Array, offset, length, encoding);
+                    pic.description = util.decodeString(uint8Array.slice(offset, fzero), encoding);
                     offset = fzero + nullTerminatorLength;
-                    pic.data = Buffer.from(b.slice(offset, length));
+                    pic.data = Buffer.from(uint8Array.slice(offset, length));
                     output = pic;
                 }
                 break;
             case 'CNT':
             case 'PCNT':
-                output = Token.UINT32_BE.get(b, 0);
+                output = Token.UINT32_BE.get(uint8Array, 0);
                 break;
             case 'SYLT':
                 // skip text encoding (1 byte),
@@ -179,7 +179,7 @@ class FrameParser {
                 offset += 7;
                 output = [];
                 while (offset < length) {
-                    const txt = b.slice(offset, offset = util.findZero(b, offset, length, encoding));
+                    const txt = uint8Array.slice(offset, offset = util.findZero(uint8Array, offset, length, encoding));
                     offset += 5; // push offset forward one +  4 byte timestamp
                     output.push(util.decodeString(txt, encoding));
                 }
@@ -189,47 +189,47 @@ class FrameParser {
             case 'COM':
             case 'COMM':
                 offset += 1;
-                out.language = util.decodeString(b.slice(offset, offset + 3), defaultEnc);
+                out.language = util.decodeString(uint8Array.slice(offset, offset + 3), defaultEnc);
                 offset += 3;
-                fzero = util.findZero(b, offset, length, encoding);
-                out.description = util.decodeString(b.slice(offset, fzero), encoding);
+                fzero = util.findZero(uint8Array, offset, length, encoding);
+                out.description = util.decodeString(uint8Array.slice(offset, fzero), encoding);
                 offset = fzero + nullTerminatorLength;
-                out.text = util.decodeString(b.slice(offset, length), encoding).replace(/\x00+$/, '');
+                out.text = util.decodeString(uint8Array.slice(offset, length), encoding).replace(/\x00+$/, '');
                 output = [out];
                 break;
             case 'UFID':
-                output = FrameParser.readIdentifierAndData(b, offset, length, defaultEnc);
+                output = FrameParser.readIdentifierAndData(uint8Array, offset, length, defaultEnc);
                 output = { owner_identifier: output.id, identifier: output.data };
                 break;
             case 'PRIV': // private frame
-                output = FrameParser.readIdentifierAndData(b, offset, length, defaultEnc);
+                output = FrameParser.readIdentifierAndData(uint8Array, offset, length, defaultEnc);
                 output = { owner_identifier: output.id, data: output.data };
                 break;
             case 'POPM': // Popularimeter
-                fzero = util.findZero(b, offset, length, defaultEnc);
-                const email = util.decodeString(b.slice(offset, fzero), defaultEnc);
+                fzero = util.findZero(uint8Array, offset, length, defaultEnc);
+                const email = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
                 offset = fzero + 1;
                 const dataLen = length - offset;
                 output = {
                     email,
-                    rating: b.readUInt8(offset),
-                    counter: dataLen >= 5 ? b.readUInt32BE(offset + 1) : undefined
+                    rating: Token.UINT8.get(uint8Array, offset),
+                    counter: dataLen >= 5 ? Token.UINT32_BE.get(uint8Array, offset + 1) : undefined
                 };
                 break;
             case 'GEOB': { // General encapsulated object
-                fzero = util.findZero(b, offset + 1, length, encoding);
-                const mimeType = util.decodeString(b.slice(offset + 1, fzero), defaultEnc);
+                fzero = util.findZero(uint8Array, offset + 1, length, encoding);
+                const mimeType = util.decodeString(uint8Array.slice(offset + 1, fzero), defaultEnc);
                 offset = fzero + 1;
-                fzero = util.findZero(b, offset, length - offset, encoding);
-                const filename = util.decodeString(b.slice(offset, fzero), defaultEnc);
+                fzero = util.findZero(uint8Array, offset, length - offset, encoding);
+                const filename = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
                 offset = fzero + 1;
-                fzero = util.findZero(b, offset, length - offset, encoding);
-                const description = util.decodeString(b.slice(offset, fzero), defaultEnc);
+                fzero = util.findZero(uint8Array, offset, length - offset, encoding);
+                const description = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
                 output = {
                     type: mimeType,
                     filename,
                     description,
-                    data: b.slice(offset + 1, length)
+                    data: uint8Array.slice(offset + 1, length)
                 };
                 break;
             }
@@ -243,23 +243,23 @@ class FrameParser {
             case 'WPAY':
             case 'WPUB':
                 // Decode URL
-                output = util.decodeString(b.slice(offset, fzero), defaultEnc);
+                output = util.decodeString(uint8Array.slice(offset, fzero), defaultEnc);
                 break;
             case 'WXXX': {
                 // Decode URL
-                fzero = util.findZero(b, offset + 1, length, encoding);
-                const description = util.decodeString(b.slice(offset + 1, fzero), encoding);
+                fzero = util.findZero(uint8Array, offset + 1, length, encoding);
+                const description = util.decodeString(uint8Array.slice(offset + 1, fzero), encoding);
                 offset = fzero + (encoding === 'utf16le' ? 2 : 1);
-                output = { description, url: util.decodeString(b.slice(offset, length), defaultEnc) };
+                output = { description, url: util.decodeString(uint8Array.slice(offset, length), defaultEnc) };
                 break;
             }
             case 'WFD':
             case 'WFED':
-                output = util.decodeString(b.slice(offset + 1, util.findZero(b, offset + 1, length, encoding)), encoding);
+                output = util.decodeString(uint8Array.slice(offset + 1, util.findZero(uint8Array, offset + 1, length, encoding)), encoding);
                 break;
             case 'MCDI': {
                 // Music CD identifier
-                output = b.slice(0, length);
+                output = uint8Array.slice(0, length);
                 break;
             }
             default:
@@ -316,11 +316,11 @@ class FrameParser {
     static trimArray(values) {
         return values.map(value => value.replace(/\x00+$/, '').trim());
     }
-    static readIdentifierAndData(b, offset, length, encoding) {
-        const fzero = util.findZero(b, offset, length, encoding);
-        const id = util.decodeString(b.slice(offset, fzero), encoding);
+    static readIdentifierAndData(uint8Array, offset, length, encoding) {
+        const fzero = util.findZero(uint8Array, offset, length, encoding);
+        const id = util.decodeString(uint8Array.slice(offset, fzero), encoding);
         offset = fzero + FrameParser.getNullTerminatorLength(encoding);
-        return { id, data: b.slice(offset, length) };
+        return { id, data: uint8Array.slice(offset, length) };
     }
     static getNullTerminatorLength(enc) {
         return enc === 'utf16le' ? 2 : 1;

package/lib/id3v2/ID3v2Parser.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" />
 import { ITokenizer } from 'strtok3/lib/core';
 import { IOptions } from '../type';
 import { INativeMetadataCollector } from '../common/MetadataCollector';
 export declare class ID3v2Parser {
-    static removeUnsyncBytes(buffer: Buffer): Buffer;
+    static removeUnsyncBytes(buffer: Uint8Array): Uint8Array;
     private static getFrameHeaderLength;
     private static readFrameFlags;
     private static readFrameData;

package/lib/id3v2/ID3v2Parser.js

@@ -48,20 +48,20 @@ class ID3v2Parser {
             }
         };
     }
-    static readFrameData(buf, frameHeader, majorVer, includeCovers, warningCollector) {
+    static readFrameData(uint8Array, frameHeader, majorVer, includeCovers, warningCollector) {
         const frameParser = new FrameParser_1.FrameParser(majorVer, warningCollector);
         switch (majorVer) {
             case 2:
-                return frameParser.readData(buf, frameHeader.id, includeCovers);
+                return frameParser.readData(uint8Array, frameHeader.id, includeCovers);
             case 3:
             case 4:
                 if (frameHeader.flags.format.unsynchronisation) {
-                    buf = ID3v2Parser.removeUnsyncBytes(buf);
+                    uint8Array = ID3v2Parser.removeUnsyncBytes(uint8Array);
                 }
                 if (frameHeader.flags.format.data_length_indicator) {
-                    buf = buf.slice(4, buf.length);
+                    uint8Array = uint8Array.slice(4, uint8Array.length);
                 }
-                return frameParser.readData(buf, frameHeader.id, includeCovers);
+                return frameParser.readData(uint8Array, frameHeader.id, includeCovers);
             default:
                 throw new Error('Unexpected majorVer: ' + majorVer);
         }
@@ -93,14 +93,12 @@ class ID3v2Parser {
         return dataRemaining > 0 ? this.parseExtendedHeaderData(dataRemaining, extendedHeader.size) : this.parseId3Data(this.id3Header.size - extendedHeader.size);
     }
     async parseExtendedHeaderData(dataRemaining, extendedHeaderSize) {
-        const buffer = Buffer.alloc(dataRemaining);
-        await this.tokenizer.readBuffer(buffer, { length: dataRemaining });
+        await this.tokenizer.ignore(dataRemaining);
         return this.parseId3Data(this.id3Header.size - extendedHeaderSize);
     }
     async parseId3Data(dataLen) {
-        const buffer = Buffer.alloc(dataLen);
-        await this.tokenizer.readBuffer(buffer, { length: dataLen });
-        for (const tag of this.parseMetadata(buffer)) {
+        const uint8Array = await this.tokenizer.readToken(new Token.Uint8ArrayType(dataLen));
+        for (const tag of this.parseMetadata(uint8Array)) {
             if (tag.id === 'TXXX') {
                 if (tag.value) {
                     for (const text of tag.value.text) {
@@ -152,13 +150,13 @@ class ID3v2Parser {
         }
         return tags;
     }
-    readFrameHeader(v, majorVer) {
+    readFrameHeader(uint8Array, majorVer) {
         let header;
         switch (majorVer) {
             case 2:
                 header = {
-                    id: v.toString('ascii', 0, 3),
-                    length: Token.UINT24_BE.get(v, 3)
+                    id: Buffer.from(uint8Array.slice(0, 3)).toString('ascii'),
+                    length: Token.UINT24_BE.get(uint8Array, 3)
                 };
                 if (!header.id.match(/[A-Z0-9]{3}/g)) {
                     this.metadata.addWarning(`Invalid ID3v2.${this.id3Header.version.major} frame-header-ID: ${header.id}`);
@@ -167,9 +165,9 @@ class ID3v2Parser {
             case 3:
             case 4:
                 header = {
-                    id: v.toString('ascii', 0, 4),
-                    length: (majorVer === 4 ? ID3v2Token_1.UINT32SYNCSAFE : Token.UINT32_BE).get(v, 4),
-                    flags: ID3v2Parser.readFrameFlags(v.slice(8, 10))
+                    id: Buffer.from(uint8Array.slice(0, 4)).toString('ascii'),
+                    length: (majorVer === 4 ? ID3v2Token_1.UINT32SYNCSAFE : Token.UINT32_BE).get(uint8Array, 4),
+                    flags: ID3v2Parser.readFrameFlags(uint8Array.slice(8, 10))
                 };
                 if (!header.id.match(/[A-Z0-9]{4}/g)) {
                     this.metadata.addWarning(`Invalid ID3v2.${this.id3Header.version.major} frame-header-ID: ${header.id}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "music-metadata",
   "description": "Music metadata parser for Node.js, supporting virtual any audio and tag format.",
-  "version": "7.12.0",
+  "version": "7.12.1",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"