music-metadata 7.11.7 → 7.12.0

package/lib/common/RandomFileReader.js

@@ -1,37 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RandomFileReader = void 0;
-const fs = require("fs");
-/**
- * Provides abstract file access via the IRandomRead interface
- */
-class RandomFileReader {
-    constructor(filePath, fileSize) {
-        this.fileSize = fileSize;
-        this.fd = fs.openSync(filePath, 'r');
-    }
-    /**
-     * 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 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, 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);
-                }
-            });
-        });
-    }
-    close() {
-        fs.closeSync(this.fd);
-    }
-}
-exports.RandomFileReader = RandomFileReader;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomFileReader = void 0;
+const fs = require("fs");
+/**
+ * Provides abstract file access via the IRandomRead interface
+ */
+class RandomFileReader {
+    constructor(fileHandle, filePath, fileSize) {
+        this.fileHandle = fileHandle;
+        this.filePath = filePath;
+        this.fileSize = fileSize;
+    }
+    /**
+     * 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 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
+     */
+    async randomRead(buffer, offset, length, position) {
+        const result = await this.fileHandle.read(buffer, offset, length, position);
+        return result.bytesRead;
+    }
+    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/RandomUint8ArrayReader.d.ts

@@ -1,18 +1,18 @@
-import { IRandomReader } from '../type';
-/**
- * Provides abstract Uint8Array access via the IRandomRead interface
- */
-export declare class RandomUint8ArrayReader implements IRandomReader {
-    private readonly uint8Array;
-    readonly fileSize: number;
-    constructor(uint8Array: Uint8Array);
-    /**
-     * Read from a given position of an abstracted file or buffer.
-     * @param uint8Array - Uint8Array that the data will be written to.
-     * @param offset - Offset in the buffer to start writing at.
-     * @param length - Integer specifying the number of bytes to read.
-     * @param position - Specifies where to begin reading from in the file.
-     * @return Promise providing bytes read
-     */
-    randomRead(uint8Array: Uint8Array, offset: number, length: number, position: number): Promise<number>;
-}
+import { IRandomReader } from '../type';
+/**
+ * Provides abstract Uint8Array access via the IRandomRead interface
+ */
+export declare class RandomUint8ArrayReader implements IRandomReader {
+    private readonly uint8Array;
+    readonly fileSize: number;
+    constructor(uint8Array: Uint8Array);
+    /**
+     * Read from a given position of an abstracted file or buffer.
+     * @param uint8Array - Uint8Array that the data will be written to.
+     * @param offset - Offset in the buffer to start writing at.
+     * @param length - Integer specifying the number of bytes to read.
+     * @param position - Specifies where to begin reading from in the file.
+     * @return Promise providing bytes read
+     */
+    randomRead(uint8Array: Uint8Array, offset: number, length: number, position: number): Promise<number>;
+}

package/lib/common/RandomUint8ArrayReader.js

@@ -1,25 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RandomUint8ArrayReader = void 0;
-/**
- * Provides abstract Uint8Array access via the IRandomRead interface
- */
-class RandomUint8ArrayReader {
-    constructor(uint8Array) {
-        this.uint8Array = uint8Array;
-        this.fileSize = uint8Array.length;
-    }
-    /**
-     * Read from a given position of an abstracted file or buffer.
-     * @param uint8Array - Uint8Array that the data will be written to.
-     * @param offset - Offset in the buffer to start writing at.
-     * @param length - Integer specifying the number of bytes to read.
-     * @param position - Specifies where to begin reading from in the file.
-     * @return Promise providing bytes read
-     */
-    async randomRead(uint8Array, offset, length, position) {
-        uint8Array.set(this.uint8Array.subarray(position, position + length), offset);
-        return length;
-    }
-}
-exports.RandomUint8ArrayReader = RandomUint8ArrayReader;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomUint8ArrayReader = void 0;
+/**
+ * Provides abstract Uint8Array access via the IRandomRead interface
+ */
+class RandomUint8ArrayReader {
+    constructor(uint8Array) {
+        this.uint8Array = uint8Array;
+        this.fileSize = uint8Array.length;
+    }
+    /**
+     * Read from a given position of an abstracted file or buffer.
+     * @param uint8Array - Uint8Array that the data will be written to.
+     * @param offset - Offset in the buffer to start writing at.
+     * @param length - Integer specifying the number of bytes to read.
+     * @param position - Specifies where to begin reading from in the file.
+     * @return Promise providing bytes read
+     */
+    async randomRead(uint8Array, offset, length, position) {
+        uint8Array.set(this.uint8Array.subarray(position, position + length), offset);
+        return length;
+    }
+}
+exports.RandomUint8ArrayReader = RandomUint8ArrayReader;

package/lib/common/Util.d.ts

@@ -1,58 +1,57 @@
-/// <reference types="node" />
-import { IRatio } from '../type';
-export declare type StringEncoding = 'ascii' | 'utf8' | 'utf16le' | 'ucs2' | 'base64url' | 'latin1' | 'hex';
-export interface ITextEncoding {
-    encoding: StringEncoding;
-    bom?: boolean;
-}
-export declare function getBit(buf: Uint8Array, off: number, bit: number): boolean;
-/**
- * Found delimiting zero in uint8Array
- * @param uint8Array Uint8Array to find the zero delimiter in
- * @param start Offset in uint8Array
- * @param end Last position to parse in uint8Array
- * @param encoding The string encoding used
- * @return Absolute position on uint8Array where zero found
- */
-export declare function findZero(uint8Array: Uint8Array, start: number, end: number, encoding?: StringEncoding): number;
-export declare function trimRightNull(x: string): string;
-/**
- * Decode string
- */
-export declare function decodeString(buffer: Buffer, 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 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
- */
-export declare function getBitAllignedNumber(buf: 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 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
- */
-export declare function isBitSet(buf: Uint8Array, byteOffset: number, bitOffset: number): boolean;
-export declare function a2hex(str: string): string;
-/**
- * Convert power ratio to DB
- * ratio: [0..1]
- */
-export declare function ratioToDb(ratio: number): number;
-/**
- * Convert dB to ratio
- * db Decibels
- */
-export declare function dbToRatio(dB: number): number;
-/**
- * Convert replay gain to ratio and Decibel
- * @param value string holding a ratio like '0.034' or '-7.54 dB'
- */
-export declare function toRatio(value: string): IRatio;
+import { IRatio } from '../type';
+export declare type StringEncoding = 'ascii' | 'utf8' | 'utf16le' | 'ucs2' | 'base64url' | 'latin1' | 'hex';
+export interface ITextEncoding {
+    encoding: StringEncoding;
+    bom?: boolean;
+}
+export declare function getBit(buf: Uint8Array, off: number, bit: number): boolean;
+/**
+ * Found delimiting zero in uint8Array
+ * @param uint8Array Uint8Array to find the zero delimiter in
+ * @param start Offset in uint8Array
+ * @param end Last position to parse in uint8Array
+ * @param encoding The string encoding used
+ * @return Absolute position on uint8Array where zero found
+ */
+export declare function findZero(uint8Array: Uint8Array, start: number, end: number, encoding?: StringEncoding): number;
+export declare function trimRightNull(x: string): string;
+/**
+ * Decode 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 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
+ */
+export declare function getBitAllignedNumber(buf: 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 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
+ */
+export declare function isBitSet(buf: Uint8Array, byteOffset: number, bitOffset: number): boolean;
+export declare function a2hex(str: string): string;
+/**
+ * Convert power ratio to DB
+ * ratio: [0..1]
+ */
+export declare function ratioToDb(ratio: number): number;
+/**
+ * Convert dB to ratio
+ * db Decibels
+ */
+export declare function dbToRatio(dB: number): number;
+/**
+ * Convert replay gain to ratio and Decibel
+ * @param value string holding a ratio like '0.034' or '-7.54 dB'
+ */
+export declare function toRatio(value: string): IRatio;

package/lib/common/Util.js

@@ -1,163 +1,158 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toRatio = exports.dbToRatio = exports.ratioToDb = exports.a2hex = exports.isBitSet = exports.getBitAllignedNumber = exports.stripNulls = exports.decodeString = exports.trimRightNull = exports.findZero = exports.getBit = void 0;
-function getBit(buf, off, bit) {
-    return (buf[off] & (1 << bit)) !== 0;
-}
-exports.getBit = getBit;
-/**
- * Found delimiting zero in uint8Array
- * @param uint8Array Uint8Array to find the zero delimiter in
- * @param start Offset in uint8Array
- * @param end Last position to parse in uint8Array
- * @param encoding The string encoding used
- * @return Absolute position on uint8Array where zero found
- */
-function findZero(uint8Array, start, end, encoding) {
-    let i = start;
-    if (encoding === 'utf16le') {
-        while (uint8Array[i] !== 0 || uint8Array[i + 1] !== 0) {
-            if (i >= end)
-                return end;
-            i += 2;
-        }
-        return i;
-    }
-    else {
-        while (uint8Array[i] !== 0) {
-            if (i >= end)
-                return end;
-            i++;
-        }
-        return i;
-    }
-}
-exports.findZero = findZero;
-function trimRightNull(x) {
-    const pos0 = x.indexOf('\0');
-    return pos0 === -1 ? x : x.substr(0, pos0);
-}
-exports.trimRightNull = trimRightNull;
-function swapBytes(uint8Array) {
-    const l = uint8Array.length;
-    if ((l & 1) !== 0)
-        throw new Error('Buffer length must be even');
-    for (let i = 0; i < l; i += 2) {
-        const a = uint8Array[i];
-        uint8Array[i] = uint8Array[i + 1];
-        uint8Array[i + 1] = a;
-    }
-    return uint8Array;
-}
-/**
- * Decode string
- */
-function decodeString(buffer, 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);
-    }
-    else if (encoding === 'utf16le' && buffer[0] === 0xFE && buffer[1] === 0xFF) {
-        // BOM, indicating big endian decoding
-        if ((buffer.length & 1) !== 0)
-            throw new Error('Expected even number of octets for 16-bit unicode string');
-        return decodeString(swapBytes(buffer), encoding);
-    }
-    return buffer.toString(encoding);
-}
-exports.decodeString = decodeString;
-function stripNulls(str) {
-    str = str.replace(/^\x00+/g, '');
-    str = str.replace(/\x00+$/g, '');
-    return str;
-}
-exports.stripNulls = stripNulls;
-/**
- * Read bit-aligned number start from buffer
- * Total offset in bits = byteOffset * 8 + bitOffset
- * @param buf 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
- */
-function getBitAllignedNumber(buf, byteOffset, bitOffset, len) {
-    const byteOff = byteOffset + ~~(bitOffset / 8);
-    const bitOff = bitOffset % 8;
-    let value = buf[byteOff];
-    value &= 0xff >> bitOff;
-    const bitsRead = 8 - bitOff;
-    const bitsLeft = len - bitsRead;
-    if (bitsLeft < 0) {
-        value >>= (8 - bitOff - len);
-    }
-    else if (bitsLeft > 0) {
-        value <<= bitsLeft;
-        value |= getBitAllignedNumber(buf, byteOffset, bitOffset + bitsRead, bitsLeft);
-    }
-    return value;
-}
-exports.getBitAllignedNumber = getBitAllignedNumber;
-/**
- * Read bit-aligned number start from buffer
- * Total offset in bits = byteOffset * 8 + bitOffset
- * @param buf Byte buffer
- * @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
- */
-function isBitSet(buf, byteOffset, bitOffset) {
-    return getBitAllignedNumber(buf, byteOffset, bitOffset, 1) === 1;
-}
-exports.isBitSet = isBitSet;
-function a2hex(str) {
-    const arr = [];
-    for (let i = 0, l = str.length; i < l; i++) {
-        const hex = Number(str.charCodeAt(i)).toString(16);
-        arr.push(hex.length === 1 ? '0' + hex : hex);
-    }
-    return arr.join(' ');
-}
-exports.a2hex = a2hex;
-/**
- * Convert power ratio to DB
- * ratio: [0..1]
- */
-function ratioToDb(ratio) {
-    return 10 * Math.log10(ratio);
-}
-exports.ratioToDb = ratioToDb;
-/**
- * Convert dB to ratio
- * db Decibels
- */
-function dbToRatio(dB) {
-    return Math.pow(10, dB / 10);
-}
-exports.dbToRatio = dbToRatio;
-/**
- * Convert replay gain to ratio and Decibel
- * @param value string holding a ratio like '0.034' or '-7.54 dB'
- */
-function toRatio(value) {
-    const ps = value.split(' ').map(p => p.trim().toLowerCase());
-    // @ts-ignore
-    if (ps.length >= 1) {
-        const v = parseFloat(ps[0]);
-        if (ps.length === 2 && ps[1] === 'db') {
-            return {
-                dB: v,
-                ratio: dbToRatio(v)
-            };
-        }
-        else {
-            return {
-                dB: ratioToDb(v),
-                ratio: v
-            };
-        }
-    }
-}
-exports.toRatio = toRatio;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRatio = exports.dbToRatio = exports.ratioToDb = exports.a2hex = exports.isBitSet = exports.getBitAllignedNumber = exports.stripNulls = exports.decodeString = exports.trimRightNull = exports.findZero = exports.getBit = void 0;
+function getBit(buf, off, bit) {
+    return (buf[off] & (1 << bit)) !== 0;
+}
+exports.getBit = getBit;
+/**
+ * Found delimiting zero in uint8Array
+ * @param uint8Array Uint8Array to find the zero delimiter in
+ * @param start Offset in uint8Array
+ * @param end Last position to parse in uint8Array
+ * @param encoding The string encoding used
+ * @return Absolute position on uint8Array where zero found
+ */
+function findZero(uint8Array, start, end, encoding) {
+    let i = start;
+    if (encoding === 'utf16le') {
+        while (uint8Array[i] !== 0 || uint8Array[i + 1] !== 0) {
+            if (i >= end)
+                return end;
+            i += 2;
+        }
+        return i;
+    }
+    else {
+        while (uint8Array[i] !== 0) {
+            if (i >= end)
+                return end;
+            i++;
+        }
+        return i;
+    }
+}
+exports.findZero = findZero;
+function trimRightNull(x) {
+    const pos0 = x.indexOf('\0');
+    return pos0 === -1 ? x : x.substr(0, pos0);
+}
+exports.trimRightNull = trimRightNull;
+function swapBytes(uint8Array) {
+    const l = uint8Array.length;
+    if ((l & 1) !== 0)
+        throw new Error('Buffer length must be even');
+    for (let i = 0; i < l; i += 2) {
+        const a = uint8Array[i];
+        uint8Array[i] = uint8Array[i + 1];
+        uint8Array[i + 1] = a;
+    }
+    return uint8Array;
+}
+/**
+ * Decode string
+ */
+function decodeString(uint8Array, encoding) {
+    // annoying workaround for a double BOM issue
+    // https://github.com/leetreveil/musicmetadata/issues/84
+    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) {
+        // 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);
+}
+exports.decodeString = decodeString;
+function stripNulls(str) {
+    str = str.replace(/^\x00+/g, '');
+    str = str.replace(/\x00+$/g, '');
+    return str;
+}
+exports.stripNulls = stripNulls;
+/**
+ * Read bit-aligned number start from buffer
+ * Total offset in bits = byteOffset * 8 + bitOffset
+ * @param buf 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
+ */
+function getBitAllignedNumber(buf, byteOffset, bitOffset, len) {
+    const byteOff = byteOffset + ~~(bitOffset / 8);
+    const bitOff = bitOffset % 8;
+    let value = buf[byteOff];
+    value &= 0xff >> bitOff;
+    const bitsRead = 8 - bitOff;
+    const bitsLeft = len - bitsRead;
+    if (bitsLeft < 0) {
+        value >>= (8 - bitOff - len);
+    }
+    else if (bitsLeft > 0) {
+        value <<= bitsLeft;
+        value |= getBitAllignedNumber(buf, byteOffset, bitOffset + bitsRead, bitsLeft);
+    }
+    return value;
+}
+exports.getBitAllignedNumber = getBitAllignedNumber;
+/**
+ * Read bit-aligned number start from buffer
+ * Total offset in bits = byteOffset * 8 + bitOffset
+ * @param buf Byte buffer
+ * @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
+ */
+function isBitSet(buf, byteOffset, bitOffset) {
+    return getBitAllignedNumber(buf, byteOffset, bitOffset, 1) === 1;
+}
+exports.isBitSet = isBitSet;
+function a2hex(str) {
+    const arr = [];
+    for (let i = 0, l = str.length; i < l; i++) {
+        const hex = Number(str.charCodeAt(i)).toString(16);
+        arr.push(hex.length === 1 ? '0' + hex : hex);
+    }
+    return arr.join(' ');
+}
+exports.a2hex = a2hex;
+/**
+ * Convert power ratio to DB
+ * ratio: [0..1]
+ */
+function ratioToDb(ratio) {
+    return 10 * Math.log10(ratio);
+}
+exports.ratioToDb = ratioToDb;
+/**
+ * Convert dB to ratio
+ * db Decibels
+ */
+function dbToRatio(dB) {
+    return Math.pow(10, dB / 10);
+}
+exports.dbToRatio = dbToRatio;
+/**
+ * Convert replay gain to ratio and Decibel
+ * @param value string holding a ratio like '0.034' or '-7.54 dB'
+ */
+function toRatio(value) {
+    const ps = value.split(' ').map(p => p.trim().toLowerCase());
+    // @ts-ignore
+    if (ps.length >= 1) {
+        const v = parseFloat(ps[0]);
+        return ps.length === 2 && ps[1] === 'db' ? {
+            dB: v,
+            ratio: dbToRatio(v)
+        } : {
+            dB: ratioToDb(v),
+            ratio: v
+        };
+    }
+}
+exports.toRatio = toRatio;
 //# sourceMappingURL=Util.js.map