music-metadata 11.10.3 → 11.10.5

package/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright © 2025 Borewit
+Copyright © 2026 Borewit
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

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.3",
+  "version": "11.10.5",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"
@@ -106,27 +106,27 @@
     "update-biome": "yarn add -D --exact @biomejs/biome && npx @biomejs/biome migrate --write"
   },
   "dependencies": {
-    "@borewit/text-codec": "^0.2.0",
+    "@borewit/text-codec": "^0.2.1",
     "@tokenizer/token": "^0.3.0",
     "content-type": "^1.0.5",
     "debug": "^4.4.3",
-    "file-type": "^21.1.1",
+    "file-type": "^21.2.0",
     "media-typer": "^1.1.0",
     "strtok3": "^10.3.4",
-    "token-types": "^6.1.1",
+    "token-types": "^6.1.2",
     "uint8array-extras": "^1.5.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.7",
-    "@types/chai": "^5.2.2",
+    "@biomejs/biome": "2.3.10",
+    "@types/chai": "^5.2.3",
     "@types/chai-as-promised": "^8.0.2",
     "@types/content-type": "^1.1.9",
     "@types/debug": "^4.1.12",
     "@types/media-typer": "^1.1.3",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^24.5.0",
+    "@types/node": "^25.0.3",
     "c8": "^10.1.3",
-    "chai": "^6.2.1",
+    "chai": "^6.2.2",
     "chai-as-promised": "^8.0.2",
     "del-cli": "^7.0.0",
     "mime": "^4.1.0",