music-metadata 7.11.8 → 7.12.1

package/LICENSE.txt

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright © 2022 Borewit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -26,6 +26,7 @@ Supports any common audio and tagging format.
 | AAC           | ADTS / Advanced Audio Coding    | [:link:](https://en.wikipedia.org/wiki/Advanced_Audio_Coding)      | <img src="https://svgshare.com/i/UT8.svg" width="40" alt="AAC logo">                                                                          |
 | APE           | Monkey's Audio                  | [:link:](https://wikipedia.org/wiki/Monkey's_Audio)                | <img src="https://foreverhits.files.wordpress.com/2015/05/ape_audio.jpg" width="40" alt="Monkey's Audio logo">                                |
 | ASF           | Advanced Systems Format         | [:link:](https://wikipedia.org/wiki/Advanced_Systems_Format)       |                                                                                                                                               |
+| BWF           | Broadcast Wave Format           | [:link:](https://en.wikipedia.org/wiki/Broadcast_Wave_Format)      |                                                                                                                                               |  
 | DSDIFF        | Philips DSDIFF                  | [:link:](https://wikipedia.org/wiki/Direct_Stream_Digital)         | <img src="https://upload.wikimedia.org/wikipedia/commons/b/bc/DSDlogo.svg" width="80" alt="DSD logo">                                         |
 | DSF           | Sony's DSD Stream File          | [:link:](https://wikipedia.org/wiki/Direct_Stream_Digital)         | <img src="https://upload.wikimedia.org/wikipedia/commons/b/bc/DSDlogo.svg" width="80" alt="DSD logo">                                         |
 | FLAC          | Free Lossless Audio Codec       | [:link:](https://wikipedia.org/wiki/FLAC)                          | <img src="https://upload.wikimedia.org/wikipedia/commons/a/a2/FLAC_logo_vector.svg" width="80" alt="FLAC logo">                               |
@@ -422,12 +423,12 @@ img.src = `data:${picture.format};base64,${picture.data.toString('base64')}`;
 
 ## Licence
 
-(The MIT License)
+The MIT License (MIT)
 
-Copyright (c) 2017 Borewit
+Copyright © 2022 Borewit
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/lib/ParserFactory.js

@@ -121,6 +121,7 @@ class ParserFactory {
             case '.aifc':
                 return 'aiff';
             case '.wav':
+            case '.bwf': // Broadcast Wave Format
                 return 'riff';
             case '.wv':
             case '.wvp':

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/RandomFileReader.d.ts

@@ -4,9 +4,10 @@ import { IRandomReader } from '../type';
  * Provides abstract file access via the IRandomRead interface
  */
 export declare class RandomFileReader implements IRandomReader {
+    private readonly fileHandle;
+    filePath: string;
     fileSize: number;
-    private readonly fd;
-    constructor(filePath: string, fileSize: number);
+    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.
@@ -16,5 +17,6 @@ export declare class RandomFileReader implements IRandomReader {
      * @return {Promise<number>} bytes read
      */
     randomRead(buffer: Buffer, offset: number, length: number, position: number): Promise<number>;
-    close(): void;
+    close(): Promise<void>;
+    static init(filePath: string, fileSize: number): Promise<RandomFileReader>;
 }

package/lib/common/RandomFileReader.js

@@ -6,9 +6,10 @@ const fs = require("fs");
  * Provides abstract file access via the IRandomRead interface
  */
 class RandomFileReader {
-    constructor(filePath, fileSize) {
+    constructor(fileHandle, filePath, fileSize) {
+        this.fileHandle = fileHandle;
+        this.filePath = filePath;
         this.fileSize = fileSize;
-        this.fd = fs.openSync(filePath, 'r');
     }
     /**
      * Read from a given position of an abstracted file or buffer.
@@ -18,20 +19,16 @@ class RandomFileReader {
      * @param position {number} is an argument specifying where to begin reading from in the file.
      * @return {Promise<number>} bytes read
      */
-    randomRead(buffer, offset, length, position) {
-        return new Promise((resolve, reject) => {
-            fs.read(this.fd, buffer, offset, length, position, (err, bytesRead) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(bytesRead);
-                }
-            });
-        });
+    async randomRead(buffer, offset, length, position) {
+        const result = await this.fileHandle.read(buffer, offset, length, position);
+        return result.bytesRead;
     }
-    close() {
-        fs.closeSync(this.fd);
+    async close() {
+        return this.fileHandle.close();
+    }
+    static async init(filePath, fileSize) {
+        const fileHandle = await fs.promises.open(filePath, 'r');
+        return new RandomFileReader(fileHandle, filePath, fileSize);
     }
 }
 exports.RandomFileReader = RandomFileReader;

package/lib/common/Util.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { IRatio } from '../type';
 export declare type StringEncoding = 'ascii' | 'utf8' | 'utf16le' | 'ucs2' | 'base64url' | 'latin1' | 'hex';
 export interface ITextEncoding {
@@ -19,27 +18,27 @@ export declare function trimRightNull(x: string): string;
 /**
  * Decode string
  */
-export declare function decodeString(buffer: Buffer, encoding: StringEncoding): string;
+export declare function decodeString(uint8Array: Uint8Array, encoding: StringEncoding): string;
 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

@@ -52,19 +52,19 @@ function swapBytes(uint8Array) {
 /**
  * Decode string
  */
-function decodeString(buffer, encoding) {
+function decodeString(uint8Array, encoding) {
     // annoying workaround for a double BOM issue
     // https://github.com/leetreveil/musicmetadata/issues/84
-    if (buffer[0] === 0xFF && buffer[1] === 0xFE) { // little endian
-        return decodeString(buffer.subarray(2), encoding);
+    if (uint8Array[0] === 0xFF && uint8Array[1] === 0xFE) { // little endian
+        return decodeString(uint8Array.subarray(2), encoding);
     }
-    else if (encoding === 'utf16le' && buffer[0] === 0xFE && buffer[1] === 0xFF) {
+    else if (encoding === 'utf16le' && uint8Array[0] === 0xFE && uint8Array[1] === 0xFF) {
         // BOM, indicating big endian decoding
-        if ((buffer.length & 1) !== 0)
+        if ((uint8Array.length & 1) !== 0)
             throw new Error('Expected even number of octets for 16-bit unicode string');
-        return decodeString(swapBytes(buffer), encoding);
+        return decodeString(swapBytes(uint8Array), encoding);
     }
-    return buffer.toString(encoding);
+    return Buffer.from(uint8Array).toString(encoding);
 }
 exports.decodeString = decodeString;
 function stripNulls(str) {
@@ -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/lib/index.js

@@ -32,12 +32,12 @@ exports.parseStream = parseStream;
 async function parseFile(filePath, options = {}) {
     debug(`parseFile: ${filePath}`);
     const fileTokenizer = await strtok3.fromFile(filePath);
-    const fileReader = new RandomFileReader_1.RandomFileReader(filePath, fileTokenizer.fileInfo.size);
+    const fileReader = await RandomFileReader_1.RandomFileReader.init(filePath, fileTokenizer.fileInfo.size);
     try {
         await Core.scanAppendingHeaders(fileReader, options);
     }
     finally {
-        fileReader.close();
+        await fileReader.close();
     }
     try {
         const parserName = ParserFactory_1.ParserFactory.getParserIdForExtension(filePath);

package/lib/wav/BwfChunk.d.ts

@@ -0,0 +1,17 @@
+import { IGetToken } from 'strtok3/lib/core';
+export interface IBroadcastAudioExtensionChunk {
+    description: string;
+    originator: string;
+    originatorReference: string;
+    originationDate: string;
+    originationTime: string;
+    timeReferenceLow: number;
+    timeReferenceHigh: number;
+    version: number;
+    umid: Uint8Array;
+}
+/**
+ * Broadcast Audio Extension Chunk
+ * Ref: https://tech.ebu.ch/docs/tech/tech3285.pdf
+ */
+export declare const BroadcastAudioExtensionChunk: IGetToken<IBroadcastAudioExtensionChunk>;

package/lib/wav/BwfChunk.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BroadcastAudioExtensionChunk = void 0;
+const Token = require("token-types");
+/**
+ * Broadcast Audio Extension Chunk
+ * Ref: https://tech.ebu.ch/docs/tech/tech3285.pdf
+ */
+exports.BroadcastAudioExtensionChunk = {
+    len: 420,
+    get: (uint8array, off) => {
+        return {
+            description: new Token.StringType(256, 'ascii').get(uint8array, off).trim(),
+            originator: new Token.StringType(32, 'ascii').get(uint8array, off + 256).trim(),
+            originatorReference: new Token.StringType(32, 'ascii').get(uint8array, off + 288).trim(),
+            originationDate: new Token.StringType(10, 'ascii').get(uint8array, off + 320).trim(),
+            originationTime: new Token.StringType(8, 'ascii').get(uint8array, off + 330).trim(),
+            timeReferenceLow: Token.UINT32_LE.get(uint8array, off + 338),
+            timeReferenceHigh: Token.UINT32_LE.get(uint8array, off + 342),
+            version: Token.UINT16_LE.get(uint8array, off + 346),
+            umid: new Token.Uint8ArrayType(64).get(uint8array, off + 348),
+            loudnessValue: Token.UINT16_LE.get(uint8array, off + 412),
+            maxTruePeakLevel: Token.UINT16_LE.get(uint8array, off + 414),
+            maxMomentaryLoudness: Token.UINT16_LE.get(uint8array, off + 416),
+            maxShortTermLoudness: Token.UINT16_LE.get(uint8array, off + 418)
+        };
+    }
+};

package/lib/wav/WaveParser.js

@@ -10,6 +10,7 @@ const ID3v2Parser_1 = require("../id3v2/ID3v2Parser");
 const util = require("../common/Util");
 const FourCC_1 = require("../common/FourCC");
 const BasicParser_1 = require("../common/BasicParser");
+const BwfChunk_1 = require("../wav/BwfChunk");
 const debug = initDebug('music-metadata:parser:RIFF');
 /**
  * Resource Interchange File Format (RIFF) Parser
@@ -101,6 +102,17 @@ class WaveParser extends BasicParser_1.BasicParser {
                     this.metadata.setFormat('bitrate', this.metadata.format.numberOfChannels * this.blockAlign * this.metadata.format.sampleRate); // ToDo: check me
                     await this.tokenizer.ignore(header.chunkSize);
                     break;
+                case 'bext': // Broadcast Audio Extension chunk	https://tech.ebu.ch/docs/tech/tech3285.pdf
+                    const bext = await this.tokenizer.readToken(BwfChunk_1.BroadcastAudioExtensionChunk);
+                    Object.keys(bext).forEach(key => {
+                        this.metadata.addTag('exif', 'bext.' + key, bext[key]);
+                    });
+                    break;
+                case '\x00\x00\x00\x00': // padding ??
+                    debug(`Ignore padding chunk: RIFF/${header.chunkID} of ${header.chunkSize} bytes`);
+                    this.metadata.addWarning('Ignore chunk: RIFF/' + header.chunkID);
+                    await this.tokenizer.ignore(header.chunkSize);
+                    break;
                 default:
                     debug(`Ignore chunk: RIFF/${header.chunkID} of ${header.chunkSize} bytes`);
                     this.metadata.addWarning('Ignore chunk: RIFF/' + header.chunkID);

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.11.8",
+  "version": "7.12.1",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"
@@ -57,7 +57,8 @@
     "chapter",
     "info",
     "parse",
-    "parser"
+    "parser",
+    "bwf"
   ],
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -89,35 +90,34 @@
     "file-type": "16.5.3",
     "media-typer": "^1.1.0",
     "strtok3": "^6.2.4",
-    "token-types": "^4.1.1"
+    "token-types": "^4.2.0"
   },
   "devDependencies": {
     "@types/chai": "^4.3.0",
     "@types/debug": "^4.1.7",
     "@types/file-type": "^10.9.1",
     "@types/mocha": "^9.1.0",
-    "@types/node": "^17.0.12",
-    "@typescript-eslint/eslint-plugin": "^5.10.1",
-    "@typescript-eslint/parser": "^5.10.1",
+    "@types/node": "^17.0.21",
+    "@typescript-eslint/eslint-plugin": "^5.12.1",
+    "@typescript-eslint/parser": "^5.12.1",
     "chai": "^4.3.6",
     "coveralls": "^3.1.1",
     "del-cli": "4.0.1",
-    "eslint": "^8.8.0",
-    "eslint-config-prettier": "^8.3.0",
+    "eslint": "^8.9.0",
+    "eslint-config-prettier": "^8.4.0",
     "eslint-import-resolver-typescript": "^2.5.0",
     "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-jsdoc": "^37.7.0",
+    "eslint-plugin-jsdoc": "^37.9.4",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-unicorn": "^40.1.0",
+    "eslint-plugin-unicorn": "^41.0.0",
     "mime": "^3.0.0",
-    "mocha": "^9.2.0",
+    "mocha": "^9.2.1",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.1.0",
-    "prettier": "^2.5.1",
     "remark-cli": "^10.0.1",
     "remark-preset-lint-recommended": "^6.1.2",
     "source-map-support": "^0.5.21",
-    "ts-node": "^10.3.0",
+    "ts-node": "^10.5.0",
     "typescript": "^4.5.5"
   },
   "engines": {