music-metadata 9.0.0 → 9.0.1

package/lib/common/RandomFileReader.d.ts

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

package/lib/common/RandomFileReader.js

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

package/lib/id3v1/ID3v1Parser.js

@@ -121,9 +121,9 @@ export class ID3v1Parser extends BasicParser {
 }
 export async function hasID3v1Header(reader) {
     if (reader.fileSize >= 128) {
-        const tag = Buffer.alloc(3);
+        const tag = new Uint8Array(3);
         await reader.randomRead(tag, 0, tag.length, reader.fileSize - 128);
-        return tag.toString('latin1') === 'TAG';
+        return new TextDecoder('latin1').decode(tag) === 'TAG';
     }
     return false;
 }

package/lib/lyrics3/Lyrics3.js

@@ -1,12 +1,12 @@
 export const endTag2 = 'LYRICS200';
 export async function getLyricsHeaderLength(reader) {
     if (reader.fileSize >= 143) {
-        const buf = Buffer.alloc(15);
+        const buf = new Uint8Array(15);
         await reader.randomRead(buf, 0, buf.length, reader.fileSize - 143);
-        const txt = buf.toString('latin1');
-        const tag = txt.substr(6);
+        const txt = new TextDecoder('latin1').decode(buf);
+        const tag = txt.slice(6);
         if (tag === endTag2) {
-            return parseInt(txt.substr(0, 6), 10) + 15;
+            return parseInt(txt.slice(0, 6), 10) + 15;
         }
     }
     return 0;

package/lib/matroska/MatroskaParser.d.ts

@@ -27,11 +27,18 @@ export declare class MatroskaParser extends BasicParser {
     private parseContainer;
     private readVintData;
     private readElement;
-    private isMaxValue;
     private readFloat;
     private readFlag;
     private readUint;
     private readString;
     private readBuffer;
     private addTag;
+    private static readUIntBE;
+    /**
+     * Reeds an unsigned integer from a big endian buffer of length `len`
+     * @param buf Buffer to decode from
+     * @param len Number of bytes
+     * @private
+     */
+    private static readUIntBeAsBigInt;
 }

package/lib/matroska/MatroskaParser.js

@@ -3,6 +3,7 @@ import initDebug from 'debug';
 import { BasicParser } from '../common/BasicParser.js';
 import * as matroskaDtd from './MatroskaDtd.js';
 import { DataType, TargetType, TrackType } from './types.js';
+import * as Token from 'token-types';
 const debug = initDebug('music-metadata:parser:matroska');
 /**
  * Extensible Binary Meta Language (EBML) parser
@@ -21,7 +22,7 @@ export class MatroskaParser extends BasicParser {
         this.parserMap.set(DataType.uint, e => this.readUint(e));
         this.parserMap.set(DataType.string, e => this.readString(e));
         this.parserMap.set(DataType.binary, e => this.readBuffer(e));
-        this.parserMap.set(DataType.uid, async (e) => await this.readUint(e) === 1);
+        this.parserMap.set(DataType.uid, async (e) => this.readBuffer(e));
         this.parserMap.set(DataType.bool, e => this.readFlag(e));
         this.parserMap.set(DataType.float, e => this.readFloat(e));
     }
@@ -45,7 +46,7 @@ export class MatroskaParser extends BasicParser {
                 if (typeof info.duration === 'number') {
                     const duration = info.duration * timecodeScale / 1000000000;
                     await this.addTag('segment:title', info.title);
-                    this.metadata.setFormat('duration', duration);
+                    this.metadata.setFormat('duration', Number(duration));
                 }
             }
             const audioTracks = matroska.segment.tracks;
@@ -168,7 +169,7 @@ export class MatroskaParser extends BasicParser {
             ++oc;
             mask >>= 1;
         }
-        const id = Buffer.alloc(oc);
+        const id = new Uint8Array(oc);
         await this.tokenizer.readBuffer(id);
         return id;
     }
@@ -176,22 +177,11 @@ export class MatroskaParser extends BasicParser {
         const id = await this.readVintData(this.ebmlMaxIDLength);
         const lenField = await this.readVintData(this.ebmlMaxSizeLength);
         lenField[0] ^= 0x80 >> (lenField.length - 1);
-        const nrLen = Math.min(6, lenField.length); // JavaScript can max read 6 bytes integer
         return {
-            id: id.readUIntBE(0, id.length),
-            len: lenField.readUIntBE(lenField.length - nrLen, nrLen)
+            id: MatroskaParser.readUIntBE(id, id.length),
+            len: MatroskaParser.readUIntBE(lenField, lenField.length)
         };
     }
-    isMaxValue(vintData) {
-        if (vintData.length === this.ebmlMaxSizeLength) {
-            for (let n = 1; n < this.ebmlMaxSizeLength; ++n) {
-                if (vintData[n] !== 0xff)
-                    return false;
-            }
-            return true;
-        }
-        return false;
-    }
     async readFloat(e) {
         switch (e.len) {
             case 0:
@@ -211,19 +201,38 @@ export class MatroskaParser extends BasicParser {
     }
     async readUint(e) {
         const buf = await this.readBuffer(e);
-        const nrLen = Math.min(6, e.len); // JavaScript can max read 6 bytes integer
-        return buf.readUIntBE(e.len - nrLen, nrLen);
+        return MatroskaParser.readUIntBE(buf, e.len);
     }
     async readString(e) {
         const rawString = await this.tokenizer.readToken(new StringType(e.len, 'utf-8'));
         return rawString.replace(/\x00.*$/g, '');
     }
     async readBuffer(e) {
-        const buf = Buffer.alloc(e.len);
+        const buf = new Uint8Array(e.len);
         await this.tokenizer.readBuffer(buf);
         return buf;
     }
     async addTag(tagId, value) {
         await this.metadata.addTag('matroska', tagId, value);
     }
+    static readUIntBE(buf, len) {
+        return Number(MatroskaParser.readUIntBeAsBigInt(buf, len));
+    }
+    /**
+     * Reeds an unsigned integer from a big endian buffer of length `len`
+     * @param buf Buffer to decode from
+     * @param len Number of bytes
+     * @private
+     */
+    static readUIntBeAsBigInt(buf, len) {
+        const normalizedNumber = new Uint8Array(8);
+        const cleanNumber = buf.subarray(0, len);
+        try {
+            normalizedNumber.set(cleanNumber, 8 - len);
+            return Token.UINT64_BE.get(normalizedNumber, 0);
+        }
+        catch (error) {
+            return BigInt(-1);
+        }
+    }
 }

package/lib/matroska/types.d.ts

@@ -17,20 +17,20 @@ export interface IElementType<T> {
     readonly multiple?: boolean;
 }
 export interface IContainerType {
-    [id: number]: IElementType<string | number | boolean | Buffer>;
+    [id: number]: IElementType<string | number | boolean | Uint8Array>;
 }
 export interface ITree {
-    [name: string]: string | number | boolean | Buffer | ITree | ITree[];
+    [name: string]: string | number | boolean | Uint8Array | ITree | ITree[];
 }
 export interface ISeekHead {
-    id?: Buffer;
+    id?: Uint8Array;
     position?: number;
 }
 export interface IMetaSeekInformation {
     seekHeads: ISeekHead[];
 }
 export interface ISegmentInformation {
-    uid?: Buffer;
+    uid?: Uint8Array;
     timecodeScale?: number;
     duration?: number;
     dateUTC?: number;
@@ -39,7 +39,7 @@ export interface ISegmentInformation {
     writingApp?: string;
 }
 export interface ITrackEntry {
-    uid?: Buffer;
+    uid?: Uint8Array;
     trackNumber?: number;
     trackType?: TrackType;
     audio?: ITrackAudio;
@@ -52,7 +52,7 @@ export interface ITrackEntry {
     name?: string;
     language?: string;
     codecID?: string;
-    codecPrivate?: Buffer;
+    codecPrivate?: Uint8Array;
     codecName?: string;
     codecSettings?: string;
     codecInfoUrl?: string;
@@ -69,14 +69,14 @@ export interface ITrackVideo {
     displayHeight?: number;
     displayUnit?: number;
     aspectRatioType?: number;
-    colourSpace?: Buffer;
+    colourSpace?: Uint8Array;
     gammaValue?: number;
 }
 export interface ITrackAudio {
     samplingFrequency?: number;
     outputSamplingFrequency?: number;
     channels?: number;
-    channelPositions?: Buffer;
+    channelPositions?: Uint8Array;
     bitDepth?: number;
 }
 export interface ICuePoint {
@@ -99,7 +99,7 @@ export interface ICueReference {
 export interface ISimpleTag {
     name?: string;
     'string'?: string;
-    binary?: Buffer;
+    binary?: Uint8Array;
     language?: string;
     default?: boolean;
 }
@@ -122,9 +122,9 @@ export declare enum TrackType {
     control = 32
 }
 export interface ITarget {
-    trackUID?: Buffer;
-    chapterUID?: Buffer;
-    attachmentUID?: Buffer;
+    trackUID?: Uint8Array;
+    chapterUID?: Uint8Array;
+    attachmentUID?: Uint8Array;
     targetTypeValue?: TargetType;
     targetType?: string;
 }
@@ -142,7 +142,7 @@ export interface IAttachmedFile {
     description?: string;
     name: string;
     mimeType: string;
-    data: Buffer;
+    data: Uint8Array;
     uid: string;
 }
 export interface IAttachments {

package/lib/mp4/AtomToken.d.ts

@@ -123,6 +123,7 @@ export declare abstract class FixedLengthAtom {
      *
      * @param {number} len Length as specified in the size field
      * @param {number} expLen Total length of sum of specified fields in the standard
+     * @param atomId Atom ID
      */
     protected constructor(len: number, expLen: number, atomId: string);
 }
@@ -148,7 +149,7 @@ export interface IAtomMdhd extends IAtomMxhd {
 export declare class MdhdAtom extends FixedLengthAtom implements IGetToken<IAtomMdhd> {
     len: number;
     constructor(len: number);
-    get(buf: Buffer, off: number): IAtomMdhd;
+    get(buf: Uint8Array, off: number): IAtomMdhd;
 }
 /**
  * Token: Movie Header Atom
@@ -156,7 +157,7 @@ export declare class MdhdAtom extends FixedLengthAtom implements IGetToken<IAtom
 export declare class MvhdAtom extends FixedLengthAtom implements IGetToken<IAtomMvhd> {
     len: number;
     constructor(len: number);
-    get(buf: Buffer, off: number): IAtomMvhd;
+    get(buf: Uint8Array, off: number): IAtomMvhd;
 }
 /**
  * Data Atom Structure ('data')
@@ -209,7 +210,7 @@ export interface INameAtom extends IVersionAndFlags {
 export declare class NameAtom implements IGetToken<INameAtom> {
     len: number;
     constructor(len: number);
-    get(buf: Buffer, off: number): INameAtom;
+    get(buf: Uint8Array, off: number): INameAtom;
 }
 /**
  * Track Header Atoms interface
@@ -262,7 +263,7 @@ export interface ITrackHeaderAtom extends IVersionAndFlags {
 export declare class TrackHeaderAtom implements IGetToken<ITrackHeaderAtom> {
     len: number;
     constructor(len: number);
-    get(buf: Buffer, off: number): ITrackHeaderAtom;
+    get(buf: Uint8Array, off: number): ITrackHeaderAtom;
 }
 /**
  * Atom: Sample Description Atom ('stsd')
@@ -289,7 +290,7 @@ export interface IAtomStsd {
 export declare class StsdAtom implements IGetToken<IAtomStsd> {
     len: number;
     constructor(len: number);
-    get(buf: Buffer, off: number): IAtomStsd;
+    get(buf: Uint8Array, off: number): IAtomStsd;
 }
 export interface ISoundSampleDescriptionVersion {
     version: number;
@@ -327,7 +328,7 @@ declare class SimpleTableAtom<T> implements IGetToken<ITableAtom<T>> {
     len: number;
     private token;
     constructor(len: number, token: IGetToken<T>);
-    get(buf: Buffer, off: number): ITableAtom<T>;
+    get(buf: Uint8Array, off: number): ITableAtom<T>;
 }
 export interface ITimeToSampleToken {
     count: number;
@@ -373,7 +374,7 @@ export interface IStszAtom extends ITableAtom<number> {
 export declare class StszAtom implements IGetToken<IStszAtom> {
     len: number;
     constructor(len: number);
-    get(buf: Buffer, off: number): IStszAtom;
+    get(buf: Uint8Array, off: number): IStszAtom;
 }
 /**
  * Chunk offset atom, 'stco'
@@ -389,6 +390,6 @@ export declare class StcoAtom extends SimpleTableAtom<number> {
 export declare class ChapterText implements IGetToken<string> {
     len: number;
     constructor(len: number);
-    get(buf: Buffer, off: number): string;
+    get(buf: Uint8Array, off: number): string;
 }
 export {};

package/lib/mp4/AtomToken.js

@@ -61,6 +61,7 @@ export class FixedLengthAtom {
      *
      * @param {number} len Length as specified in the size field
      * @param {number} expLen Total length of sum of specified fields in the standard
+     * @param atomId Atom ID
      */
     constructor(len, expLen, atomId) {
         this.len = len;

package/lib/mpeg/MpegParser.js

@@ -212,9 +212,9 @@ export class MpegParser extends AbstractID3Parser {
         this.totalDataLength = 0;
         this.bitrates = [];
         this.calculateEofDuration = false;
-        this.buf_frame_header = Buffer.alloc(4);
+        this.buf_frame_header = new Uint8Array(4);
         this.syncPeek = {
-            buf: Buffer.alloc(maxPeekLen),
+            buf: new Uint8Array(maxPeekLen),
             len: 0
         };
     }
@@ -394,7 +394,7 @@ export class MpegParser extends AbstractID3Parser {
         }
     }
     async parseAdts(header) {
-        const buf = Buffer.alloc(3);
+        const buf = new Uint8Array(3);
         await this.tokenizer.readBuffer(buf);
         header.frameLength += common.getBitAllignedNumber(buf, 0, 0, 11);
         this.totalDataLength += header.frameLength;

package/lib/mpeg/XingTag.d.ts

@@ -26,7 +26,7 @@ export interface IXingInfoTag {
      * Actual stream size = file size - header(s) size [bytes]
      */
     streamSize?: number;
-    toc?: Buffer;
+    toc?: Uint8Array;
     /**
      * the number of header data bytes (from original file)
      */

package/lib/mpeg/XingTag.js

@@ -40,7 +40,7 @@ export async function readXingHeader(tokenizer) {
         xingInfoTag.streamSize = await tokenizer.readToken(Token.UINT32_BE);
     }
     if (flags.toc) {
-        xingInfoTag.toc = Buffer.alloc(100);
+        xingInfoTag.toc = new Uint8Array(100);
         await tokenizer.readBuffer(xingInfoTag.toc);
     }
     if (flags.vbrScale) {

package/lib/ogg/opus/OpusParser.d.ts

@@ -16,9 +16,9 @@ export declare class OpusParser extends VorbisParser {
     /**
      * Parse first Opus Ogg page
      * @param {IPageHeader} header
-     * @param {Buffer} pageData
+     * @param {Uint8Array} pageData
      */
-    protected parseFirstPage(header: IPageHeader, pageData: Buffer): void;
-    protected parseFullPage(pageData: Buffer): Promise<void>;
+    protected parseFirstPage(header: IPageHeader, pageData: Uint8Array): void;
+    protected parseFullPage(pageData: Uint8Array): Promise<void>;
     calculateDuration(header: IPageHeader): void;
 }

package/lib/ogg/opus/OpusParser.js

@@ -15,7 +15,7 @@ export class OpusParser extends VorbisParser {
     /**
      * Parse first Opus Ogg page
      * @param {IPageHeader} header
-     * @param {Buffer} pageData
+     * @param {Uint8Array} pageData
      */
     parseFirstPage(header, pageData) {
         this.metadata.setFormat('codec', 'Opus');

package/lib/ogg/speex/SpeexParser.d.ts

@@ -15,7 +15,7 @@ export declare class SpeexParser extends VorbisParser {
     /**
      * Parse first Speex Ogg page
      * @param {IPageHeader} header
-     * @param {Buffer} pageData
+     * @param {Uint8Array} pageData
      */
-    protected parseFirstPage(header: IPageHeader, pageData: Buffer): void;
+    protected parseFirstPage(header: IPageHeader, pageData: Uint8Array): void;
 }

package/lib/ogg/speex/SpeexParser.js

@@ -16,7 +16,7 @@ export class SpeexParser extends VorbisParser {
     /**
      * Parse first Speex Ogg page
      * @param {IPageHeader} header
-     * @param {Buffer} pageData
+     * @param {Uint8Array} pageData
      */
     parseFirstPage(header, pageData) {
         debug('First Ogg/Speex page');

package/lib/ogg/theora/TheoraParser.d.ts

@@ -15,7 +15,7 @@ export declare class TheoraParser implements Ogg.IPageConsumer {
      * @param header Ogg Page Header
      * @param pageData Page data
      */
-    parsePage(header: Ogg.IPageHeader, pageData: Buffer): Promise<void>;
+    parsePage(header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
     flush(): Promise<void>;
     calculateDuration(header: Ogg.IPageHeader): void;
     /**
@@ -23,5 +23,5 @@ export declare class TheoraParser implements Ogg.IPageConsumer {
      * @param {IPageHeader} header
      * @param {Buffer} pageData
      */
-    protected parseFirstPage(header: Ogg.IPageHeader, pageData: Buffer): Promise<void>;
+    protected parseFirstPage(header: Ogg.IPageHeader, pageData: Uint8Array): Promise<void>;
 }

package/lib/ogg/vorbis/VorbisParser.d.ts

@@ -16,9 +16,10 @@ export declare class VorbisParser implements IPageConsumer {
      * @param header Ogg Page Header
      * @param pageData Page data
      */
-    parsePage(header: IPageHeader, pageData: Buffer): Promise<void>;
+    parsePage(header: IPageHeader, pageData: Uint8Array): Promise<void>;
+    private static mergeUint8Arrays;
     flush(): Promise<void>;
-    parseUserComment(pageData: Buffer, offset: number): Promise<number>;
+    parseUserComment(pageData: Uint8Array, offset: number): Promise<number>;
     addTag(id: string, value: string | IVorbisPicture): Promise<void>;
     calculateDuration(header: IPageHeader): void;
     /**
@@ -26,10 +27,10 @@ export declare class VorbisParser implements IPageConsumer {
      * @param header
      * @param pageData
      */
-    protected parseFirstPage(header: IPageHeader, pageData: Buffer): void;
-    protected parseFullPage(pageData: Buffer): Promise<void>;
+    protected parseFirstPage(header: IPageHeader, pageData: Uint8Array): void;
+    protected parseFullPage(pageData: Uint8Array): Promise<void>;
     /**
      * Ref: https://xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-840005.2
      */
-    protected parseUserCommentList(pageData: Buffer, offset: number): Promise<void>;
+    protected parseUserCommentList(pageData: Uint8Array, offset: number): Promise<void>;
 }

package/lib/ogg/vorbis/VorbisParser.js

@@ -32,7 +32,7 @@ export class VorbisParser {
             if (header.headerType.lastPage || !header.headerType.continued) {
                 // Flush page segments
                 if (this.pageSegments.length > 0) {
-                    const fullPage = Buffer.concat(this.pageSegments);
+                    const fullPage = VorbisParser.mergeUint8Arrays(this.pageSegments);
                     await this.parseFullPage(fullPage);
                 }
                 // Reset page segments
@@ -43,8 +43,17 @@ export class VorbisParser {
             this.calculateDuration(header);
         }
     }
+    static mergeUint8Arrays(arrays) {
+        const totalSize = arrays.reduce((acc, e) => acc + e.length, 0);
+        const merged = new Uint8Array(totalSize);
+        arrays.forEach((array, i, _arrays) => {
+            const offset = _arrays.slice(0, i).reduce((acc, e) => acc + e.length, 0);
+            merged.set(array, offset);
+        });
+        return merged;
+    }
     async flush() {
-        await this.parseFullPage(Buffer.concat(this.pageSegments));
+        await this.parseFullPage(VorbisParser.mergeUint8Arrays(this.pageSegments));
     }
     async parseUserComment(pageData, offset) {
         const decoder = new VorbisDecoder(pageData, offset);

package/lib/wav/WaveChunk.d.ts

@@ -59,5 +59,5 @@ export interface IFactChunk {
 export declare class FactChunk implements IGetToken<IFactChunk> {
     len: number;
     constructor(header: IChunkHeader);
-    get(buf: Buffer, off: number): IFactChunk;
+    get(buf: Uint8Array, off: number): IFactChunk;
 }

package/lib/wavpack/WavPackParser.d.ts

@@ -8,6 +8,7 @@ export declare class WavPackParser extends BasicParser {
     parseWavPackBlocks(): Promise<void>;
     /**
      * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf, 3.0 Metadata Sub-blocks
+     * @param header Header
      * @param remainingLength
      */
     private parseMetadataSubBlock;

package/lib/wavpack/WavPackParser.js

@@ -4,6 +4,7 @@ import { FourCcToken } from '../common/FourCC.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { WavPack } from './WavPackToken.js';
 import initDebug from 'debug';
+import { uint8ArrayToHex } from 'uint8array-extras';
 const debug = initDebug('music-metadata:parser:WavPack');
 /**
  * WavPack Parser
@@ -49,13 +50,14 @@ export class WavPackParser extends BasicParser {
     }
     /**
      * Ref: http://www.wavpack.com/WavPack5FileFormat.pdf, 3.0 Metadata Sub-blocks
+     * @param header Header
      * @param remainingLength
      */
     async parseMetadataSubBlock(header, remainingLength) {
         while (remainingLength > WavPack.MetadataIdToken.len) {
             const id = await this.tokenizer.readToken(WavPack.MetadataIdToken);
             const dataSizeInWords = await this.tokenizer.readNumber(id.largeBlock ? Token.UINT24_LE : Token.UINT8);
-            const data = Buffer.alloc(dataSizeInWords * 2 - (id.isOddSize ? 1 : 0));
+            const data = new Uint8Array(dataSizeInWords * 2 - (id.isOddSize ? 1 : 0));
             await this.tokenizer.readBuffer(data);
             debug(`Metadata Sub-Blocks functionId=0x${id.functionId.toString(16)}, id.largeBlock=${id.largeBlock},data-size=${data.length}`);
             switch (id.functionId) {
@@ -78,7 +80,7 @@ export class WavPackParser extends BasicParser {
                     this.metadata.setFormat('audioMD5', data);
                     break;
                 case 0x2f: // ID_BLOCK_CHECKSUM
-                    debug(`ID_BLOCK_CHECKSUM: checksum=${data.toString('hex')}`);
+                    debug(`ID_BLOCK_CHECKSUM: checksum=${uint8ArrayToHex(data)}`);
                     break;
                 default:
                     debug(`Ignore unsupported meta-sub-block-id functionId=0x${id.functionId.toString(16)}`);