music-metadata 8.3.0 → 9.0.1

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('binary');
-        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

@@ -1,4 +1,4 @@
-import { ITokenizer } from 'strtok3/core';
+import type { ITokenizer } from 'strtok3';
 import { INativeMetadataCollector } from '../common/MetadataCollector.js';
 import { BasicParser } from '../common/BasicParser.js';
 import { IOptions } from '../type.js';
@@ -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));
     }
@@ -44,8 +45,8 @@ export class MatroskaParser extends BasicParser {
                 const timecodeScale = info.timecodeScale ? info.timecodeScale : 1000000;
                 if (typeof info.duration === 'number') {
                     const duration = info.duration * timecodeScale / 1000000000;
-                    this.addTag('segment:title', info.title);
-                    this.metadata.setFormat('duration', duration);
+                    await this.addTag('segment:title', info.title);
+                    this.metadata.setFormat('duration', Number(duration));
                 }
             }
             const audioTracks = matroska.segment.tracks;
@@ -87,28 +88,24 @@ export class MatroskaParser extends BasicParser {
                     this.metadata.setFormat('numberOfChannels', audioTrack.audio.channels);
                 }
                 if (matroska.segment.tags) {
-                    matroska.segment.tags.tag.forEach(tag => {
+                    await Promise.all(matroska.segment.tags.tag.map(async (tag) => {
                         const target = tag.target;
                         const targetType = (target === null || target === void 0 ? void 0 : target.targetTypeValue) ? TargetType[target.targetTypeValue] : ((target === null || target === void 0 ? void 0 : target.targetType) ? target.targetType : 'track');
-                        tag.simpleTags.forEach(simpleTag => {
+                        await Promise.all(tag.simpleTags.map(async (simpleTag) => {
                             const value = simpleTag.string ? simpleTag.string : simpleTag.binary;
-                            this.addTag(`${targetType}:${simpleTag.name}`, value);
-                        });
-                    });
+                            await this.addTag(`${targetType}:${simpleTag.name}`, value);
+                        }));
+                    }));
                 }
                 if (matroska.segment.attachments) {
-                    matroska.segment.attachments.attachedFiles
+                    await Promise.all(matroska.segment.attachments.attachedFiles
                         .filter(file => file.mimeType.startsWith('image/'))
-                        .map(file => {
-                        return {
-                            data: file.data,
-                            format: file.mimeType,
-                            description: file.description,
-                            name: file.name
-                        };
-                    }).forEach(picture => {
-                        this.addTag('picture', picture);
-                    });
+                        .map(file => this.addTag('picture', {
+                        data: file.data,
+                        format: file.mimeType,
+                        description: file.description,
+                        name: file.name
+                    })));
                 }
             }
         }
@@ -172,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;
     }
@@ -180,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:
@@ -215,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(/\00.*$/g, '');
+        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;
     }
-    addTag(tagId, value) {
-        this.metadata.addTag('matroska', tagId, value);
+    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

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 export interface IHeader {
     id: number;
     len: number;
@@ -18,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;
@@ -40,7 +39,7 @@ export interface ISegmentInformation {
     writingApp?: string;
 }
 export interface ITrackEntry {
-    uid?: Buffer;
+    uid?: Uint8Array;
     trackNumber?: number;
     trackType?: TrackType;
     audio?: ITrackAudio;
@@ -53,7 +52,7 @@ export interface ITrackEntry {
     name?: string;
     language?: string;
     codecID?: string;
-    codecPrivate?: Buffer;
+    codecPrivate?: Uint8Array;
     codecName?: string;
     codecSettings?: string;
     codecInfoUrl?: string;
@@ -70,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 {
@@ -100,7 +99,7 @@ export interface ICueReference {
 export interface ISimpleTag {
     name?: string;
     'string'?: string;
-    binary?: Buffer;
+    binary?: Uint8Array;
     language?: string;
     default?: boolean;
 }
@@ -123,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;
 }
@@ -143,7 +142,7 @@ export interface IAttachmedFile {
     description?: string;
     name: string;
     mimeType: string;
-    data: Buffer;
+    data: Uint8Array;
     uid: string;
 }
 export interface IAttachments {

package/lib/mp4/Atom.d.ts

@@ -1,5 +1,5 @@
 import * as AtomToken from './AtomToken.js';
-import { ITokenizer } from 'strtok3/core';
+import type { ITokenizer } from 'strtok3';
 export type AtomDataHandler = (atom: Atom, remaining: number) => Promise<void>;
 export declare class Atom {
     readonly header: AtomToken.IAtomHeader;

package/lib/mp4/AtomToken.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-import { IToken, IGetToken } from 'strtok3/core';
+import type { IToken, IGetToken } from 'strtok3';
 interface IVersionAndFlags {
     /**
      * A 1-byte specification of the version
@@ -124,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);
 }
@@ -149,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
@@ -157,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')
@@ -183,7 +183,7 @@ export interface IDataAtom {
     /**
      * An array of bytes containing the value of the metadata.
      */
-    value: Buffer;
+    value: Uint8Array;
 }
 /**
  * Data Atom Structure
@@ -210,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
@@ -263,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')
@@ -290,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;
@@ -328,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;
@@ -374,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'
@@ -390,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

@@ -10,7 +10,7 @@ export const Header = {
             throw new Error('Invalid atom header length');
         return {
             length: BigInt(length),
-            name: new Token.StringType(4, 'binary').get(buf, off + 4)
+            name: new Token.StringType(4, 'latin1').get(buf, off + 4)
         };
     },
     put: (buf, off, hdr) => {
@@ -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;
@@ -150,7 +151,7 @@ export class DataAtom {
                 type: Token.UINT24_BE.get(buf, off + 1)
             },
             locale: Token.UINT24_BE.get(buf, off + 4),
-            value: Buffer.from(new Token.Uint8ArrayType(this.len - 8).get(buf, off + 8))
+            value: new Token.Uint8ArrayType(this.len - 8).get(buf, off + 8)
         };
     }
 }

package/lib/mp4/MP4Parser.js

@@ -5,6 +5,7 @@ import { Genres } from '../id3v1/ID3v1Parser.js';
 import { Atom } from './Atom.js';
 import * as AtomToken from './AtomToken.js';
 import { TrackType } from '../type.js';
+import { uint8ArrayToHex, uint8ArrayToString } from 'uint8array-extras';
 const debug = initDebug('music-metadata:parser:MP4');
 const tagFormat = 'iTunes';
 const encoderDict = {
@@ -199,7 +200,7 @@ export class MP4Parser extends BasicParser {
             },
             date: async (len) => {
                 const date = await this.tokenizer.readToken(new Token.StringType(len, 'utf-8'));
-                this.addTag('date', date);
+                await this.addTag('date', date);
             }
         };
     }
@@ -321,8 +322,8 @@ export class MP4Parser extends BasicParser {
             this.metadata.setFormat('bitrate', 8 * this.audioLengthInBytes / this.metadata.format.duration);
         }
     }
-    addTag(id, value) {
-        this.metadata.addTag(tagFormat, id, value);
+    async addTag(id, value) {
+        await this.metadata.addTag(tagFormat, id, value);
     }
     addWarning(message) {
         debug('Warning: ' + message);
@@ -347,8 +348,8 @@ export class MP4Parser extends BasicParser {
                     tagKey += ':' + name.name;
                     break;
                 default:
-                    const dataAtom = await this.tokenizer.readToken(new Token.BufferType(payLoadLength));
-                    this.addWarning('Unsupported meta-item: ' + tagKey + '[' + child.header.name + '] => value=' + dataAtom.toString('hex') + ' ascii=' + dataAtom.toString('ascii'));
+                    const uint8Array = await this.tokenizer.readToken(new Token.Uint8ArrayType(payLoadLength));
+                    this.addWarning('Unsupported meta-item: ' + tagKey + '[' + child.header.name + '] => value=' + uint8ArrayToHex(uint8Array) + ' ascii=' + uint8ArrayToString(uint8Array, 'ascii'));
             }
         }, metaAtom.getPayloadLength(0));
     }
@@ -367,17 +368,17 @@ export class MP4Parser extends BasicParser {
                         const num = Token.UINT8.get(dataAtom.value, 3);
                         const of = Token.UINT8.get(dataAtom.value, 5);
                         // console.log("  %s[data] = %s/%s", tagKey, num, of);
-                        this.addTag(tagKey, num + '/' + of);
+                        await this.addTag(tagKey, num + '/' + of);
                         break;
                     case 'gnre':
                         const genreInt = Token.UINT8.get(dataAtom.value, 1);
                         const genreStr = Genres[genreInt - 1];
                         // console.log("  %s[data] = %s", tagKey, genreStr);
-                        this.addTag(tagKey, genreStr);
+                        await this.addTag(tagKey, genreStr);
                         break;
                     case 'rate':
-                        const rate = dataAtom.value.toString('ascii');
-                        this.addTag(tagKey, rate);
+                        const rate = new TextDecoder('ascii').decode(dataAtom.value);
+                        await this.addTag(tagKey, rate);
                         break;
                     default:
                         debug('unknown proprietary value type for: ' + metaAtom.atomPath);
@@ -385,38 +386,38 @@ export class MP4Parser extends BasicParser {
                 break;
             case 1: // UTF-8: Without any count or NULL terminator
             case 18: // Unknown: Found in m4b in combination with a '©gen' tag
-                this.addTag(tagKey, dataAtom.value.toString('utf-8'));
+                await this.addTag(tagKey, new TextDecoder('utf-8').decode(dataAtom.value));
                 break;
             case 13: // JPEG
                 if (this.options.skipCovers)
                     break;
-                this.addTag(tagKey, {
+                await this.addTag(tagKey, {
                     format: 'image/jpeg',
-                    data: Buffer.from(dataAtom.value)
+                    data: Uint8Array.from(dataAtom.value)
                 });
                 break;
             case 14: // PNG
                 if (this.options.skipCovers)
                     break;
-                this.addTag(tagKey, {
+                await this.addTag(tagKey, {
                     format: 'image/png',
-                    data: Buffer.from(dataAtom.value)
+                    data: Uint8Array.from(dataAtom.value)
                 });
                 break;
             case 21: // BE Signed Integer
-                this.addTag(tagKey, MP4Parser.read_BE_Integer(dataAtom.value, true));
+                await this.addTag(tagKey, MP4Parser.read_BE_Integer(dataAtom.value, true));
                 break;
             case 22: // BE Unsigned Integer
-                this.addTag(tagKey, MP4Parser.read_BE_Integer(dataAtom.value, false));
+                await this.addTag(tagKey, MP4Parser.read_BE_Integer(dataAtom.value, false));
                 break;
             case 65: // An 8-bit signed integer
-                this.addTag(tagKey, dataAtom.value.readInt8(0));
+                await this.addTag(tagKey, Token.UINT8.get(dataAtom.value, 0));
                 break;
             case 66: // A big-endian 16-bit signed integer
-                this.addTag(tagKey, dataAtom.value.readInt16BE(0));
+                await this.addTag(tagKey, Token.UINT16_BE.get(dataAtom.value, 0));
                 break;
             case 67: // A big-endian 32-bit signed integer
-                this.addTag(tagKey, dataAtom.value.readInt32BE(0));
+                await this.addTag(tagKey, Token.UINT32_BE.get(dataAtom.value, 0));
                 break;
             default:
                 this.addWarning(`atom key=${tagKey}, has unknown well-known-type (data-type): ${dataAtom.type.type}`);

package/lib/mpeg/ExtendedLameHeader.d.ts

@@ -1,7 +1,7 @@
 /**
  * Extended Lame Header
  */
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 import { IReplayGain } from './ReplayGainDataFormat.js';
 /**
  * LAME Tag, extends the Xing header format

package/lib/mpeg/MpegParser.js

@@ -1,5 +1,5 @@
 import * as Token from 'token-types';
-import { EndOfStreamError } from 'strtok3/core';
+import { EndOfStreamError } from 'strtok3';
 import initDebug from 'debug';
 import * as common from '../common/Util.js';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.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/ReplayGainDataFormat.d.ts

@@ -1,4 +1,4 @@
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 export interface IReplayGain {
     type: NameCode;
     origin: ReplayGainOriginator;

package/lib/mpeg/XingTag.d.ts

@@ -1,6 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
 import * as Token from 'token-types';
-import { IGetToken, ITokenizer } from 'strtok3/core';
+import type { IGetToken, ITokenizer } from 'strtok3';
 import { IExtendedLameHeader } from './ExtendedLameHeader.js';
 export interface IXingHeaderFlags {
     frames: boolean;
@@ -27,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/musepack/index.js

@@ -6,7 +6,7 @@ import { MpcSv7Parser } from './sv7/MpcSv7Parser.js';
 const debug = initDebug('music-metadata:parser:musepack');
 class MusepackParser extends AbstractID3Parser {
     async postId3v2Parse() {
-        const signature = await this.tokenizer.peekToken(new Token.StringType(3, 'binary'));
+        const signature = await this.tokenizer.peekToken(new Token.StringType(3, 'latin1'));
         let mpcParser;
         switch (signature) {
             case 'MP+': {

package/lib/musepack/sv7/BitReader.d.ts

@@ -1,4 +1,4 @@
-import { ITokenizer } from 'strtok3/core';
+import type { ITokenizer } from 'strtok3';
 export declare class BitReader {
     private tokenizer;
     pos: number;

package/lib/musepack/sv7/StreamVersion7.d.ts

@@ -1,4 +1,4 @@
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 /**
  * MusePack stream version 7 format specification
  * http://trac.musepack.net/musepack/wiki/SV7Specification

package/lib/musepack/sv7/StreamVersion7.js

@@ -8,7 +8,7 @@ export const Header = {
     get: (buf, off) => {
         const header = {
             // word 0
-            signature: Buffer.from(buf).toString('latin1', off, off + 3),
+            signature: new TextDecoder('latin1').decode(buf.subarray(off, off + 3)),
             // versionIndex number * 1000 (3.81 = 3810) (remember that 4-byte alignment causes this to take 4-bytes)
             streamMinorVersion: util.getBitAllignedNumber(buf, off + 3, 0, 4),
             streamMajorVersion: util.getBitAllignedNumber(buf, off + 3, 4, 4),

package/lib/musepack/sv8/StreamVersion8.d.ts

@@ -1,4 +1,4 @@
-import { ITokenizer } from 'strtok3/core';
+import { ITokenizer } from 'strtok3';
 export interface IPacketHeader {
     key: string;
     payloadLength: number;

package/lib/musepack/sv8/StreamVersion8.js

@@ -2,7 +2,7 @@ import * as Token from 'token-types';
 import initDebug from 'debug';
 import * as util from '../../common/Util.js';
 const debug = initDebug('music-metadata:parser:musepack:sv8');
-const PacketKey = new Token.StringType(2, 'binary');
+const PacketKey = new Token.StringType(2, 'latin1');
 /**
  * Stream Header Packet part 1
  * Ref: http://trac.musepack.net/musepack/wiki/SV8Specification#StreamHeaderPacket

package/lib/ogg/Ogg.d.ts

@@ -59,7 +59,7 @@ export interface IPageConsumer {
      * @param {IPageHeader} header Ogg page header
      * @param {Buffer} pageData Ogg page data
      */
-    parsePage(header: IPageHeader, pageData: Uint8Array): any;
+    parsePage(header: IPageHeader, pageData: Uint8Array): Promise<void>;
     /**
      * Calculate duration of provided header
      * @param header Ogg header
@@ -68,5 +68,5 @@ export interface IPageConsumer {
     /**
      * Force to parse pending segments
      */
-    flush(): any;
+    flush(): Promise<void>;
 }