music-metadata 11.10.4 → 11.10.6

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 = 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);
+                const filename = filenameStr.text;
+                uint8Array = uint8Array.subarray(filenameStr.len);
+                const descriptionStr = FrameParser.readNullTerminatedString(uint8Array, encoding);
+                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 = TextEncodingToken.get(uint8Array, 0);
+                uint8Array = uint8Array.subarray(1);
+                const descriptionStr = FrameParser.readNullTerminatedString(uint8Array, encoding);
+                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 = TextEncodingToken.get(uint8Array, 0);
+                uint8Array = uint8Array.subarray(1);
+                output = FrameParser.readNullTerminatedString(uint8Array, encoding).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/lib/mpeg/MpegParser.d.ts

@@ -16,13 +16,11 @@ export declare class MpegContentError extends MpegContentError_base {
 export declare class MpegParser extends AbstractID3Parser {
     private frameCount;
     private syncFrameCount;
-    private countSkipFrameData;
     private totalDataLength;
     private audioFrameHeader?;
     private bitrates;
     private offset;
     private frame_size;
-    private crc;
     private calculateEofDuration;
     private samplesPerFrame;
     private buf_frame_header;

package/lib/mpeg/MpegParser.js

@@ -233,12 +233,10 @@ export class MpegParser extends AbstractID3Parser {
         super(...arguments);
         this.frameCount = 0;
         this.syncFrameCount = -1;
-        this.countSkipFrameData = 0;
         this.totalDataLength = 0;
         this.bitrates = [];
         this.offset = 0;
         this.frame_size = 0;
-        this.crc = null;
         this.calculateEofDuration = false;
         this.samplesPerFrame = null;
         this.buf_frame_header = new Uint8Array(4);
@@ -467,8 +465,8 @@ export class MpegParser extends AbstractID3Parser {
         return false;
     }
     async parseCrc() {
-        this.crc = await this.tokenizer.readNumber(Token.INT16_BE);
-        this.offset += 2;
+        await this.tokenizer.ignore(Token.INT16_BE.len); // Ignore CRC
+        this.offset += Token.INT16_BE.len;
         return this.skipSideInformation();
     }
     async skipSideInformation() {
@@ -561,7 +559,6 @@ export class MpegParser extends AbstractID3Parser {
         if (frameDataLeft < 0)
             throw new MpegContentError('frame-data-left cannot be negative');
         await this.tokenizer.ignore(frameDataLeft);
-        this.countSkipFrameData += frameDataLeft;
     }
     areAllSame(array) {
         const first = array[0];

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

@@ -37,7 +37,7 @@ export declare class VorbisStream implements IPageConsumer {
     flush(): Promise<void>;
     parseUserComment(pageData: Uint8Array, offset: number): Promise<number>;
     addTag(id: string, value: string | IVorbisPicture): Promise<void>;
-    calculateDuration(enfOfStream: boolean): void;
+    calculateDuration(_enfOfStream: boolean): void;
     /**
      * Parse first Ogg/Vorbis page
      * @param _header

package/lib/ogg/vorbis/VorbisStream.js

@@ -77,7 +77,7 @@ export class VorbisStream {
         }
         await this.metadata.addTag('vorbis', id, value);
     }
-    calculateDuration(enfOfStream) {
+    calculateDuration(_enfOfStream) {
         if (this.lastPageHeader && this.metadata.format.sampleRate && this.lastPageHeader.absoluteGranulePosition >= 0) {
             // Calculate duration
             this.metadata.setFormat('numberOfSamples', this.lastPageHeader.absoluteGranulePosition);

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.6",
   "author": {
     "name": "Borewit",
     "url": "https://github.com/Borewit"
@@ -110,14 +110,15 @@
     "@tokenizer/token": "^0.3.0",
     "content-type": "^1.0.5",
     "debug": "^4.4.3",
-    "file-type": "^21.2.0",
+    "file-type": "^21.3.0",
     "media-typer": "^1.1.0",
     "strtok3": "^10.3.4",
     "token-types": "^6.1.2",
-    "uint8array-extras": "^1.5.0"
+    "uint8array-extras": "^1.5.0",
+    "win-guid": "^0.1.3"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.10",
+    "@biomejs/biome": "2.3.11",
     "@types/chai": "^5.2.3",
     "@types/chai-as-promised": "^8.0.2",
     "@types/content-type": "^1.1.9",

package/lib/asf/GUID.d.ts

@@ -1,83 +0,0 @@
-/**
- * Ref:
- * - https://tools.ietf.org/html/draft-fleischman-asf-01, Appendix A: ASF GUIDs
- * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
- * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/index.html
- * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
- *
- * ASF File Structure:
- * - https://msdn.microsoft.com/en-us/library/windows/desktop/ee663575(v=vs.85).aspx
- *
- * ASF GUIDs:
- * - http://drang.s4.xrea.com/program/tips/id3tag/wmp/10_asf_guids.html
- * - https://github.com/dji-sdk/FFmpeg/blob/master/libavformat/asf.c
- */
-export default class GUID {
-    static HeaderObject: GUID;
-    static DataObject: GUID;
-    static SimpleIndexObject: GUID;
-    static IndexObject: GUID;
-    static MediaObjectIndexObject: GUID;
-    static TimecodeIndexObject: GUID;
-    static FilePropertiesObject: GUID;
-    static StreamPropertiesObject: GUID;
-    static HeaderExtensionObject: GUID;
-    static CodecListObject: GUID;
-    static ScriptCommandObject: GUID;
-    static MarkerObject: GUID;
-    static BitrateMutualExclusionObject: GUID;
-    static ErrorCorrectionObject: GUID;
-    static ContentDescriptionObject: GUID;
-    static ExtendedContentDescriptionObject: GUID;
-    static ContentBrandingObject: GUID;
-    static StreamBitratePropertiesObject: GUID;
-    static ContentEncryptionObject: GUID;
-    static ExtendedContentEncryptionObject: GUID;
-    static DigitalSignatureObject: GUID;
-    static PaddingObject: GUID;
-    static ExtendedStreamPropertiesObject: GUID;
-    static AdvancedMutualExclusionObject: GUID;
-    static GroupMutualExclusionObject: GUID;
-    static StreamPrioritizationObject: GUID;
-    static BandwidthSharingObject: GUID;
-    static LanguageListObject: GUID;
-    static MetadataObject: GUID;
-    static MetadataLibraryObject: GUID;
-    static IndexParametersObject: GUID;
-    static MediaObjectIndexParametersObject: GUID;
-    static TimecodeIndexParametersObject: GUID;
-    static CompatibilityObject: GUID;
-    static AdvancedContentEncryptionObject: GUID;
-    static AudioMedia: GUID;
-    static VideoMedia: GUID;
-    static CommandMedia: GUID;
-    static JFIF_Media: GUID;
-    static Degradable_JPEG_Media: GUID;
-    static FileTransferMedia: GUID;
-    static BinaryMedia: GUID;
-    static ASF_Index_Placeholder_Object: GUID;
-    static fromBin(bin: Uint8Array, offset?: number): GUID;
-    /**
-     * Decode GUID in format like "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
-     * @param objectId Binary GUID
-     * @param offset Read offset in bytes, default 0
-     * @returns GUID as dashed hexadecimal representation
-     */
-    static decode(objectId: Uint8Array, offset?: number): string;
-    /**
-     * Decode stream type
-     * @param mediaType Media type GUID
-     * @returns Media type
-     */
-    static decodeMediaType(mediaType: GUID): 'audio' | 'video' | 'command' | 'degradable-jpeg' | 'file-transfer' | 'binary' | undefined;
-    /**
-     * Encode GUID
-     * @param guid GUID like: "B503BF5F-2EA9-CF11-8EE3-00C00C205365"
-     * @returns Encoded Binary GUID
-     */
-    static encode(str: string): Uint8Array;
-    str: string;
-    constructor(str: string);
-    equals(guid: GUID): boolean;
-    toBin(): Uint8Array;
-}