@openclaw/matrix 2026.10.2 → 2026.10.5-beta.2

package/node_modules/music-metadata/lib/dsdiff/DsdiffParser.js

@@ -1,11 +1,11 @@
-import * as Token from 'token-types';
 import initDebug from 'debug';
 import * as strtok3 from 'strtok3';
-import { FourCcToken } from '../common/FourCC.js';
+import * as Token from 'token-types';
 import { BasicParser } from '../common/BasicParser.js';
+import { FourCcToken } from '../common/FourCC.js';
 import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
-import { ChunkHeader64 } from './DsdiffToken.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { ChunkHeader64 } from './DsdiffToken.js';
 const debug = initDebug('music-metadata:parser:aiff');
 export class DsdiffContentParseError extends makeUnexpectedFileContentError('DSDIFF') {
 }
@@ -18,8 +18,9 @@ export class DsdiffContentParseError extends makeUnexpectedFileContentError('DSD
 export class DsdiffParser extends BasicParser {
     async parse() {
         const header = await this.tokenizer.readToken(ChunkHeader64);
-        if (header.chunkID !== 'FRM8')
+        if (header.chunkID !== 'FRM8') {
             throw new DsdiffContentParseError('Unexpected chunk-ID');
+        }
         this.metadata.setAudioOnly();
         const type = (await this.tokenizer.readToken(FourCcToken)).trim();
         switch (type) {
@@ -37,26 +38,30 @@ export class DsdiffParser extends BasicParser {
             //  If the data is an odd number of bytes in length, a pad byte must be added at the end
             debug(`Chunk id=${chunkHeader.chunkID}`);
             await this.readData(chunkHeader);
-            remainingSize -= (BigInt(ChunkHeader64.len) + chunkHeader.chunkSize);
+            remainingSize -= BigInt(ChunkHeader64.len) + chunkHeader.chunkSize;
         }
     }
     async readData(header) {
         debug(`Reading data of chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
         const p0 = this.tokenizer.position;
         switch (header.chunkID.trim()) {
-            case 'FVER': { // 3.1 FORMAT VERSION CHUNK
+            case 'FVER': {
+                // 3.1 FORMAT VERSION CHUNK
                 const version = await this.tokenizer.readToken(Token.UINT32_LE);
                 debug(`DSDIFF version=${version}`);
                 break;
             }
-            case 'PROP': { // 3.2 PROPERTY CHUNK
+            case 'PROP': {
+                // 3.2 PROPERTY CHUNK
                 const propType = await this.tokenizer.readToken(FourCcToken);
-                if (propType !== 'SND ')
+                if (propType !== 'SND ') {
                     throw new DsdiffContentParseError('Unexpected PROP-chunk ID');
+                }
                 await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCcToken.len));
                 break;
             }
-            case 'ID3': { // Unofficial ID3 tag support
+            case 'ID3': {
+                // Unofficial ID3 tag support
                 const id3_data = await this.tokenizer.readToken(new Token.Uint8ArrayType(Number(header.chunkSize)));
                 const rst = strtok3.fromBuffer(id3_data);
                 await new ID3v2Parser().parse(this.metadata, rst, this.options);
@@ -64,7 +69,7 @@ export class DsdiffParser extends BasicParser {
             }
             case 'DSD':
                 if (this.metadata.format.numberOfChannels) {
-                    this.metadata.setFormat('numberOfSamples', Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels)));
+                    this.metadata.setFormat('numberOfSamples', Number((header.chunkSize * BigInt(8)) / BigInt(this.metadata.format.numberOfChannels)));
                 }
                 if (this.metadata.format.numberOfSamples && this.metadata.format.sampleRate) {
                     this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
@@ -87,18 +92,21 @@ export class DsdiffParser extends BasicParser {
             debug(`Sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
             const p0 = this.tokenizer.position;
             switch (sndPropHeader.chunkID.trim()) {
-                case 'FS': { // 3.2.1 Sample Rate Chunk
+                case 'FS': {
+                    // 3.2.1 Sample Rate Chunk
                     const sampleRate = await this.tokenizer.readToken(Token.UINT32_BE);
                     this.metadata.setFormat('sampleRate', sampleRate);
                     break;
                 }
-                case 'CHNL': { // 3.2.2 Channels Chunk
+                case 'CHNL': {
+                    // 3.2.2 Channels Chunk
                     const numChannels = await this.tokenizer.readToken(Token.UINT16_BE);
                     this.metadata.setFormat('numberOfChannels', numChannels);
                     await this.handleChannelChunks(sndPropHeader.chunkSize - BigInt(Token.UINT16_BE.len));
                     break;
                 }
-                case 'CMPR': { // 3.2.3 Compression Type Chunk
+                case 'CMPR': {
+                    // 3.2.3 Compression Type Chunk
                     const compressionIdCode = (await this.tokenizer.readToken(FourCcToken)).trim();
                     const count = await this.tokenizer.readToken(Token.UINT8);
                     const compressionName = await this.tokenizer.readToken(new Token.StringType(count, 'ascii'));
@@ -109,7 +117,8 @@ export class DsdiffParser extends BasicParser {
                     this.metadata.setFormat('codec', `${compressionIdCode} (${compressionName})`);
                     break;
                 }
-                case 'ABSS': { // 3.2.4 Absolute Start Time Chunk
+                case 'ABSS': {
+                    // 3.2.4 Absolute Start Time Chunk
                     const hours = await this.tokenizer.readToken(Token.UINT16_BE);
                     const minutes = await this.tokenizer.readToken(Token.UINT8);
                     const seconds = await this.tokenizer.readToken(Token.UINT8);
@@ -117,7 +126,8 @@ export class DsdiffParser extends BasicParser {
                     debug(`ABSS ${hours}:${minutes}:${seconds}.${samples}`);
                     break;
                 }
-                case 'LSCO': { // 3.2.5 Loudspeaker Configuration Chunk
+                case 'LSCO': {
+                    // 3.2.5 Loudspeaker Configuration Chunk
                     const lsConfig = await this.tokenizer.readToken(Token.UINT16_BE);
                     debug(`LSCO lsConfig=${lsConfig}`);
                     break;
@@ -134,7 +144,10 @@ export class DsdiffParser extends BasicParser {
             remainingSize -= BigInt(ChunkHeader64.len) + sndPropHeader.chunkSize;
             debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
         }
-        if (this.metadata.format.lossless && this.metadata.format.sampleRate && this.metadata.format.numberOfChannels && this.metadata.format.bitsPerSample) {
+        if (this.metadata.format.lossless &&
+            this.metadata.format.sampleRate &&
+            this.metadata.format.numberOfChannels &&
+            this.metadata.format.bitsPerSample) {
             const bitrate = this.metadata.format.sampleRate * this.metadata.format.numberOfChannels * this.metadata.format.bitsPerSample;
             this.metadata.setFormat('bitrate', bitrate);
         }

package/node_modules/music-metadata/lib/dsf/DsfChunk.d.ts

@@ -43,7 +43,7 @@ export declare const ChannelType: {
     '5 channels': number;
     '5.1 channels': number;
 };
-export type ChannelType = typeof ChannelType[keyof typeof ChannelType];
+export type ChannelType = (typeof ChannelType)[keyof typeof ChannelType];
 /**
  * Interface to format chunk payload chunk
  */

package/node_modules/music-metadata/lib/dsf/DsfParser.js

@@ -1,9 +1,9 @@
 import initDebug from 'debug';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import { ChunkHeader, DsdChunk, FormatChunk } from './DsfChunk.js';
 import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
-import { makeUnexpectedFileContentError } from '../ParseError.js';
 import { ID3v2Header } from '../id3v2/ID3v2Token.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { ChunkHeader, DsdChunk, FormatChunk } from './DsfChunk.js';
 const debug = initDebug('music-metadata:parser:DSF');
 export class DsdContentParseError extends makeUnexpectedFileContentError('DSD') {
 }
@@ -66,9 +66,7 @@ export class DsfParser extends AbstractID3Parser {
                     this.metadata.setFormat('bitsPerSample', formatChunk.bitsPerSample);
                     this.metadata.setFormat('numberOfSamples', formatChunk.sampleCount);
                     this.metadata.setFormat('duration', Number(formatChunk.sampleCount) / formatChunk.samplingFrequency);
-                    const bitrate = formatChunk.bitsPerSample *
-                        formatChunk.samplingFrequency *
-                        formatChunk.channelNum;
+                    const bitrate = formatChunk.bitsPerSample * formatChunk.samplingFrequency * formatChunk.channelNum;
                     this.metadata.setFormat('bitrate', bitrate);
                     return; // We got what we want, stop further processing of chunks
                 }

package/node_modules/music-metadata/lib/ebml/EbmlIterator.d.ts

@@ -28,7 +28,7 @@ export declare const ParseAction: {
     readonly TerminateParsing: 4;
     readonly SkipElement: 5;
 };
-export type ParseAction = typeof ParseAction[keyof typeof ParseAction];
+export type ParseAction = (typeof ParseAction)[keyof typeof ParseAction];
 /**
  * @return true, to quit the parser
  */

package/node_modules/music-metadata/lib/ebml/EbmlIterator.js

@@ -1,9 +1,9 @@
-import { Float32_BE, Float64_BE, StringType, UINT8 } from 'token-types';
 import initDebug from 'debug';
 import { EndOfStreamError } from 'strtok3';
-import { DataType } from './types.js';
 import * as Token from 'token-types';
+import { Float32_BE, Float64_BE, StringType, UINT8 } from 'token-types';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { DataType } from './types.js';
 const debug = initDebug('music-metadata:parser:ebml');
 export class EbmlContentError extends makeUnexpectedFileContentError('EBML') {
 }
@@ -61,14 +61,15 @@ export class EbmlIterator {
                 switch (action) {
                     case ParseAction.ReadNext:
                         {
-                            if (element.id === 0x1F43B675) {
+                            if (element.id === 0x1f43b675) {
                                 // Hack to ignore remaining segment, when cluster element received
                                 // await this.tokenizer.ignore(posDone - this.tokenizer.position);
                                 // break;
                             }
                             debug(`Read element: name=${getElementPath(child)}{id=0x${element.id.toString(16)}, container=${!!child.container}} at position=${elementPosition}`);
                             if (child.container) {
-                                const res = await this.parseContainer(child, element.len >= 0 ? this.tokenizer.position + element.len : -1, listener);
+                                const childEnd = Math.min(posDone, this.tokenizer.fileInfo.size ?? Number.POSITIVE_INFINITY, element.len >= 0 ? this.tokenizer.position + element.len : posDone);
+                                const res = await this.parseContainer(child, childEnd, listener);
                                 if (child.multiple) {
                                     if (!tree[child.name]) {
                                         tree[child.name] = [];
@@ -83,6 +84,13 @@ export class EbmlIterator {
                             else {
                                 const parser = this.parserMap.get(child.value);
                                 if (typeof parser === 'function') {
+                                    // Validate before leaf readers allocate buffers or string tokens from the declared length.
+                                    const end = Math.min(posDone, this.tokenizer.fileInfo.size ?? Number.POSITIVE_INFINITY);
+                                    if (!Number.isSafeInteger(element.len) ||
+                                        element.len < 0 ||
+                                        element.len > end - this.tokenizer.position) {
+                                        throw new EbmlContentError(`Invalid element length: ${element.len}`);
+                                    }
                                     const value = await parser(element);
                                     tree[child.name] = value;
                                     await listener.elementValue(child, value, elementPosition);
@@ -166,10 +174,30 @@ export class EbmlIterator {
         return readUIntBE(buf, e.len);
     }
     async readString(e) {
-        const rawString = await this.tokenizer.readToken(new StringType(e.len, 'utf-8'));
+        const buf = await this.readBuffer(e);
+        const rawString = new StringType(e.len, 'utf-8').get(buf, 0);
         return rawString.replace(/\x00.*$/g, '');
     }
     async readBuffer(e) {
+        const chunkSize = 64 * 1024;
+        if ((!this.tokenizer.supportsRandomAccess() || this.tokenizer.fileInfo.size === undefined) && e.len > chunkSize) {
+            // Neither a declared container size nor an advertised stream size proves these bytes exist.
+            // Allocate incrementally, and only assemble the leaf after reading its payload.
+            const chunks = [];
+            for (let remaining = e.len; remaining > 0;) {
+                const chunk = new Uint8Array(Math.min(remaining, chunkSize));
+                await this.tokenizer.readBuffer(chunk);
+                chunks.push(chunk);
+                remaining -= chunk.length;
+            }
+            const buf = new Uint8Array(e.len);
+            let offset = 0;
+            for (const chunk of chunks) {
+                buf.set(chunk, offset);
+                offset += chunk.length;
+            }
+            return buf;
+        }
         const buf = new Uint8Array(e.len);
         await this.tokenizer.readBuffer(buf);
         return buf;
@@ -202,7 +230,8 @@ function linkParents(element) {
             const child = element.container[id];
             child.id = Number.parseInt(id, 10);
             return child;
-        }).forEach(child => {
+        })
+            .forEach(child => {
             child.parent = element;
             linkParents(child);
         });

package/node_modules/music-metadata/lib/ebml/types.d.ts

@@ -9,7 +9,7 @@ export declare const DataType: {
     readonly binary: 4;
     readonly float: 5;
 };
-export type DataType = typeof DataType[keyof typeof DataType];
+export type DataType = (typeof DataType)[keyof typeof DataType];
 export type ValueType = string | number | Uint8Array | boolean | ITree | ITree[];
 export interface IHeader {
     id: number;

package/node_modules/music-metadata/lib/ebml/types.js

@@ -4,5 +4,5 @@ export const DataType = {
     uid: 2,
     bool: 3,
     binary: 4,
-    float: 5,
+    float: 5
 };

package/node_modules/music-metadata/lib/flac/FlacParser.d.ts

@@ -1,5 +1,5 @@
-import { type IVorbisPicture } from '../ogg/vorbis/Vorbis.js';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+import { type IVorbisPicture } from '../ogg/vorbis/Vorbis.js';
 import type { IBlockStreamInfo } from './FlacToken.js';
 export declare class FlacParser extends AbstractID3Parser {
     private vorbisParser;

package/node_modules/music-metadata/lib/flac/FlacParser.js

@@ -1,10 +1,10 @@
 import initDebug from 'debug';
 import { Uint8ArrayType } from 'token-types';
-import { VorbisPictureToken } from '../ogg/vorbis/Vorbis.js';
-import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
 import { FourCcToken } from '../common/FourCC.js';
-import { VorbisStream } from '../ogg/vorbis/VorbisStream.js';
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+import { VorbisPictureToken } from '../ogg/vorbis/Vorbis.js';
 import { VorbisDecoder } from '../ogg/vorbis/VorbisDecoder.js';
+import { VorbisStream } from '../ogg/vorbis/VorbisStream.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
 import * as Flac from './FlacToken.js';
 const debug = initDebug('music-metadata:parser:FLAC');
@@ -29,7 +29,7 @@ export class FlacParser extends AbstractID3Parser {
         } while (!blockHeader.lastBlock);
         if (this.tokenizer.fileInfo.size && this.metadata.format.duration) {
             const dataSize = this.tokenizer.fileInfo.size - this.tokenizer.position;
-            this.metadata.setFormat('bitrate', 8 * dataSize / this.metadata.format.duration);
+            this.metadata.setFormat('bitrate', (8 * dataSize) / this.metadata.format.duration);
         }
     }
     async parseDataBlock(blockHeader) {
@@ -60,8 +60,9 @@ export class FlacParser extends AbstractID3Parser {
      * Parse STREAMINFO
      */
     async readBlockStreamInfo(dataLen) {
-        if (dataLen !== Flac.BlockStreamInfo.len)
+        if (dataLen !== Flac.BlockStreamInfo.len) {
             throw new FlacContentError('Unexpected block-stream-info length');
+        }
         const streamInfo = await this.tokenizer.readToken(Flac.BlockStreamInfo);
         this.metadata.setFormat('container', 'FLAC');
         this.processsStreamInfo(streamInfo);

package/node_modules/music-metadata/lib/flac/FlacToken.d.ts

@@ -12,7 +12,7 @@ export declare const BlockType: {
     CUESHEET: number;
     PICTURE: number;
 };
-export type BlockType = typeof BlockType[keyof typeof BlockType];
+export type BlockType = (typeof BlockType)[keyof typeof BlockType];
 /**
  * METADATA_BLOCK_DATA
  * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo

package/node_modules/music-metadata/lib/flac/FlacToken.js

@@ -1,5 +1,5 @@
-import * as util from '../common/Util.js';
 import { UINT16_BE, UINT24_BE, Uint8ArrayType } from 'token-types';
+import * as util from '../common/Util.js';
 /**
  * FLAC supports up to 128 kinds of metadata blocks; currently the following are defined:
  * ref: https://xiph.org/flac/format.html#metadata_block

package/node_modules/music-metadata/lib/id3v1/ID3v1Parser.d.ts

@@ -1,7 +1,7 @@
 import type { IRandomAccessTokenizer, ITokenizer } from 'strtok3';
 import { BasicParser } from '../common/BasicParser.js';
-import type { IPrivateOptions } from '../type.js';
 import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import type { IPrivateOptions } from '../type.js';
 /**
  * ID3v1 Genre mappings
  * Ref: https://de.wikipedia.org/wiki/Liste_der_ID3v1-Genres

package/node_modules/music-metadata/lib/id3v1/ID3v1Parser.js

@@ -1,43 +1,207 @@
+import { textDecode } from '@borewit/text-codec';
 import initDebug from 'debug';
 import { StringType, UINT8 } from 'token-types';
-import * as util from '../common/Util.js';
-import { BasicParser } from '../common/BasicParser.js';
 import { APEv2Parser } from '../apev2/APEv2Parser.js';
-import { textDecode } from '@borewit/text-codec';
+import { BasicParser } from '../common/BasicParser.js';
+import * as util from '../common/Util.js';
 const debug = initDebug('music-metadata:parser:ID3v1');
 /**
  * ID3v1 Genre mappings
  * Ref: https://de.wikipedia.org/wiki/Liste_der_ID3v1-Genres
  */
 export const Genres = [
-    'Blues', 'Classic Rock', 'Country', 'Dance', 'Disco', 'Funk', 'Grunge', 'Hip-Hop',
-    'Jazz', 'Metal', 'New Age', 'Oldies', 'Other', 'Pop', 'R&B', 'Rap', 'Reggae', 'Rock',
-    'Techno', 'Industrial', 'Alternative', 'Ska', 'Death Metal', 'Pranks', 'Soundtrack',
-    'Euro-Techno', 'Ambient', 'Trip-Hop', 'Vocal', 'Jazz+Funk', 'Fusion', 'Trance',
-    'Classical', 'Instrumental', 'Acid', 'House', 'Game', 'Sound Clip', 'Gospel', 'Noise',
-    'Alt. Rock', 'Bass', 'Soul', 'Punk', 'Space', 'Meditative', 'Instrumental Pop',
-    'Instrumental Rock', 'Ethnic', 'Gothic', 'Darkwave', 'Techno-Industrial',
-    'Electronic', 'Pop-Folk', 'Eurodance', 'Dream', 'Southern Rock', 'Comedy', 'Cult',
-    'Gangsta Rap', 'Top 40', 'Christian Rap', 'Pop/Funk', 'Jungle', 'Native American',
-    'Cabaret', 'New Wave', 'Psychedelic', 'Rave', 'Showtunes', 'Trailer', 'Lo-Fi', 'Tribal',
-    'Acid Punk', 'Acid Jazz', 'Polka', 'Retro', 'Musical', 'Rock & Roll', 'Hard Rock',
-    'Folk', 'Folk/Rock', 'National Folk', 'Swing', 'Fast-Fusion', 'Bebob', 'Latin', 'Revival',
-    'Celtic', 'Bluegrass', 'Avantgarde', 'Gothic Rock', 'Progressive Rock', 'Psychedelic Rock',
-    'Symphonic Rock', 'Slow Rock', 'Big Band', 'Chorus', 'Easy Listening', 'Acoustic', 'Humour',
-    'Speech', 'Chanson', 'Opera', 'Chamber Music', 'Sonata', 'Symphony', 'Booty Bass', 'Primus',
-    'Porn Groove', 'Satire', 'Slow Jam', 'Club', 'Tango', 'Samba', 'Folklore',
-    'Ballad', 'Power Ballad', 'Rhythmic Soul', 'Freestyle', 'Duet', 'Punk Rock', 'Drum Solo',
-    'A Cappella', 'Euro-House', 'Dance Hall', 'Goa', 'Drum & Bass', 'Club-House',
-    'Hardcore', 'Terror', 'Indie', 'BritPop', 'Negerpunk', 'Polsk Punk', 'Beat',
-    'Christian Gangsta Rap', 'Heavy Metal', 'Black Metal', 'Crossover', 'Contemporary Christian',
-    'Christian Rock', 'Merengue', 'Salsa', 'Thrash Metal', 'Anime', 'JPop', 'Synthpop',
-    'Abstract', 'Art Rock', 'Baroque', 'Bhangra', 'Big Beat', 'Breakbeat', 'Chillout',
-    'Downtempo', 'Dub', 'EBM', 'Eclectic', 'Electro', 'Electroclash', 'Emo', 'Experimental',
-    'Garage', 'Global', 'IDM', 'Illbient', 'Industro-Goth', 'Jam Band', 'Krautrock',
-    'Leftfield', 'Lounge', 'Math Rock', 'New Romantic', 'Nu-Breakz', 'Post-Punk', 'Post-Rock',
-    'Psytrance', 'Shoegaze', 'Space Rock', 'Trop Rock', 'World Music', 'Neoclassical', 'Audiobook',
-    'Audio Theatre', 'Neue Deutsche Welle', 'Podcast', 'Indie Rock', 'G-Funk', 'Dubstep',
-    'Garage Rock', 'Psybient'
+    'Blues',
+    'Classic Rock',
+    'Country',
+    'Dance',
+    'Disco',
+    'Funk',
+    'Grunge',
+    'Hip-Hop',
+    'Jazz',
+    'Metal',
+    'New Age',
+    'Oldies',
+    'Other',
+    'Pop',
+    'R&B',
+    'Rap',
+    'Reggae',
+    'Rock',
+    'Techno',
+    'Industrial',
+    'Alternative',
+    'Ska',
+    'Death Metal',
+    'Pranks',
+    'Soundtrack',
+    'Euro-Techno',
+    'Ambient',
+    'Trip-Hop',
+    'Vocal',
+    'Jazz+Funk',
+    'Fusion',
+    'Trance',
+    'Classical',
+    'Instrumental',
+    'Acid',
+    'House',
+    'Game',
+    'Sound Clip',
+    'Gospel',
+    'Noise',
+    'Alt. Rock',
+    'Bass',
+    'Soul',
+    'Punk',
+    'Space',
+    'Meditative',
+    'Instrumental Pop',
+    'Instrumental Rock',
+    'Ethnic',
+    'Gothic',
+    'Darkwave',
+    'Techno-Industrial',
+    'Electronic',
+    'Pop-Folk',
+    'Eurodance',
+    'Dream',
+    'Southern Rock',
+    'Comedy',
+    'Cult',
+    'Gangsta Rap',
+    'Top 40',
+    'Christian Rap',
+    'Pop/Funk',
+    'Jungle',
+    'Native American',
+    'Cabaret',
+    'New Wave',
+    'Psychedelic',
+    'Rave',
+    'Showtunes',
+    'Trailer',
+    'Lo-Fi',
+    'Tribal',
+    'Acid Punk',
+    'Acid Jazz',
+    'Polka',
+    'Retro',
+    'Musical',
+    'Rock & Roll',
+    'Hard Rock',
+    'Folk',
+    'Folk/Rock',
+    'National Folk',
+    'Swing',
+    'Fast-Fusion',
+    'Bebob',
+    'Latin',
+    'Revival',
+    'Celtic',
+    'Bluegrass',
+    'Avantgarde',
+    'Gothic Rock',
+    'Progressive Rock',
+    'Psychedelic Rock',
+    'Symphonic Rock',
+    'Slow Rock',
+    'Big Band',
+    'Chorus',
+    'Easy Listening',
+    'Acoustic',
+    'Humour',
+    'Speech',
+    'Chanson',
+    'Opera',
+    'Chamber Music',
+    'Sonata',
+    'Symphony',
+    'Booty Bass',
+    'Primus',
+    'Porn Groove',
+    'Satire',
+    'Slow Jam',
+    'Club',
+    'Tango',
+    'Samba',
+    'Folklore',
+    'Ballad',
+    'Power Ballad',
+    'Rhythmic Soul',
+    'Freestyle',
+    'Duet',
+    'Punk Rock',
+    'Drum Solo',
+    'A Cappella',
+    'Euro-House',
+    'Dance Hall',
+    'Goa',
+    'Drum & Bass',
+    'Club-House',
+    'Hardcore',
+    'Terror',
+    'Indie',
+    'BritPop',
+    'Negerpunk',
+    'Polsk Punk',
+    'Beat',
+    'Christian Gangsta Rap',
+    'Heavy Metal',
+    'Black Metal',
+    'Crossover',
+    'Contemporary Christian',
+    'Christian Rock',
+    'Merengue',
+    'Salsa',
+    'Thrash Metal',
+    'Anime',
+    'JPop',
+    'Synthpop',
+    'Abstract',
+    'Art Rock',
+    'Baroque',
+    'Bhangra',
+    'Big Beat',
+    'Breakbeat',
+    'Chillout',
+    'Downtempo',
+    'Dub',
+    'EBM',
+    'Eclectic',
+    'Electro',
+    'Electroclash',
+    'Emo',
+    'Experimental',
+    'Garage',
+    'Global',
+    'IDM',
+    'Illbient',
+    'Industro-Goth',
+    'Jam Band',
+    'Krautrock',
+    'Leftfield',
+    'Lounge',
+    'Math Rock',
+    'New Romantic',
+    'Nu-Breakz',
+    'Post-Punk',
+    'Post-Rock',
+    'Psytrance',
+    'Shoegaze',
+    'Space Rock',
+    'Trop Rock',
+    'World Music',
+    'Neoclassical',
+    'Audiobook',
+    'Audio Theatre',
+    'Neue Deutsche Welle',
+    'Podcast',
+    'Indie Rock',
+    'G-Funk',
+    'Dubstep',
+    'Garage Rock',
+    'Psybient'
 ];
 /**
  * Spec: http://id3.org/ID3v1
@@ -46,25 +210,29 @@ export const Genres = [
 const Iid3v1Token = {
     len: 128,
     /**
-     * @param buf Buffer possibly holding the 128 bytes ID3v1.1 metadata header
+     * @param buf Buffer possibly holding the 128-byte ID3v1/1.1 metadata header
      * @param off Offset in buffer in bytes
-     * @returns ID3v1.1 header if first 3 bytes equals 'TAG', otherwise null is returned
+     * @returns ID3v1/1.1 header if the first 3 bytes equal 'TAG', otherwise null is returned
      */
     get: (buf, off) => {
         const header = new Id3v1StringType(3).get(buf, off);
-        return header === 'TAG' ? {
+        if (header !== 'TAG') {
+            return null;
+        }
+        const zeroByte = UINT8.get(buf, off + 125);
+        const track = UINT8.get(buf, off + 126);
+        // ID3v1.1 replaces the final two comment bytes with a zero separator and a nonzero track number.
+        const hasTrack = zeroByte === 0 && track !== 0;
+        return {
             header,
             title: new Id3v1StringType(30).get(buf, off + 3),
             artist: new Id3v1StringType(30).get(buf, off + 33),
             album: new Id3v1StringType(30).get(buf, off + 63),
             year: new Id3v1StringType(4).get(buf, off + 93),
-            comment: new Id3v1StringType(28).get(buf, off + 97),
-            // ID3v1.1 separator for track
-            zeroByte: UINT8.get(buf, off + 127),
-            // track: ID3v1.1 field added by Michael Mutschler
-            track: UINT8.get(buf, off + 126),
+            comment: new Id3v1StringType(hasTrack ? 28 : 30).get(buf, off + 97),
+            track: hasTrack ? track : undefined,
             genre: UINT8.get(buf, off + 127)
-        } : null;
+        };
     }
 };
 class Id3v1StringType {
@@ -110,12 +278,14 @@ export class ID3v1Parser extends BasicParser {
             debug('ID3v1 header found at: pos=%s', this.tokenizer.fileInfo.size - Iid3v1Token.len);
             const props = ['title', 'artist', 'album', 'comment', 'track', 'year'];
             for (const id of props) {
-                if (header[id] && header[id] !== '')
+                if (header[id] && header[id] !== '') {
                     await this.addTag(id, header[id]);
+                }
             }
             const genre = ID3v1Parser.getGenre(header.genre);
-            if (genre)
+            if (genre) {
                 await this.addTag('genre', genre);
+            }
         }
         else {
             debug('ID3v1 header not found at: pos=%s', this.tokenizer.fileInfo.size - Iid3v1Token.len);