music-metadata 11.10.4 → 11.10.5

package/lib/apev2/APEv2Parser.js

@@ -113,7 +113,7 @@ export class APEv2Parser extends BasicParser {
             const tagItemHeader = await this.tokenizer.readToken(TagItemHeader);
             bytesRemaining -= TagItemHeader.len + tagItemHeader.size;
             await this.tokenizer.peekBuffer(keyBuffer, { length: Math.min(keyBuffer.length, bytesRemaining) });
-            let zero = util.findZero(keyBuffer, 0, keyBuffer.length);
+            let zero = util.findZero(keyBuffer);
             const key = await this.tokenizer.readToken(new StringType(zero, 'ascii'));
             await this.tokenizer.ignore(1);
             bytesRemaining -= key.length + 1;
@@ -131,7 +131,7 @@ export class APEv2Parser extends BasicParser {
                     else {
                         const picData = new Uint8Array(tagItemHeader.size);
                         await this.tokenizer.readBuffer(picData);
-                        zero = util.findZero(picData, 0, picData.length);
+                        zero = util.findZero(picData);
                         const description = textDecode(picData.subarray(0, zero), 'utf-8');
                         const data = picData.subarray(zero + 1);
                         await this.metadata.addTag(tagFormat, key, {

package/lib/common/Util.d.ts

@@ -2,14 +2,12 @@ import type { IRatio } from '../type.js';
 export type StringEncoding = 'ascii' | 'utf8' | 'utf-16le' | 'ucs2' | 'base64url' | 'latin1' | 'hex';
 export declare function getBit(buf: Uint8Array, off: number, bit: number): boolean;
 /**
- * Found delimiting zero in uint8Array
+ * Find delimiting zero in uint8Array
  * @param uint8Array Uint8Array to find the zero delimiter in
- * @param start Offset in uint8Array
- * @param end Last position to parse in uint8Array
  * @param encoding The string encoding used
- * @return Absolute position on uint8Array where zero found
+ * @return position in uint8Array where zero found, or uint8Array.length if not found
  */
-export declare function findZero(uint8Array: Uint8Array, start: number, end: number, encoding?: StringEncoding): number;
+export declare function findZero(uint8Array: Uint8Array, encoding?: StringEncoding): number;
 export declare function trimRightNull(x: string): string;
 /**
  * Decode string

package/lib/common/Util.js

@@ -5,33 +5,31 @@ export function getBit(buf, off, bit) {
     return (buf[off] & (1 << bit)) !== 0;
 }
 /**
- * Found delimiting zero in uint8Array
+ * Find delimiting zero in uint8Array
  * @param uint8Array Uint8Array to find the zero delimiter in
- * @param start Offset in uint8Array
- * @param end Last position to parse in uint8Array
  * @param encoding The string encoding used
- * @return Absolute position on uint8Array where zero found
+ * @return position in uint8Array where zero found, or uint8Array.length if not found
  */
-export function findZero(uint8Array, start, end, encoding) {
-    let i = start;
+export function findZero(uint8Array, encoding) {
+    const len = uint8Array.length;
     if (encoding === 'utf-16le') {
-        while (uint8Array[i] !== 0 || uint8Array[i + 1] !== 0) {
-            if (i >= end)
-                return end;
-            i += 2;
+        // Look for 0x00 0x00 on 2-byte boundary
+        for (let i = 0; i + 1 < len; i += 2) {
+            if (uint8Array[i] === 0 && uint8Array[i + 1] === 0)
+                return i;
         }
-        return i;
+        return len;
     }
-    while (uint8Array[i] !== 0) {
-        if (i >= end)
-            return end;
-        i++;
+    // latin1 / utf8 / utf16be (caller typically handles utf16be separately or via decode)
+    for (let i = 0; i < len; i++) {
+        if (uint8Array[i] === 0)
+            return i;
     }
-    return i;
+    return len;
 }
 export function trimRightNull(x) {
     const pos0 = x.indexOf('\0');
-    return pos0 === -1 ? x : x.substr(0, pos0);
+    return pos0 === -1 ? x : x.substring(0, pos0);
 }
 function swapBytes(uint8Array) {
     const l = uint8Array.length;

package/lib/id3v2/FrameHeader.d.ts

@@ -0,0 +1,31 @@
+import { type ID3v2MajorVersion } from './ID3v2Token.js';
+import type { IWarningCollector } from '../common/MetadataCollector.js';
+export interface IFrameFlags {
+    status: {
+        tag_alter_preservation: boolean;
+        file_alter_preservation: boolean;
+        read_only: boolean;
+    };
+    format: {
+        grouping_identity: boolean;
+        compression: boolean;
+        encryption: boolean;
+        unsynchronisation: boolean;
+        data_length_indicator: boolean;
+    };
+}
+export interface IFrameHeader {
+    id: string;
+    length: number;
+    flags?: IFrameFlags;
+}
+/**
+ * Frame header length (bytes) depending on ID3v2 major version.
+ */
+export declare function getFrameHeaderLength(majorVer: number): 6 | 10;
+/**
+ * Factory: parse a frame header from its header bytes (6 for v2.2, 10 for v2.3/v2.4).
+ *
+ * Note: It only *parses* and does light validation. It does not read payload bytes.
+ */
+export declare function readFrameHeader(uint8Array: Uint8Array, majorVer: ID3v2MajorVersion, warningCollector: IWarningCollector): IFrameHeader;

package/lib/id3v2/FrameHeader.js

@@ -0,0 +1,73 @@
+// lib/id3v2/FrameHeader.ts
+import * as Token from 'token-types';
+import * as util from '../common/Util.js';
+import { UINT32SYNCSAFE } from './ID3v2Token.js';
+import { textDecode } from '@borewit/text-codec';
+import { Id3v2ContentError } from './FrameParser.js';
+/**
+ * Frame header length (bytes) depending on ID3v2 major version.
+ */
+export function getFrameHeaderLength(majorVer) {
+    switch (majorVer) {
+        case 2: return 6;
+        case 3:
+        case 4: return 10;
+        default: throw makeUnexpectedMajorVersionError(majorVer);
+    }
+}
+function readFrameFlags(b) {
+    return {
+        status: {
+            tag_alter_preservation: util.getBit(b, 0, 6),
+            file_alter_preservation: util.getBit(b, 0, 5),
+            read_only: util.getBit(b, 0, 4)
+        },
+        format: {
+            grouping_identity: util.getBit(b, 1, 7),
+            compression: util.getBit(b, 1, 3),
+            encryption: util.getBit(b, 1, 2),
+            unsynchronisation: util.getBit(b, 1, 1),
+            data_length_indicator: util.getBit(b, 1, 0)
+        }
+    };
+}
+/**
+ * Factory: parse a frame header from its header bytes (6 for v2.2, 10 for v2.3/v2.4).
+ *
+ * Note: It only *parses* and does light validation. It does not read payload bytes.
+ */
+export function readFrameHeader(uint8Array, majorVer, warningCollector) {
+    switch (majorVer) {
+        case 2:
+            return parseFrameHeaderV22(uint8Array, majorVer, warningCollector);
+        case 3:
+        case 4:
+            return parseFrameHeaderV23V24(uint8Array, majorVer, warningCollector);
+        default:
+            throw makeUnexpectedMajorVersionError(majorVer);
+    }
+}
+function parseFrameHeaderV22(uint8Array, majorVer, warningCollector) {
+    const header = {
+        id: textDecode(uint8Array.subarray(0, 3), 'ascii'),
+        length: Token.UINT24_BE.get(uint8Array, 3)
+    };
+    if (!header.id.match(/^[A-Z0-9]{3}$/)) {
+        warningCollector.addWarning(`Invalid ID3v2.${majorVer} frame-header-ID: ${header.id}`);
+    }
+    return header;
+}
+function parseFrameHeaderV23V24(uint8Array, majorVer, warningCollector) {
+    const header = {
+        id: textDecode(uint8Array.subarray(0, 4), 'ascii'),
+        length: (majorVer === 4 ? UINT32SYNCSAFE : Token.UINT32_BE).get(uint8Array, 4),
+        flags: readFrameFlags(uint8Array.subarray(8, 10))
+    };
+    if (!header.id.match(/^[A-Z0-9]{4}$/)) {
+        warningCollector.addWarning(`Invalid ID3v2.${majorVer} frame-header-ID: ${header.id}`);
+    }
+    return header;
+}
+function makeUnexpectedMajorVersionError(majorVer) {
+    throw new Id3v2ContentError(`Unexpected majorVer: ${majorVer}`);
+}

package/lib/id3v2/FrameParser.d.ts

@@ -54,6 +54,7 @@ export declare class FrameParser {
      */
     private splitValue;
     private static trimArray;
+    private static trimNullPadding;
     private static readIdentifierAndData;
     private static getNullTerminatorLength;
 }

package/lib/id3v2/FrameParser.js

@@ -7,6 +7,7 @@ import { makeUnexpectedFileContentError } from '../ParseError.js';
 import { decodeUintBE } from '../common/Util.js';
 const debug = initDebug('music-metadata:id3v2:frame-parser');
 const defaultEnc = 'latin1'; // latin1 == iso-8859-1;
+const urlEnc = { encoding: defaultEnc, bom: false };
 export function parseGenre(origVal) {
     // match everything inside parentheses
     const genres = [];
@@ -90,7 +91,7 @@ export class FrameParser {
             case 'PCST': {
                 let text;
                 try {
-                    text = util.decodeString(uint8Array.subarray(1), encoding).replace(/\x00+$/, '');
+                    text = FrameParser.trimNullPadding(util.decodeString(uint8Array.subarray(1), encoding));
                 }
                 catch (error) {
                     if (error instanceof Error) {
@@ -135,7 +136,7 @@ export class FrameParser {
                 break;
             }
             case 'TXXX': {
-                const idAndData = FrameParser.readIdentifierAndData(uint8Array, offset + 1, length, encoding);
+                const idAndData = FrameParser.readIdentifierAndData(uint8Array.subarray(1), encoding);
                 const textTag = {
                     description: idAndData.id,
                     text: this.splitValue(type, util.decodeString(idAndData.data, encoding).replace(/\x00+$/, ''))
@@ -147,28 +148,28 @@ export class FrameParser {
             case 'APIC':
                 if (includeCovers) {
                     const pic = {};
-                    offset += 1;
+                    uint8Array = uint8Array.subarray(1);
                     switch (this.major) {
                         case 2:
-                            pic.format = util.decodeString(uint8Array.subarray(offset, offset + 3), 'latin1'); // 'latin1'; // latin1 == iso-8859-1;
-                            offset += 3;
+                            pic.format = util.decodeString(uint8Array.subarray(0, 3), 'latin1'); // 'latin1'; // latin1 == iso-8859-1;
+                            uint8Array = uint8Array.subarray(3);
                             break;
                         case 3:
                         case 4:
-                            fzero = util.findZero(uint8Array, offset, length, defaultEnc);
-                            pic.format = util.decodeString(uint8Array.subarray(offset, fzero), defaultEnc);
-                            offset = fzero + 1;
+                            fzero = util.findZero(uint8Array, defaultEnc);
+                            pic.format = util.decodeString(uint8Array.subarray(0, fzero), defaultEnc);
+                            uint8Array = uint8Array.subarray(fzero + 1);
                             break;
                         default:
                             throw makeUnexpectedMajorVersionError(this.major);
                     }
                     pic.format = FrameParser.fixPictureMimeType(pic.format);
-                    pic.type = AttachedPictureType[uint8Array[offset]];
-                    offset += 1;
-                    fzero = util.findZero(uint8Array, offset, length, encoding);
-                    pic.description = util.decodeString(uint8Array.subarray(offset, fzero), encoding);
-                    offset = fzero + nullTerminatorLength;
-                    pic.data = uint8Array.subarray(offset, length);
+                    pic.type = AttachedPictureType[uint8Array[0]];
+                    uint8Array = uint8Array.subarray(1);
+                    fzero = util.findZero(uint8Array, encoding);
+                    pic.description = util.decodeString(uint8Array.subarray(0, fzero), encoding);
+                    uint8Array = uint8Array.subarray(fzero + nullTerminatorLength);
+                    pic.data = uint8Array;
                     output = pic;
                 }
                 break;
@@ -178,7 +179,7 @@ export class FrameParser {
                 break;
             case 'SYLT': {
                 const syltHeader = SyncTextHeader.get(uint8Array, 0);
-                offset += SyncTextHeader.len;
+                uint8Array = uint8Array.subarray(SyncTextHeader.len);
                 const result = {
                     descriptor: '',
                     language: syltHeader.language,
@@ -187,12 +188,12 @@ export class FrameParser {
                     syncText: []
                 };
                 let readSyllables = false;
-                while (offset < length) {
-                    const nullStr = FrameParser.readNullTerminatedString(uint8Array.subarray(offset), syltHeader.encoding);
-                    offset += nullStr.len;
+                while (uint8Array.length > 0) {
+                    const nullStr = FrameParser.readNullTerminatedString(uint8Array, syltHeader.encoding);
+                    uint8Array = uint8Array.subarray(nullStr.len);
                     if (readSyllables) {
-                        const timestamp = Token.UINT32_BE.get(uint8Array, offset);
-                        offset += Token.UINT32_BE.len;
+                        const timestamp = Token.UINT32_BE.get(uint8Array, 0);
+                        uint8Array = uint8Array.subarray(Token.UINT32_BE.len);
                         result.syncText.push({
                             text: nullStr.text,
                             timestamp
@@ -224,42 +225,52 @@ export class FrameParser {
                 break;
             }
             case 'UFID': {
-                const ufid = FrameParser.readIdentifierAndData(uint8Array, offset, length, defaultEnc);
+                const ufid = FrameParser.readIdentifierAndData(uint8Array, defaultEnc);
                 output = { owner_identifier: ufid.id, identifier: ufid.data };
                 break;
             }
             case 'PRIV': { // private frame
-                const priv = FrameParser.readIdentifierAndData(uint8Array, offset, length, defaultEnc);
+                const priv = FrameParser.readIdentifierAndData(uint8Array, defaultEnc);
                 output = { owner_identifier: priv.id, data: priv.data };
                 break;
             }
             case 'POPM': { // Popularimeter
-                fzero = util.findZero(uint8Array, offset, length, defaultEnc);
-                const email = util.decodeString(uint8Array.subarray(offset, fzero), defaultEnc);
-                offset = fzero + 1;
-                const valueLen = length - offset - 1;
+                uint8Array = uint8Array.subarray(offset);
+                const emailStr = FrameParser.readNullTerminatedString(uint8Array, urlEnc);
+                const email = emailStr.text;
+                uint8Array = uint8Array.subarray(emailStr.len);
+                if (uint8Array.length === 0) {
+                    this.warningCollector.addWarning(`id3v2.${this.major} type=${type} POPM frame missing rating byte`);
+                    output = { email, rating: 0, counter: undefined };
+                    break;
+                }
+                const rating = Token.UINT8.get(uint8Array, 0);
+                const counterBytes = uint8Array.subarray(Token.UINT8.len);
                 output = {
                     email,
-                    rating: Token.UINT8.get(uint8Array, offset),
-                    counter: valueLen > 0 ? util.decodeUintBE(uint8Array.subarray(offset + 1)) : undefined
+                    rating,
+                    counter: counterBytes.length > 0 ? decodeUintBE(counterBytes) : undefined
                 };
                 break;
             }
             case 'GEOB': { // General encapsulated object
-                fzero = util.findZero(uint8Array, offset + 1, length, encoding);
-                const mimeType = util.decodeString(uint8Array.subarray(offset + 1, fzero), defaultEnc);
-                offset = fzero + 1;
-                fzero = util.findZero(uint8Array, offset, length, encoding);
-                const filename = util.decodeString(uint8Array.subarray(offset, fzero), defaultEnc);
-                offset = fzero + 1;
-                fzero = util.findZero(uint8Array, offset, length, encoding);
-                const description = util.decodeString(uint8Array.subarray(offset, fzero), defaultEnc);
-                offset = fzero + 1;
+                // [encoding] <MIME> 0x00 <filename> 0x00/0x00 0x00 <description> 0x00/0x00 0x00 <data>
+                const { encoding: geobEncoding, bom: geobBom } = TextEncodingToken.get(uint8Array, 0);
+                uint8Array = uint8Array.subarray(1);
+                const mimeTypeStr = FrameParser.readNullTerminatedString(uint8Array, urlEnc);
+                const mimeType = mimeTypeStr.text;
+                uint8Array = uint8Array.subarray(mimeTypeStr.len);
+                const filenameStr = FrameParser.readNullTerminatedString(uint8Array, { encoding: geobEncoding, bom: geobBom });
+                const filename = filenameStr.text;
+                uint8Array = uint8Array.subarray(filenameStr.len);
+                const descriptionStr = FrameParser.readNullTerminatedString(uint8Array, { encoding: geobEncoding, bom: geobBom });
+                const description = descriptionStr.text;
+                uint8Array = uint8Array.subarray(descriptionStr.len);
                 const geob = {
                     type: mimeType,
                     filename,
                     description,
-                    data: uint8Array.subarray(offset, length)
+                    data: uint8Array
                 };
                 output = geob;
                 break;
@@ -274,21 +285,26 @@ export class FrameParser {
             case 'WPAY':
             case 'WPUB':
                 // Decode URL
-                fzero = util.findZero(uint8Array, offset + 1, length, encoding);
-                output = util.decodeString(uint8Array.subarray(offset, fzero), defaultEnc);
+                output = FrameParser.readNullTerminatedString(uint8Array, urlEnc).text;
                 break;
             case 'WXXX': {
-                // Decode URL
-                fzero = util.findZero(uint8Array, offset + 1, length, encoding);
-                const description = util.decodeString(uint8Array.subarray(offset + 1, fzero), encoding);
-                offset = fzero + (encoding === 'utf-16le' ? 2 : 1);
-                output = { description, url: util.decodeString(uint8Array.subarray(offset, length), defaultEnc) };
+                // [encoding] <description> 0x00/0x00 0x00 <url>
+                const { encoding: wxxxEncoding, bom: wxxxBom } = TextEncodingToken.get(uint8Array, 0);
+                uint8Array = uint8Array.subarray(1);
+                const descriptionStr = FrameParser.readNullTerminatedString(uint8Array, { encoding: wxxxEncoding, bom: wxxxBom });
+                const description = descriptionStr.text;
+                uint8Array = uint8Array.subarray(descriptionStr.len);
+                // URL is always ISO-8859-1
+                output = { description, url: FrameParser.trimNullPadding(util.decodeString(uint8Array, defaultEnc)) };
                 break;
             }
             case 'WFD':
-            case 'WFED':
-                output = util.decodeString(uint8Array.subarray(offset + 1, util.findZero(uint8Array, offset + 1, length, encoding)), encoding);
+            case 'WFED': {
+                const { encoding: wfdEncoding, bom: wfdBom } = TextEncodingToken.get(uint8Array, 0);
+                uint8Array = uint8Array.subarray(1);
+                output = FrameParser.readNullTerminatedString(uint8Array, { encoding: wfdEncoding, bom: wfdBom }).text;
                 break;
+            }
             case 'MCDI': {
                 // Music CD identifier
                 output = uint8Array.subarray(0, length);
@@ -301,18 +317,21 @@ export class FrameParser {
         return output;
     }
     static readNullTerminatedString(uint8Array, encoding) {
-        let offset = encoding.bom ? 2 : 0;
-        const zeroIndex = util.findZero(uint8Array, offset, uint8Array.length, encoding.encoding);
-        const txt = uint8Array.subarray(offset, zeroIndex);
-        if (encoding.encoding === 'utf-16le') {
-            offset = zeroIndex + 2;
-        }
-        else {
-            offset = zeroIndex + 1;
+        const bomSize = encoding.bom ? 2 : 0;
+        const originalLen = uint8Array.length;
+        const valueArray = uint8Array.subarray(bomSize);
+        const zeroIndex = util.findZero(valueArray, encoding.encoding);
+        if (zeroIndex >= valueArray.length) {
+            // No terminator found, decode full buffer remainder
+            return {
+                text: util.decodeString(valueArray, encoding.encoding),
+                len: originalLen
+            };
         }
+        const txt = valueArray.subarray(0, zeroIndex);
         return {
             text: util.decodeString(txt, encoding.encoding),
-            len: offset
+            len: bomSize + zeroIndex + FrameParser.getNullTerminatorLength(encoding.encoding)
         };
     }
     static fixPictureMimeType(pictureType) {
@@ -361,16 +380,21 @@ export class FrameParser {
         return FrameParser.trimArray(values);
     }
     static trimArray(values) {
-        return values.map(value => value.replace(/\x00+$/, '').trim());
+        return values.map(value => FrameParser.trimNullPadding(value).trim());
+    }
+    static trimNullPadding(value) {
+        let end = value.length;
+        while (end > 0 && value.charCodeAt(end - 1) === 0) {
+            end--;
+        }
+        return end === value.length ? value : value.slice(0, end);
     }
-    static readIdentifierAndData(uint8Array, offset, length, encoding) {
-        const fzero = util.findZero(uint8Array, offset, length, encoding);
-        const id = util.decodeString(uint8Array.subarray(offset, fzero), encoding);
-        offset = fzero + FrameParser.getNullTerminatorLength(encoding);
-        return { id, data: uint8Array.subarray(offset, length) };
+    static readIdentifierAndData(uint8Array, encoding) {
+        const idStr = FrameParser.readNullTerminatedString(uint8Array, { encoding, bom: false });
+        return { id: idStr.text, data: uint8Array.subarray(idStr.len) };
     }
     static getNullTerminatorLength(enc) {
-        return enc === 'utf-16le' ? 2 : 1;
+        return enc.startsWith('utf-16') ? 2 : 1;
     }
 }
 export class Id3v2ContentError extends makeUnexpectedFileContentError('id3v2') {

package/lib/id3v2/ID3v2Parser.d.ts

@@ -3,8 +3,6 @@ import type { IOptions } from '../type.js';
 import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
 export declare class ID3v2Parser {
     static removeUnsyncBytes(buffer: Uint8Array): Uint8Array;
-    private static getFrameHeaderLength;
-    private static readFrameFlags;
     private static readFrameData;
     /**
      * Create a combined tag key, of tag & description
@@ -25,5 +23,4 @@ export declare class ID3v2Parser {
     private handleTag;
     private addTag;
     private parseMetadata;
-    private readFrameHeader;
 }

package/lib/id3v2/ID3v2Parser.js

@@ -1,8 +1,7 @@
 import * as Token from 'token-types';
-import * as util from '../common/Util.js';
 import { FrameParser, Id3v2ContentError } from './FrameParser.js';
-import { ExtendedHeader, ID3v2Header, UINT32SYNCSAFE } from './ID3v2Token.js';
-import { textDecode } from '@borewit/text-codec';
+import { ExtendedHeader, ID3v2Header } from './ID3v2Token.js';
+import { getFrameHeaderLength, readFrameHeader } from './FrameHeader.js';
 export class ID3v2Parser {
     constructor() {
         this.tokenizer = undefined;
@@ -26,33 +25,6 @@ export class ID3v2Parser {
         }
         return buffer.subarray(0, writeI);
     }
-    static getFrameHeaderLength(majorVer) {
-        switch (majorVer) {
-            case 2:
-                return 6;
-            case 3:
-            case 4:
-                return 10;
-            default:
-                throw makeUnexpectedMajorVersionError(majorVer);
-        }
-    }
-    static readFrameFlags(b) {
-        return {
-            status: {
-                tag_alter_preservation: util.getBit(b, 0, 6),
-                file_alter_preservation: util.getBit(b, 0, 5),
-                read_only: util.getBit(b, 0, 4)
-            },
-            format: {
-                grouping_identity: util.getBit(b, 1, 7),
-                compression: util.getBit(b, 1, 3),
-                encryption: util.getBit(b, 1, 2),
-                unsynchronisation: util.getBit(b, 1, 1),
-                data_length_indicator: util.getBit(b, 1, 0)
-            }
-        };
-    }
     static readFrameData(uint8Array, frameHeader, majorVer, includeCovers, warningCollector) {
         const frameParser = new FrameParser(majorVer, warningCollector);
         switch (majorVer) {
@@ -127,14 +99,14 @@ export class ID3v2Parser {
         while (true) {
             if (offset === data.length)
                 break;
-            const frameHeaderLength = ID3v2Parser.getFrameHeaderLength(this.id3Header.version.major);
+            const frameHeaderLength = getFrameHeaderLength(this.id3Header.version.major);
             if (offset + frameHeaderLength > data.length) {
                 this.metadata.addWarning('Illegal ID3v2 tag length');
                 break;
             }
             const frameHeaderBytes = data.subarray(offset, offset + frameHeaderLength);
             offset += frameHeaderLength;
-            const frameHeader = this.readFrameHeader(frameHeaderBytes, this.id3Header.version.major);
+            const frameHeader = readFrameHeader(frameHeaderBytes, this.id3Header.version.major, this.metadata);
             const frameDataBytes = data.subarray(offset, offset + frameHeader.length);
             offset += frameHeader.length;
             const values = ID3v2Parser.readFrameData(frameDataBytes, frameHeader, this.id3Header.version.major, !this.options.skipCovers, this.metadata);
@@ -144,34 +116,6 @@ export class ID3v2Parser {
         }
         return tags;
     }
-    readFrameHeader(uint8Array, majorVer) {
-        let header;
-        switch (majorVer) {
-            case 2:
-                header = {
-                    id: textDecode(uint8Array.subarray(0, 3), 'ascii'),
-                    length: Token.UINT24_BE.get(uint8Array, 3)
-                };
-                if (!header.id.match(/[A-Z0-9]{3}/g)) {
-                    this.metadata.addWarning(`Invalid ID3v2.${this.id3Header.version.major} frame-header-ID: ${header.id}`);
-                }
-                break;
-            case 3:
-            case 4:
-                header = {
-                    id: textDecode(uint8Array.subarray(0, 4), 'ascii'),
-                    length: (majorVer === 4 ? UINT32SYNCSAFE : Token.UINT32_BE).get(uint8Array, 4),
-                    flags: ID3v2Parser.readFrameFlags(uint8Array.subarray(8, 10))
-                };
-                if (!header.id.match(/[A-Z0-9]{4}/g)) {
-                    this.metadata.addWarning(`Invalid ID3v2.${this.id3Header.version.major} frame-header-ID: ${header.id}`);
-                }
-                break;
-            default:
-                throw makeUnexpectedMajorVersionError(majorVer);
-        }
-        return header;
-    }
 }
 function makeUnexpectedMajorVersionError(majorVer) {
     throw new Id3v2ContentError(`Unexpected majorVer: ${majorVer}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "music-metadata",
   "description": "Music metadata parser for Node.js, supporting virtual any audio and tag format.",
-  "version": "11.10.4",
+  "version": "11.10.5",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"