@dragon708/docmind-markdown 1.2.5 → 1.2.7

package/node_modules/music-metadata/lib/common/MetadataCollector.js

@@ -1,19 +1,22 @@
-import { TrackTypeValueToKeyMap, } from '../type.js';
-import initDebug from 'debug';
-import { isSingleton, isUnique } from './GenericTagTypes.js';
-import { CombinedTagMapper } from './CombinedTagMapper.js';
-import { CommonTagMapper } from './GenericTagMapper.js';
-import { toRatio } from './Util.js';
-import { fileTypeFromBuffer } from 'file-type';
-import { parseLyrics } from '../lrc/LyricsParser.js';
-const debug = initDebug('music-metadata:collector');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinArtists = exports.MetadataCollector = void 0;
+const type_1 = require("../type");
+const debug_1 = require("debug");
+const GenericTagTypes_1 = require("./GenericTagTypes");
+const CombinedTagMapper_1 = require("./CombinedTagMapper");
+const GenericTagMapper_1 = require("./GenericTagMapper");
+const Util_1 = require("./Util");
+const FileType = require("file-type/core");
+const debug = (0, debug_1.default)('music-metadata:collector');
 const TagPriority = ['matroska', 'APEv2', 'vorbis', 'ID3v2.4', 'ID3v2.3', 'ID3v2.2', 'exif', 'asf', 'iTunes', 'AIFF', 'ID3v1'];
 /**
  * Provided to the parser to uodate the metadata result.
  * Responsible for triggering async updates
  */
-export class MetadataCollector {
+class MetadataCollector {
     constructor(opts) {
+        this.opts = opts;
         this.format = {
             tagTypes: [],
             trackInfo: []
@@ -22,7 +25,7 @@ export class MetadataCollector {
         this.common = {
             track: { no: null, of: null },
             disk: { no: null, of: null },
-            movementIndex: { no: null, of: null }
+            movementIndex: {}
         };
         this.quality = {
             warnings: []
@@ -35,8 +38,7 @@ export class MetadataCollector {
          * Maps a tag type to a priority
          */
         this.originPriority = {};
-        this.tagMapper = new CombinedTagMapper();
-        this.opts = opts;
+        this.tagMapper = new CombinedTagMapper_1.CombinedTagMapper();
         let priority = 1;
         for (const tagType of TagPriority) {
             this.originPriority[tagType] = priority++;
@@ -51,132 +53,124 @@ export class MetadataCollector {
         return Object.keys(this.native).length > 0;
     }
     addStreamInfo(streamInfo) {
-        debug(`streamInfo: type=${streamInfo.type ? TrackTypeValueToKeyMap[streamInfo.type] : '?'}, codec=${streamInfo.codecName}`);
+        debug(`streamInfo: type=${type_1.TrackType[streamInfo.type]}, codec=${streamInfo.codecName}`);
         this.format.trackInfo.push(streamInfo);
     }
     setFormat(key, value) {
         debug(`format: ${key} = ${value}`);
         this.format[key] = value; // as any to override readonly
-        if (this.opts?.observer) {
+        if (this.opts.observer) {
             this.opts.observer({ metadata: this, tag: { type: 'format', id: key, value } });
         }
     }
-    setAudioOnly() {
-        this.setFormat('hasAudio', true);
-        this.setFormat('hasVideo', false);
-    }
-    async addTag(tagType, tagId, value) {
+    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 });
-        await this.toCommon(tagType, tagId, value);
+        this.toCommon(tagType, tagId, value);
     }
     addWarning(warning) {
         this.quality.warnings.push({ message: warning });
     }
-    async postMap(tagType, tag) {
+    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
         // it is emitted to the user. e.g. genre (20) -> Electronic
         switch (tag.id) {
             case 'artist':
-                return this.handleSingularArtistTag(tagType, tag, 'artist', 'artists');
-            case 'albumartist':
-                return this.handleSingularArtistTag(tagType, tag, 'albumartist', 'albumartists');
+                if (this.commonOrigin.artist === this.originPriority[tagType]) {
+                    // Assume the artist field is used as artists
+                    return this.postMap('artificial', { id: 'artists', value: tag.value });
+                }
+                if (!this.common.artists) {
+                    // Fill artists using artist source
+                    this.setGenericTag('artificial', { id: 'artists', value: tag.value });
+                }
+                break;
             case 'artists':
-                return this.handlePluralArtistTag(tagType, tag, 'artist', 'artists');
-            case 'albumartists':
-                return this.handlePluralArtistTag(tagType, tag, 'albumartist', 'albumartists');
+                if (!this.common.artist || this.commonOrigin.artist === this.originPriority.artificial) {
+                    if (!this.common.artists || this.common.artists.indexOf(tag.value) === -1) {
+                        // Fill artist using artists source
+                        const artists = (this.common.artists || []).concat([tag.value]);
+                        const value = joinArtists(artists);
+                        const artistTag = { id: 'artist', value };
+                        this.setGenericTag('artificial', artistTag);
+                    }
+                }
+                break;
             case 'picture':
-                return this.postFixPicture(tag.value).then(picture => {
+                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);
+                this.common.track.of = GenericTagMapper_1.CommonTagMapper.toIntOrNull(tag.value);
                 return;
             case 'totaldiscs':
-                this.common.disk.of = CommonTagMapper.toIntOrNull(tag.value);
+                this.common.disk.of = GenericTagMapper_1.CommonTagMapper.toIntOrNull(tag.value);
                 return;
             case 'movementTotal':
-                this.common.movementIndex.of = CommonTagMapper.toIntOrNull(tag.value);
+                this.common.movementIndex.of = GenericTagMapper_1.CommonTagMapper.toIntOrNull(tag.value);
                 return;
             case 'track':
             case 'disk':
-            case 'movementIndex': {
+            case 'movementIndex':
                 const of = this.common[tag.id].of; // store of value, maybe maybe overwritten
-                this.common[tag.id] = CommonTagMapper.normalizeTrack(tag.value);
+                this.common[tag.id] = GenericTagMapper_1.CommonTagMapper.normalizeTrack(tag.value);
                 this.common[tag.id].of = of != null ? of : this.common[tag.id].of;
                 return;
-            }
             case 'bpm':
             case 'year':
             case 'originalyear':
-                tag.value = Number.parseInt(tag.value, 10);
+                tag.value = parseInt(tag.value, 10);
                 break;
-            case 'date': {
+            case 'date':
                 // ToDo: be more strict on 'YYYY...'
-                const year = Number.parseInt(tag.value.substr(0, 4), 10);
-                if (!Number.isNaN(year)) {
+                const year = parseInt(tag.value.substr(0, 4), 10);
+                if (!isNaN(year)) {
                     this.common.year = year;
                 }
                 break;
-            }
             case 'discogs_label_id':
             case 'discogs_release_id':
             case 'discogs_master_release_id':
             case 'discogs_artist_id':
             case 'discogs_votes':
-                tag.value = typeof tag.value === 'string' ? Number.parseInt(tag.value, 10) : tag.value;
+                tag.value = typeof tag.value === 'string' ? parseInt(tag.value, 10) : tag.value;
                 break;
             case 'replaygain_track_gain':
             case 'replaygain_track_peak':
             case 'replaygain_album_gain':
             case 'replaygain_album_peak':
-                tag.value = toRatio(tag.value);
+                tag.value = (0, Util_1.toRatio)(tag.value);
                 break;
             case 'replaygain_track_minmax':
-                tag.value = tag.value.split(',').map(v => Number.parseInt(v, 10));
+                tag.value = tag.value.split(',').map(v => parseInt(v, 10));
                 break;
-            case 'replaygain_undo': {
-                const minMix = tag.value.split(',').map(v => Number.parseInt(v, 10));
+            case 'replaygain_undo':
+                const minMix = tag.value.split(',').map(v => parseInt(v, 10));
                 tag.value = {
                     leftChannel: minMix[0],
                     rightChannel: minMix[1]
                 };
                 break;
-            }
             case 'gapless': // iTunes gap-less flag
             case 'compilation':
             case 'podcast':
             case 'showMovement':
                 tag.value = tag.value === '1' || tag.value === 1; // boolean
                 break;
-            case 'isrc': { // Only keep unique values
-                const commonTag = this.common[tag.id];
-                if (commonTag && commonTag.indexOf(tag.value) !== -1)
+            case 'isrc': // Only keep unique values
+                if (this.common[tag.id] && this.common[tag.id].indexOf(tag.value) !== -1)
                     return;
                 break;
-            }
-            case 'comment':
-                if (typeof tag.value === 'string') {
-                    tag.value = { text: tag.value };
-                }
-                if (tag.value.descriptor === 'iTunPGAP') {
-                    this.setGenericTag(tagType, { id: 'gapless', value: tag.value.text === '1' });
-                }
-                break;
-            case 'lyrics':
-                if (typeof tag.value === 'string') {
-                    tag.value = parseLyrics(tag.value);
-                }
-                break;
             default:
             // nothing to do
         }
@@ -196,34 +190,6 @@ export class MetadataCollector {
             common: this.common
         };
     }
-    /**
-     * Handle singular artist tags (artist, albumartist) and cross-populate to plural form
-     */
-    handleSingularArtistTag(tagType, tag, singularId, pluralId) {
-        if (this.commonOrigin[singularId] === this.originPriority[tagType]) {
-            // Assume the singular field is used as plural (multiple values from same source)
-            return this.postMap('artificial', { id: pluralId, value: tag.value });
-        }
-        if (!this.common[pluralId]) {
-            // Fill plural using singular source
-            this.setGenericTag('artificial', { id: pluralId, value: tag.value });
-        }
-        this.setGenericTag(tagType, tag);
-    }
-    /**
-     * Handle plural artist tags (artists, albumartists) and cross-populate to singular form
-     */
-    handlePluralArtistTag(tagType, tag, singularId, pluralId) {
-        if (!this.common[singularId] || this.commonOrigin[singularId] === this.originPriority.artificial) {
-            if (!this.common[pluralId] || this.common[pluralId].indexOf(tag.value) === -1) {
-                // Fill singular using plural source
-                const values = (this.common[pluralId] || []).concat([tag.value]);
-                const value = joinArtists(values);
-                this.setGenericTag('artificial', { id: singularId, value });
-            }
-        }
-        this.setGenericTag(tagType, tag);
-    }
     /**
      * Fix some common issues with picture object
      * @param picture Picture
@@ -231,7 +197,7 @@ export class MetadataCollector {
     async postFixPicture(picture) {
         if (picture.data && picture.data.length > 0) {
             if (!picture.format) {
-                const fileType = await fileTypeFromBuffer(Uint8Array.from(picture.data)); // ToDO: remove Buffer
+                const fileType = await FileType.fromBuffer(picture.data);
                 if (fileType) {
                     picture.format = fileType.mime;
                 }
@@ -246,17 +212,17 @@ export class MetadataCollector {
             }
             return picture;
         }
-        this.addWarning("Empty picture tag found");
+        this.addWarning(`Empty picture tag found`);
         return null;
     }
     /**
      * Convert native tag to common tags
      */
-    async toCommon(tagType, tagId, value) {
+    toCommon(tagType, tagId, value) {
         const tag = { id: tagId, value };
         const genericTag = this.tagMapper.mapTag(tagType, tag, this);
         if (genericTag) {
-            await this.postMap(tagType, genericTag);
+            this.postMap(tagType, genericTag);
         }
     }
     /**
@@ -266,7 +232,7 @@ export class MetadataCollector {
         debug(`common.${tag.id} = ${tag.value}`);
         const prio0 = this.commonOrigin[tag.id] || 1000;
         const prio1 = this.originPriority[tagType];
-        if (isSingleton(tag.id)) {
+        if ((0, GenericTagTypes_1.isSingleton)(tag.id)) {
             if (prio1 <= prio0) {
                 this.common[tag.id] = tag.value;
                 this.commonOrigin[tag.id] = prio1;
@@ -277,7 +243,7 @@ export class MetadataCollector {
         }
         else {
             if (prio1 === prio0) {
-                if (!isUnique(tag.id) || this.common[tag.id].indexOf(tag.value) === -1) {
+                if (!(0, GenericTagTypes_1.isUnique)(tag.id) || this.common[tag.id].indexOf(tag.value) === -1) {
                     this.common[tag.id].push(tag.value);
                 }
                 else {
@@ -293,15 +259,18 @@ export class MetadataCollector {
                 return debug(`Ignore native tag (list): ${tagType}.${tag.id} = ${tag.value}`);
             }
         }
-        if (this.opts?.observer) {
+        if (this.opts.observer) {
             this.opts.observer({ metadata: this, tag: { type: 'common', id: tag.id, value: tag.value } });
         }
         // ToDo: trigger metadata event
     }
 }
-export function joinArtists(artists) {
+exports.MetadataCollector = MetadataCollector;
+function joinArtists(artists) {
     if (artists.length > 2) {
-        return `${artists.slice(0, artists.length - 1).join(', ')} & ${artists[artists.length - 1]}`;
+        return artists.slice(0, artists.length - 1).join(', ') + ' & ' + artists[artists.length - 1];
     }
     return artists.join(' & ');
 }
+exports.joinArtists = joinArtists;
+//# sourceMappingURL=MetadataCollector.js.map

package/node_modules/music-metadata/lib/common/RandomFileReader.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+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 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 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>;
+    close(): Promise<void>;
+    static init(filePath: string, fileSize: number): Promise<RandomFileReader>;
+}

package/node_modules/music-metadata/lib/common/RandomFileReader.js

@@ -0,0 +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(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/node_modules/music-metadata/lib/common/RandomUint8ArrayReader.d.ts

@@ -0,0 +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>;
+}

package/node_modules/music-metadata/lib/common/RandomUint8ArrayReader.js

@@ -0,0 +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;

package/node_modules/music-metadata/lib/common/Util.d.ts

@@ -1,13 +1,19 @@
-import type { IRatio } from '../type.js';
-export type StringEncoding = 'ascii' | 'utf8' | 'utf-16le' | 'ucs2' | 'base64url' | 'latin1' | 'hex';
+import { IRatio } from '../type';
+export 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;
 /**
- * Find delimiting zero in uint8Array
+ * 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 position in uint8Array where zero found, or uint8Array.length if not found
+ * @return Absolute position on uint8Array where zero found
  */
-export declare function findZero(uint8Array: Uint8Array, encoding?: StringEncoding): number;
+export declare function findZero(uint8Array: Uint8Array, start: number, end: number, encoding?: StringEncoding): number;
 export declare function trimRightNull(x: string): string;
 /**
  * Decode string
@@ -48,9 +54,4 @@ 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 | undefined;
-/**
- * Decode a big-endian unsigned integer from a Uint8Array.
- * Supports dynamic length (1–8 bytes).
- */
-export declare function decodeUintBE(uint8Array: Uint8Array): number;
+export declare function toRatio(value: string): IRatio;

package/node_modules/music-metadata/lib/common/Util.js

@@ -1,40 +1,47 @@
-import { StringType } from 'token-types';
-import { FieldDecodingError } from '../ParseError.js';
-import { getUintBE } from 'uint8array-extras';
-export function getBit(buf, off, bit) {
+"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;
 /**
- * Find delimiting zero in uint8Array
+ * 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 position in uint8Array where zero found, or uint8Array.length if not found
+ * @return Absolute position on uint8Array where zero found
  */
-export function findZero(uint8Array, encoding) {
-    const len = uint8Array.length;
-    if (encoding === 'utf-16le') {
-        // Look for 0x00 0x00 on 2-byte boundary
-        for (let i = 0; i + 1 < len; i += 2) {
-            if (uint8Array[i] === 0 && uint8Array[i + 1] === 0)
-                return i;
+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 len;
+        return i;
     }
-    // latin1 / utf8 / utf16be (caller typically handles utf16be separately or via decode)
-    for (let i = 0; i < len; i++) {
-        if (uint8Array[i] === 0)
-            return i;
+    else {
+        while (uint8Array[i] !== 0) {
+            if (i >= end)
+                return end;
+            i++;
+        }
+        return i;
     }
-    return len;
 }
-export function trimRightNull(x) {
+exports.findZero = findZero;
+function trimRightNull(x) {
     const pos0 = x.indexOf('\0');
-    return pos0 === -1 ? x : x.substring(0, pos0);
+    return pos0 === -1 ? x : x.substr(0, pos0);
 }
+exports.trimRightNull = trimRightNull;
 function swapBytes(uint8Array) {
     const l = uint8Array.length;
     if ((l & 1) !== 0)
-        throw new FieldDecodingError('Buffer length must be even');
+        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];
@@ -45,25 +52,27 @@ function swapBytes(uint8Array) {
 /**
  * Decode string
  */
-export function decodeString(uint8Array, encoding) {
+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);
     }
-    if (encoding === 'utf-16le' && uint8Array[0] === 0xFE && uint8Array[1] === 0xFF) {
+    else if (encoding === 'utf16le' && uint8Array[0] === 0xFE && uint8Array[1] === 0xFF) {
         // BOM, indicating big endian decoding
         if ((uint8Array.length & 1) !== 0)
-            throw new FieldDecodingError('Expected even number of octets for 16-bit unicode string');
+            throw new Error('Expected even number of octets for 16-bit unicode string');
         return decodeString(swapBytes(uint8Array), encoding);
     }
-    return new StringType(uint8Array.length, encoding).get(uint8Array, 0);
+    return Buffer.from(uint8Array).toString(encoding);
 }
-export function stripNulls(str) {
+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
@@ -73,7 +82,7 @@ export function stripNulls(str) {
  * @param len Length of number in bits
  * @return Decoded bit aligned number
  */
-export function getBitAllignedNumber(source, byteOffset, bitOffset, len) {
+function getBitAllignedNumber(source, byteOffset, bitOffset, len) {
     const byteOff = byteOffset + ~~(bitOffset / 8);
     const bitOff = bitOffset % 8;
     let value = source[byteOff];
@@ -89,6 +98,7 @@ export function getBitAllignedNumber(source, byteOffset, bitOffset, len) {
     }
     return value;
 }
+exports.getBitAllignedNumber = getBitAllignedNumber;
 /**
  * Read bit-aligned number start from buffer
  * Total offset in bits = byteOffset * 8 + bitOffset
@@ -97,39 +107,44 @@ export function getBitAllignedNumber(source, byteOffset, bitOffset, len) {
  * @param bitOffset Starting offset in bits: 0 = most significant bit, 7 is the least significant bit
  * @return True if bit is set
  */
-export function isBitSet(source, byteOffset, bitOffset) {
+function isBitSet(source, byteOffset, bitOffset) {
     return getBitAllignedNumber(source, byteOffset, bitOffset, 1) === 1;
 }
-export function a2hex(str) {
+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);
+        arr.push(hex.length === 1 ? '0' + hex : hex);
     }
     return arr.join(' ');
 }
+exports.a2hex = a2hex;
 /**
  * Convert power ratio to DB
  * ratio: [0..1]
  */
-export function ratioToDb(ratio) {
+function ratioToDb(ratio) {
     return 10 * Math.log10(ratio);
 }
+exports.ratioToDb = ratioToDb;
 /**
  * Convert dB to ratio
  * db Decibels
  */
-export function dbToRatio(dB) {
-    return 10 ** (dB / 10);
+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'
  */
-export function toRatio(value) {
+function toRatio(value) {
     const ps = value.split(' ').map(p => p.trim().toLowerCase());
+    // @ts-ignore
     if (ps.length >= 1) {
-        const v = Number.parseFloat(ps[0]);
+        const v = parseFloat(ps[0]);
         return ps.length === 2 && ps[1] === 'db' ? {
             dB: v,
             ratio: dbToRatio(v)
@@ -139,14 +154,5 @@ export function toRatio(value) {
         };
     }
 }
-/**
- * Decode a big-endian unsigned integer from a Uint8Array.
- * Supports dynamic length (1–8 bytes).
- */
-export function decodeUintBE(uint8Array) {
-    if (uint8Array.length === 0) {
-        throw new Error("decodeUintBE: empty Uint8Array");
-    }
-    const view = new DataView(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength);
-    return getUintBE(view);
-}
+exports.toRatio = toRatio;
+//# sourceMappingURL=Util.js.map