music-metadata 8.2.0 → 9.0.0

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
@@ -183,7 +182,7 @@ export interface IDataAtom {
     /**
      * An array of bytes containing the value of the metadata.
      */
-    value: Buffer;
+    value: Uint8Array;
 }
 /**
  * Data Atom Structure

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) => {
@@ -150,7 +150,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/mp4/MP4TagMapper.js

@@ -84,7 +84,7 @@ const mp4TagMap = {
     '----:com.apple.iTunes:replaygain_album_minmax': 'replaygain_album_minmax',
     '----:com.apple.iTunes:replaygain_undo': 'replaygain_undo',
     // Additional mappings:
-    gnre: 'genre',
+    gnre: 'genre', // ToDo: check mapping
     '----:com.apple.iTunes:ALBUMARTISTSORT': 'albumartistsort',
     '----:com.apple.iTunes:ARTISTS': 'artists',
     '----:com.apple.iTunes:ORIGINALDATE': 'originaldate',

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';
@@ -19,8 +19,8 @@ const MPEG4 = {
      */
     AudioObjectTypes: [
         'AAC Main',
-        'AAC LC',
-        'AAC SSR',
+        'AAC LC', // Low Complexity
+        'AAC SSR', // Scalable Sample Rate
         'AAC LTP' // Long Term Prediction
     ],
     /**
@@ -188,7 +188,7 @@ MpegFrameHeader.sampling_rate_freq_index = {
 };
 MpegFrameHeader.samplesInFrameTable = [
     /* Layer   I    II   III */
-    [0, 384, 1152, 1152],
+    [0, 384, 1152, 1152], // MPEG-1
     [0, 384, 1152, 576] // MPEG-2(.5
 ];
 /**

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;

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>;
 }

package/lib/ogg/OggParser.d.ts

@@ -1,4 +1,4 @@
-import { IGetToken } from 'strtok3/core';
+import { IGetToken } from 'strtok3';
 import { BasicParser } from '../common/BasicParser.js';
 import * as Ogg from './Ogg.js';
 export declare class SegmentTable implements IGetToken<Ogg.ISegmentTable> {

package/lib/ogg/OggParser.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 util from '../common/Util.js';
 import { FourCcToken } from '../common/FourCC.js';
@@ -51,7 +51,7 @@ export class OggParser extends BasicParser {
                 const pageData = await this.tokenizer.readToken(new Token.Uint8ArrayType(segmentTable.totalPageSize));
                 debug('firstPage=%s, lastPage=%s, continued=%s', header.headerType.firstPage, header.headerType.lastPage, header.headerType.continued);
                 if (header.headerType.firstPage) {
-                    const id = new Token.StringType(7, 'ascii').get(Buffer.from(pageData), 0);
+                    const id = new TextDecoder('ascii').decode(pageData.subarray(0, 7));
                     switch (id) {
                         case '\x01vorbis': // Ogg/Vorbis
                             debug('Set page consumer to Ogg/Vorbis');
@@ -74,7 +74,7 @@ export class OggParser extends BasicParser {
                             throw new Error('gg audio-codec not recognized (id=' + id + ')');
                     }
                 }
-                this.pageConsumer.parsePage(header, pageData);
+                await this.pageConsumer.parsePage(header, pageData);
             } while (!header.headerType.lastPage);
         }
         catch (err) {
@@ -90,7 +90,7 @@ export class OggParser extends BasicParser {
                 if (this.pageNumber > 0) {
                     // ignore this error: work-around if last OGG-page is not marked with last-page flag
                     this.metadata.addWarning('Invalid FourCC ID, maybe last OGG-page is not marked with last-page flag');
-                    this.pageConsumer.flush();
+                    await this.pageConsumer.flush();
                 }
             }
             else {
@@ -110,7 +110,7 @@ OggParser.Header = {
                 firstPage: util.getBit(buf, off + 5, 1),
                 lastPage: util.getBit(buf, off + 5, 2)
             },
-            // packet_flag: buf.readUInt8(off + 5),
+            // packet_flag: Token.UINT8.get(buf, off + 5),
             absoluteGranulePosition: Number(Token.UINT64_LE.get(buf, off + 6)),
             streamSerialNumber: Token.UINT32_LE.get(buf, off + 14),
             pageSequenceNo: Token.UINT32_LE.get(buf, off + 18),

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

@@ -1,4 +1,4 @@
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 /**
  * Opus ID Header interface
  * Ref: https://wiki.xiph.org/OggOpus#ID_Header

package/lib/ogg/opus/Opus.js

@@ -13,12 +13,12 @@ export class IdHeader {
     get(buf, off) {
         return {
             magicSignature: new Token.StringType(8, 'ascii').get(buf, off + 0),
-            version: buf.readUInt8(off + 8),
-            channelCount: buf.readUInt8(off + 9),
-            preSkip: buf.readInt16LE(off + 10),
-            inputSampleRate: buf.readInt32LE(off + 12),
-            outputGain: buf.readInt16LE(off + 16),
-            channelMapping: buf.readUInt8(off + 18)
+            version: Token.UINT8.get(buf, off + 8),
+            channelCount: Token.UINT8.get(buf, off + 9),
+            preSkip: Token.UINT16_LE.get(buf, off + 10),
+            inputSampleRate: Token.UINT32_LE.get(buf, off + 12),
+            outputGain: Token.UINT16_LE.get(buf, off + 16),
+            channelMapping: Token.UINT8.get(buf, off + 18)
         };
     }
 }

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

@@ -1,5 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-import { ITokenizer } from 'strtok3/core';
+import { ITokenizer } from 'strtok3';
 import { IPageHeader } from '../Ogg.js';
 import { VorbisParser } from '../vorbis/VorbisParser.js';
 import { IOptions } from '../../type.js';
@@ -20,6 +19,6 @@ export declare class OpusParser extends VorbisParser {
      * @param {Buffer} pageData
      */
     protected parseFirstPage(header: IPageHeader, pageData: Buffer): void;
-    protected parseFullPage(pageData: Buffer): void;
+    protected parseFullPage(pageData: Buffer): Promise<void>;
     calculateDuration(header: IPageHeader): void;
 }

package/lib/ogg/opus/OpusParser.js

@@ -26,11 +26,11 @@ export class OpusParser extends VorbisParser {
         this.metadata.setFormat('sampleRate', this.idHeader.inputSampleRate);
         this.metadata.setFormat('numberOfChannels', this.idHeader.channelCount);
     }
-    parseFullPage(pageData) {
+    async parseFullPage(pageData) {
         const magicSignature = new Token.StringType(8, 'ascii').get(pageData, 0);
         switch (magicSignature) {
             case 'OpusTags':
-                this.parseUserCommentList(pageData, 8);
+                await this.parseUserCommentList(pageData, 8);
                 this.lastPos = this.tokenizer.position - pageData.length;
                 break;
             default:

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

@@ -1,4 +1,4 @@
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 /**
  * Speex Header Packet
  * Ref: https://www.speex.org/docs/manual/speex-manual/node8.html#SECTION00830000000000000000

package/lib/ogg/speex/Speex.js

@@ -10,19 +10,19 @@ export const Header = {
         return {
             speex: new Token.StringType(8, 'ascii').get(buf, off + 0),
             version: util.trimRightNull(new Token.StringType(20, 'ascii').get(buf, off + 8)),
-            version_id: buf.readInt32LE(off + 28),
-            header_size: buf.readInt32LE(off + 32),
-            rate: buf.readInt32LE(off + 36),
-            mode: buf.readInt32LE(off + 40),
-            mode_bitstream_version: buf.readInt32LE(off + 44),
-            nb_channels: buf.readInt32LE(off + 48),
-            bitrate: buf.readInt32LE(off + 52),
-            frame_size: buf.readInt32LE(off + 56),
-            vbr: buf.readInt32LE(off + 60),
-            frames_per_packet: buf.readInt32LE(off + 64),
-            extra_headers: buf.readInt32LE(off + 68),
-            reserved1: buf.readInt32LE(off + 72),
-            reserved2: buf.readInt32LE(off + 76)
+            version_id: Token.INT32_LE.get(buf, off + 28),
+            header_size: Token.INT32_LE.get(buf, off + 32),
+            rate: Token.INT32_LE.get(buf, off + 36),
+            mode: Token.INT32_LE.get(buf, off + 40),
+            mode_bitstream_version: Token.INT32_LE.get(buf, off + 44),
+            nb_channels: Token.INT32_LE.get(buf, off + 48),
+            bitrate: Token.INT32_LE.get(buf, off + 52),
+            frame_size: Token.INT32_LE.get(buf, off + 56),
+            vbr: Token.INT32_LE.get(buf, off + 60),
+            frames_per_packet: Token.INT32_LE.get(buf, off + 64),
+            extra_headers: Token.INT32_LE.get(buf, off + 68),
+            reserved1: Token.INT32_LE.get(buf, off + 72),
+            reserved2: Token.INT32_LE.get(buf, off + 76)
         };
     }
 };

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

@@ -1,5 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-import { ITokenizer } from 'strtok3/core';
+import { ITokenizer } from 'strtok3';
 import { IPageHeader } from '../Ogg.js';
 import { VorbisParser } from '../vorbis/VorbisParser.js';
 import { IOptions } from '../../type.js';

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

@@ -1,4 +1,4 @@
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 /**
  * 6.2 Identification Header
  * Ref: https://theora.org/doc/Theora.pdf: 6.2 Identification Header Decode

package/lib/ogg/theora/Theora.js

@@ -8,13 +8,13 @@ export const IdentificationHeader = {
     get: (buf, off) => {
         return {
             id: new Token.StringType(7, 'ascii').get(buf, off),
-            vmaj: buf.readUInt8(off + 7),
-            vmin: buf.readUInt8(off + 8),
-            vrev: buf.readUInt8(off + 9),
-            vmbw: buf.readUInt16BE(off + 10),
-            vmbh: buf.readUInt16BE(off + 17),
+            vmaj: Token.UINT8.get(buf, off + 7),
+            vmin: Token.UINT8.get(buf, off + 8),
+            vrev: Token.UINT8.get(buf, off + 9),
+            vmbw: Token.UINT16_BE.get(buf, off + 10),
+            vmbh: Token.UINT16_BE.get(buf, off + 17),
             nombr: Token.UINT24_BE.get(buf, off + 37),
-            nqual: buf.readUInt8(off + 40)
+            nqual: Token.UINT8.get(buf, off + 40)
         };
     }
 };

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

@@ -1,5 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-import { ITokenizer } from 'strtok3/core';
+import { ITokenizer } from 'strtok3';
 import * as Ogg from '../Ogg.js';
 import { IOptions } from '../../type.js';
 import { INativeMetadataCollector } from '../../common/MetadataCollector.js';
@@ -16,13 +15,13 @@ export declare class TheoraParser implements Ogg.IPageConsumer {
      * @param header Ogg Page Header
      * @param pageData Page data
      */
-    parsePage(header: Ogg.IPageHeader, pageData: Buffer): void;
-    flush(): void;
+    parsePage(header: Ogg.IPageHeader, pageData: Buffer): Promise<void>;
+    flush(): Promise<void>;
     calculateDuration(header: Ogg.IPageHeader): void;
     /**
      * Parse first Theora Ogg page. the initial identification header packet
      * @param {IPageHeader} header
      * @param {Buffer} pageData
      */
-    protected parseFirstPage(header: Ogg.IPageHeader, pageData: Buffer): void;
+    protected parseFirstPage(header: Ogg.IPageHeader, pageData: Buffer): Promise<void>;
 }

package/lib/ogg/theora/TheoraParser.js

@@ -15,12 +15,12 @@ export class TheoraParser {
      * @param header Ogg Page Header
      * @param pageData Page data
      */
-    parsePage(header, pageData) {
+    async parsePage(header, pageData) {
         if (header.headerType.firstPage) {
-            this.parseFirstPage(header, pageData);
+            await this.parseFirstPage(header, pageData);
         }
     }
-    flush() {
+    async flush() {
         debug('flush');
     }
     calculateDuration(header) {
@@ -31,7 +31,7 @@ export class TheoraParser {
      * @param {IPageHeader} header
      * @param {Buffer} pageData
      */
-    parseFirstPage(header, pageData) {
+    async parseFirstPage(header, pageData) {
         debug('First Ogg/Theora page');
         this.metadata.setFormat('codec', 'Theora');
         const idHeader = IdentificationHeader.get(pageData, 0);

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

@@ -1,6 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
 import { IPicture } from '../../type.js';
-import { IGetToken } from 'strtok3/core';
+import type { IGetToken } from 'strtok3';
 /**
  * Interface to parsed result of METADATA_BLOCK_PICTURE
  * Ref: https://wiki.xiph.org/VorbisComment#METADATA_BLOCK_PICTURE
@@ -23,9 +22,9 @@ export interface IVorbisPicture extends IPicture {
 export declare class VorbisPictureToken implements IGetToken<IVorbisPicture> {
     len: any;
     static fromBase64(base64str: string): IVorbisPicture;
-    static fromBuffer(buffer: Buffer): IVorbisPicture;
+    static fromBuffer(buffer: Uint8Array): IVorbisPicture;
     constructor(len: any);
-    get(buffer: Buffer, offset: number): IVorbisPicture;
+    get(buffer: Uint8Array, offset: number): IVorbisPicture;
 }
 /**
  * Vorbis 1 decoding tokens

package/lib/ogg/vorbis/Vorbis.js

@@ -8,7 +8,7 @@ import { AttachedPictureType } from '../../id3v2/ID3v2Token.js';
  */
 export class VorbisPictureToken {
     static fromBase64(base64str) {
-        return this.fromBuffer(Buffer.from(base64str, 'base64'));
+        return this.fromBuffer(Uint8Array.from(atob(base64str), c => c.charCodeAt(0)));
     }
     static fromBuffer(buffer) {
         const pic = new VorbisPictureToken(buffer.length);
@@ -20,15 +20,15 @@ export class VorbisPictureToken {
     get(buffer, offset) {
         const type = AttachedPictureType[Token.UINT32_BE.get(buffer, offset)];
         const mimeLen = Token.UINT32_BE.get(buffer, offset += 4);
-        const format = buffer.toString('utf-8', offset += 4, offset + mimeLen);
+        const format = new Token.StringType(mimeLen, 'utf-8').get(buffer, offset += 4);
         const descLen = Token.UINT32_BE.get(buffer, offset += mimeLen);
-        const description = buffer.toString('utf-8', offset += 4, offset + descLen);
+        const description = new Token.StringType(descLen, 'utf-8').get(buffer, offset += 4);
         const width = Token.UINT32_BE.get(buffer, offset += descLen);
         const height = Token.UINT32_BE.get(buffer, offset += 4);
         const colour_depth = Token.UINT32_BE.get(buffer, offset += 4);
         const indexed_color = Token.UINT32_BE.get(buffer, offset += 4);
         const picDataLen = Token.UINT32_BE.get(buffer, offset += 4);
-        const data = Buffer.from(buffer.slice(offset += 4, offset + picDataLen));
+        const data = Uint8Array.from(buffer.slice(offset += 4, offset + picDataLen));
         return {
             type,
             format,
@@ -49,7 +49,7 @@ export const CommonHeader = {
     len: 7,
     get: (buf, off) => {
         return {
-            packetType: buf.readUInt8(off),
+            packetType: Token.UINT8.get(buf, off),
             vorbis: new Token.StringType(6, 'ascii').get(buf, off + 1)
         };
     }
@@ -61,14 +61,13 @@ export const CommonHeader = {
 export const IdentificationHeader = {
     len: 23,
     get: (uint8Array, off) => {
-        const dataView = new DataView(uint8Array.buffer, uint8Array.byteOffset);
         return {
-            version: dataView.getUint32(off + 0, true),
-            channelMode: dataView.getUint8(off + 4),
-            sampleRate: dataView.getUint32(off + 5, true),
-            bitrateMax: dataView.getUint32(off + 9, true),
-            bitrateNominal: dataView.getUint32(off + 13, true),
-            bitrateMin: dataView.getUint32(off + 17, true)
+            version: Token.UINT32_LE.get(uint8Array, off + 0),
+            channelMode: Token.UINT8.get(uint8Array, off + 4),
+            sampleRate: Token.UINT32_LE.get(uint8Array, off + 5),
+            bitrateMax: Token.UINT32_LE.get(uint8Array, off + 9),
+            bitrateNominal: Token.UINT32_LE.get(uint8Array, off + 13),
+            bitrateMin: Token.UINT32_LE.get(uint8Array, off + 17)
         };
     }
 };

package/lib/ogg/vorbis/VorbisDecoder.js

@@ -11,7 +11,7 @@ export class VorbisDecoder {
     }
     readStringUtf8() {
         const len = this.readInt32();
-        const value = Buffer.from(this.data).toString('utf-8', this.offset, this.offset + len);
+        const value = new TextDecoder('utf-8').decode(this.data.subarray(this.offset, this.offset + len));
         this.offset += len;
         return value;
     }