@openclaw/matrix 2026.10.2 → 2026.10.5-beta.2

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

@@ -75,7 +75,7 @@ export interface ICueReference {
 }
 export interface ISimpleTag {
     name?: string;
-    'string'?: string;
+    string?: string;
     binary?: Uint8Array;
     language?: string;
     default?: boolean;
@@ -98,7 +98,7 @@ export declare const TrackType: {
     button: number;
     control: number;
 };
-export type TrackType = typeof TrackType[keyof typeof TrackType];
+export type TrackType = (typeof TrackType)[keyof typeof TrackType];
 export type TrackTypeKey = keyof typeof TrackType;
 export declare const TrackTypeValueToKeyMap: Record<TrackType, TrackTypeKey>;
 export interface ITarget {

package/node_modules/music-metadata/lib/mp4/Atom.d.ts

@@ -1,16 +1,17 @@
-import * as AtomToken from './AtomToken.js';
 import type { ITokenizer } from 'strtok3';
+import * as AtomToken from './AtomToken.js';
 export type AtomDataHandler = (atom: Atom, remaining: number) => Promise<void>;
 export declare class Atom {
+    private readonly payloadLength;
     static readAtom(tokenizer: ITokenizer, dataHandler: AtomDataHandler, parent: Atom | null, remaining: number): Promise<Atom>;
     readonly children: Atom[];
     readonly atomPath: string;
     readonly header: AtomToken.IAtomHeader;
     extended: boolean;
     readonly parent: Atom | null;
-    constructor(header: AtomToken.IAtomHeader, extended: boolean, parent: Atom | null);
+    constructor(header: AtomToken.IAtomHeader, extended: boolean, parent: Atom | null, payloadLength: number);
     getHeaderLength(): number;
-    getPayloadLength(remaining: number): number;
+    getPayloadLength(): number;
     readAtoms(tokenizer: ITokenizer, dataHandler: AtomDataHandler, size: number): Promise<void>;
     private readData;
 }

package/node_modules/music-metadata/lib/mp4/Atom.js

@@ -1,24 +1,43 @@
 import initDebug from 'debug';
 import * as AtomToken from './AtomToken.js';
-import { Header } from './AtomToken.js';
+import { Header, Mp4ContentError } from './AtomToken.js';
 const debug = initDebug('music-metadata:parser:MP4:Atom');
 export class Atom {
     static async readAtom(tokenizer, dataHandler, parent, remaining) {
-        // Parse atom header
+        // Validate boundaries before reading either header or dispatching a payload parser.
         const offset = tokenizer.position;
+        remaining = Math.min(remaining, (tokenizer.fileInfo.size ?? Number.POSITIVE_INFINITY) - offset);
+        if (remaining < AtomToken.Header.len) {
+            throw new Mp4ContentError('Truncated atom header');
+        }
         debug(`Reading next token on offset=${offset}...`); //  buf.toString('ascii')
         const header = await tokenizer.readToken(AtomToken.Header);
         const extended = header.length === 1n;
         if (extended) {
+            if (remaining < 16) {
+                throw new Mp4ContentError('Truncated extended atom header');
+            }
             header.length = await tokenizer.readToken(AtomToken.ExtendedSize);
         }
-        const atomBean = new Atom(header, extended, parent);
-        const payloadLength = atomBean.getPayloadLength(remaining);
+        const headerLength = extended ? 16 : 8;
+        if ((extended || header.length !== 0n) && header.length < BigInt(headerLength)) {
+            throw new Mp4ContentError(`Invalid atom size: ${header.length}`);
+        }
+        if (header.length > BigInt(Number.MAX_SAFE_INTEGER)) {
+            throw new Mp4ContentError(`Atom size exceeds Number.MAX_SAFE_INTEGER: ${header.length}`);
+        }
+        const length = header.length === 0n ? remaining : Number(header.length);
+        if (length > remaining) {
+            throw new Mp4ContentError(`Atom size exceeds remaining bytes: ${header.length} > ${remaining}`);
+        }
+        const payloadLength = length - headerLength;
+        const atomBean = new Atom(header, extended, parent, payloadLength);
         debug(`parse atom name=${atomBean.atomPath}, extended=${atomBean.extended}, offset=${offset}, len=${atomBean.header.length}`); //  buf.toString('ascii')
         await atomBean.readData(tokenizer, dataHandler, payloadLength);
         return atomBean;
     }
-    constructor(header, extended, parent) {
+    constructor(header, extended, parent, payloadLength) {
+        this.payloadLength = payloadLength;
         this.header = header;
         this.extended = extended;
         this.parent = parent;
@@ -28,14 +47,24 @@ export class Atom {
     getHeaderLength() {
         return this.extended ? 16 : 8;
     }
-    getPayloadLength(remaining) {
-        return (this.header.length === 0n ? remaining : Number(this.header.length)) - this.getHeaderLength();
+    getPayloadLength() {
+        return this.payloadLength;
     }
     async readAtoms(tokenizer, dataHandler, size) {
         while (size > 0) {
+            if (size === Number.POSITIVE_INFINITY) {
+                // An open-ended container ends only at clean EOF, before the next header.
+                const bytesRead = await tokenizer.peekBuffer(new Uint8Array(Header.len), { mayBeLess: true });
+                if (bytesRead === 0) {
+                    return;
+                }
+                if (bytesRead < Header.len) {
+                    throw new Mp4ContentError('Truncated atom header');
+                }
+            }
             const atomBean = await Atom.readAtom(tokenizer, dataHandler, this, size);
             this.children.push(atomBean);
-            size -= atomBean.header.length === 0n ? size : Number(atomBean.header.length);
+            size = atomBean.header.length === 0n ? 0 : size - Number(atomBean.header.length);
         }
     }
     async readData(tokenizer, dataHandler, remaining) {
@@ -50,13 +79,17 @@ export class Atom {
             case 'ilst':
             case 'tref':
             case 'moof':
-                return this.readAtoms(tokenizer, dataHandler, this.getPayloadLength(remaining));
-            case 'meta': { // Metadata Atom, ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW8
+                return this.readAtoms(tokenizer, dataHandler, remaining);
+            case 'meta': {
+                // Metadata Atom, ref: https://developer.apple.com/library/content/documentation/QuickTime/QTFF/Metadata/Metadata.html#//apple_ref/doc/uid/TP40000939-CH1-SW8
+                if (remaining < 8) {
+                    throw new Mp4ContentError('Truncated meta atom');
+                }
                 // meta has 4 bytes of padding, ignore
                 const peekHeader = await tokenizer.peekToken(Header);
                 const paddingLength = peekHeader.name === 'hdlr' ? 0 : 4;
                 await tokenizer.ignore(paddingLength);
-                return this.readAtoms(tokenizer, dataHandler, this.getPayloadLength(remaining) - paddingLength);
+                return this.readAtoms(tokenizer, dataHandler, remaining - paddingLength);
             }
             default:
                 return dataHandler(this, remaining);

package/node_modules/music-metadata/lib/mp4/AtomToken.d.ts

@@ -1,4 +1,4 @@
-import type { IToken, IGetToken } from 'strtok3';
+import type { IGetToken, IToken } from 'strtok3';
 declare const Mp4ContentError_base: {
     new (message: string): {
         readonly fileType: string;

package/node_modules/music-metadata/lib/mp4/AtomToken.js

@@ -1,9 +1,8 @@
-import * as Token from 'token-types';
 import initDebug from 'debug';
+import * as Token from 'token-types';
 import { FourCcToken } from '../common/FourCC.js';
-import { makeUnexpectedFileContentError } from '../ParseError.js';
 import * as util from '../common/Util.js';
-import { FieldDecodingError } from '../ParseError.js';
+import { FieldDecodingError, makeUnexpectedFileContentError } from '../ParseError.js';
 const debug = initDebug('music-metadata:parser:MP4:atom');
 export class Mp4ContentError extends makeUnexpectedFileContentError('MP4') {
 }
@@ -11,8 +10,9 @@ export const Header = {
     len: 8,
     get: (buf, off) => {
         const length = Token.UINT32_BE.get(buf, off);
-        if (length < 0)
+        if (length < 0) {
             throw new Mp4ContentError('Invalid atom header length');
+        }
         return {
             length: BigInt(length),
             name: new Token.StringType(4, 'latin1').get(buf, off + 4)
@@ -226,7 +226,15 @@ export class TrackHeaderAtom {
         this.len = len;
     }
     get(buf, off) {
+        const available = Math.min(this.len, buf.length - off);
+        if (available < 4) {
+            throw new Mp4ContentError('Truncated tkhd header');
+        }
         const version = Token.UINT8.get(buf, off);
+        // Validate through the volume field, the last field currently decoded.
+        if ((version === 0 && available < 38) || (version === 1 && available < 50)) {
+            throw new Mp4ContentError('Truncated tkhd header');
+        }
         const flags = Token.UINT24_BE.get(buf, off + 1);
         switch (version) {
             case 0:
@@ -306,11 +314,23 @@ export class StsdAtom {
         this.len = len;
     }
     get(buf, off) {
+        const end = Math.min(off + this.len, buf.length);
+        if (end - off < stsdHeader.len) {
+            throw new Mp4ContentError('Truncated stsd header');
+        }
         const header = stsdHeader.get(buf, off);
         off += stsdHeader.len;
         const table = [];
         for (let n = 0; n < header.numberOfEntries; ++n) {
+            if (end - off < Token.UINT32_BE.len) {
+                throw new Mp4ContentError('Truncated stsd sample entry');
+            }
             const size = Token.UINT32_BE.get(buf, off); // Sample description size
+            // A SampleEntry needs its size, format, reserved bytes and data reference index.
+            // Requiring it to fit also bounds the loop by the available payload, not entry_count.
+            if (size < 16 || size > end - off) {
+                throw new Mp4ContentError(`Invalid stsd sample entry size: ${size}`);
+            }
             off += Token.UINT32_BE.len;
             table.push(new SampleDescriptionTable(size - Token.UINT32_BE.len).get(buf, off));
             // A SampleEntry extends Box, so its size covers the size field already stepped over
@@ -449,10 +469,12 @@ export class ChapterText {
 }
 function readTokenTable(buf, token, off, remainingLen, numberOfEntries) {
     debug(`remainingLen=${remainingLen}, numberOfEntries=${numberOfEntries} * token-len=${token.len}`);
-    if (remainingLen === 0)
+    if (remainingLen === 0) {
         return [];
-    if (remainingLen !== numberOfEntries * token.len)
+    }
+    if (remainingLen !== numberOfEntries * token.len) {
         throw new Mp4ContentError('mismatch number-of-entries with remaining atom-length');
+    }
     const entries = [];
     // parse offset-table
     for (let n = 0; n < numberOfEntries; ++n) {
@@ -539,7 +561,7 @@ export class TrackRunBox {
         }
         for (let n = 0; n < trun.sampleCount; ++n) {
             if (dynOffset >= this.len) {
-                debug("TrackRunBox size mismatch");
+                debug('TrackRunBox size mismatch');
                 break;
             }
             const sample = {};
@@ -579,7 +601,7 @@ export class HandlerBox {
             flags: Token.UINT24_BE.get(buf, off + 1),
             componentType: charTypeToken.get(buf, off + 4),
             handlerType: charTypeToken.get(buf, off + 8),
-            componentName: new Token.StringType(this.len - 28, 'utf-8').get(buf, off + 28),
+            componentName: new Token.StringType(this.len - 28, 'utf-8').get(buf, off + 28)
         };
     }
 }

package/node_modules/music-metadata/lib/mp4/MP4Parser.d.ts

@@ -2,6 +2,8 @@ import { BasicParser } from '../common/BasicParser.js';
 import { Atom } from './Atom.js';
 export declare class MP4Parser extends BasicParser {
     private static read_BE_Integer;
+    private validatePayloadLength;
+    private readToken;
     private tracks;
     private hasVideoTrack;
     private hasAudioTrack;

package/node_modules/music-metadata/lib/mp4/MP4Parser.js

@@ -1,13 +1,13 @@
+import { textDecode } from '@borewit/text-codec';
 import initDebug from 'debug';
 import * as Token from 'token-types';
+import { uint8ArrayToHex } from 'uint8array-extras';
 import { BasicParser } from '../common/BasicParser.js';
 import { Genres } from '../id3v1/ID3v1Parser.js';
+import { TrackType } from '../type.js';
 import { Atom } from './Atom.js';
 import * as AtomToken from './AtomToken.js';
 import { ChapterTrackReferenceBox, Mp4ContentError } from './AtomToken.js';
-import { TrackType } from '../type.js';
-import { uint8ArrayToHex } from 'uint8array-extras';
-import { textDecode } from '@borewit/text-codec';
 const debug = initDebug('music-metadata:parser:MP4');
 const tagFormat = 'iTunes';
 const encoderDict = {
@@ -122,7 +122,7 @@ export class MP4Parser extends BasicParser {
              * Ref: https://developer.apple.com/library/archive/documentation/QuickTime/QTFF/QTFFChap2/qtff2.html#//apple_ref/doc/uid/TP40000939-CH204-56313
              */
             mvhd: async (len) => {
-                const mvhd = await this.tokenizer.readToken(new AtomToken.MvhdAtom(len));
+                const mvhd = await this.readToken(new AtomToken.MvhdAtom(len));
                 this.metadata.setFormat('creationTime', mvhd.creationTime);
                 this.metadata.setFormat('modificationTime', mvhd.modificationTime);
             },
@@ -153,9 +153,12 @@ export class MP4Parser extends BasicParser {
                 await this.tokenizer.ignore(len);
             },
             ftyp: async (len) => {
+                if (len < 8 || len % AtomToken.ftyp.len !== 0) {
+                    throw new Mp4ContentError(`Invalid ftyp payload length: ${len}`);
+                }
                 const types = [];
                 while (len > 0) {
-                    const ftype = await this.tokenizer.readToken(AtomToken.ftyp);
+                    const ftype = await this.readToken(AtomToken.ftyp);
                     len -= AtomToken.ftyp.len;
                     const value = ftype.type.replace(/\W/g, '');
                     if (value.length > 0) {
@@ -170,7 +173,7 @@ export class MP4Parser extends BasicParser {
              * Parse sample description atom
              */
             stsd: async (len) => {
-                const stsd = await this.tokenizer.readToken(new AtomToken.StsdAtom(len));
+                const stsd = await this.readToken(new AtomToken.StsdAtom(len));
                 const trackDescription = this.getTrackDescription();
                 trackDescription.soundSampleDescription = stsd.table.map(dfEntry => this.parseSoundSampleDescription(dfEntry));
             },
@@ -178,13 +181,13 @@ export class MP4Parser extends BasicParser {
              * Parse sample-sizes atom ('stsz')
              */
             stsz: async (len) => {
-                const stsz = await this.tokenizer.readToken(new AtomToken.StszAtom(len));
+                const stsz = await this.readToken(new AtomToken.StszAtom(len));
                 const td = this.getTrackDescription();
                 td.sampleSize = stsz.sampleSize;
                 td.sampleSizeTable = stsz.entries;
             },
             date: async (len) => {
-                const date = await this.tokenizer.readToken(new Token.StringType(len, 'utf-8'));
+                const date = await this.readToken(new Token.StringType(len, 'utf-8'));
                 await this.addTag('date', date);
             }
         };
@@ -197,12 +200,23 @@ export class MP4Parser extends BasicParser {
         }
         return Number(token.get(array, 0));
     }
+    // Metadata and sample tables are buffered; media data is skipped separately.
+    // A bound is also necessary for streams whose total size is unknown.
+    validatePayloadLength(length) {
+        if (!Number.isSafeInteger(length) || length < 0 || length > 64 * 1024 * 1024) {
+            throw new Mp4ContentError(`Atom payload exceeds the 64 MiB buffering limit: ${length}`);
+        }
+    }
+    async readToken(token) {
+        this.validatePayloadLength(token.len);
+        return this.tokenizer.readToken(token);
+    }
     async parse() {
         this.hasVideoTrack = false;
         this.hasAudioTrack = true;
         this.tracks.clear();
-        let remainingFileSize = this.tokenizer.fileInfo.size || 0;
-        while (!this.tokenizer.fileInfo.size || remainingFileSize > 0) {
+        let remainingFileSize = this.tokenizer.fileInfo.size ?? Number.POSITIVE_INFINITY;
+        while (remainingFileSize > 0) {
             try {
                 const token = await this.tokenizer.peekToken(AtomToken.Header);
                 if (token.name === '\0\0\0\0') {
@@ -218,12 +232,13 @@ export class MP4Parser extends BasicParser {
                     debug(errMsg);
                     this.addWarning(errMsg);
                 }
-                else
+                else {
                     throw error;
+                }
                 break;
             }
             const rootAtom = await Atom.readAtom(this.tokenizer, (atom, remaining) => this.handleAtom(atom, remaining), null, remainingFileSize);
-            remainingFileSize -= rootAtom.header.length === BigInt(0) ? remainingFileSize : Number(rootAtom.header.length);
+            remainingFileSize = rootAtom.header.length === 0n ? 0 : remainingFileSize - Number(rootAtom.header.length);
         }
         // Post process metadata
         const formatList = [];
@@ -279,10 +294,10 @@ export class MP4Parser extends BasicParser {
                             const dur = sample.sampleDuration ?? fragment.header.defaultSampleDuration ?? 0;
                             const size = sample.sampleSize ?? fragment.header.defaultSampleSize ?? 0;
                             if (dur === 0) {
-                                throw new Error("Missing sampleDuration and no defaultSampleDuration in track fragment header");
+                                throw new Error('Missing sampleDuration and no defaultSampleDuration in track fragment header');
                             }
                             if (size === 0) {
-                                throw new Error("Missing sampleSize and no defaultSampleSize in track fragment header");
+                                throw new Error('Missing sampleSize and no defaultSampleSize in track fragment header');
                             }
                             totalTimeUnits += dur;
                             audioTrack.sizeInBytes += size;
@@ -321,7 +336,7 @@ export class MP4Parser extends BasicParser {
             if (firstAudioTrack.duration) {
                 this.metadata.setFormat('duration', firstAudioTrack.duration);
                 if (firstAudioTrack.sizeInBytes) {
-                    this.metadata.setFormat('bitrate', 8 * firstAudioTrack.sizeInBytes / firstAudioTrack.duration);
+                    this.metadata.setFormat('bitrate', (8 * firstAudioTrack.sizeInBytes) / firstAudioTrack.duration);
                 }
             }
         }
@@ -349,8 +364,10 @@ export class MP4Parser extends BasicParser {
                     }
             }
         }
-        // const payloadLength = atom.getPayloadLength(remaining);
         if (this.atomParsers[atom.header.name]) {
+            if (atom.header.name !== 'mdat') {
+                this.validatePayloadLength(remaining);
+            }
             return this.atomParsers[atom.header.name](remaining);
         }
         debug(`No parser for atom path=${atom.atomPath}, payload-len=${remaining}, ignoring atom`);
@@ -375,27 +392,27 @@ export class MP4Parser extends BasicParser {
      */
     parseMetadataItemData(metaAtom) {
         let tagKey = metaAtom.header.name;
-        return metaAtom.readAtoms(this.tokenizer, async (child, remaining) => {
-            const payLoadLength = child.getPayloadLength(remaining);
+        return metaAtom.readAtoms(this.tokenizer, async (child) => {
+            const payLoadLength = child.getPayloadLength();
             switch (child.header.name) {
                 case 'data': // value atom
                     return this.parseValueAtom(tagKey, child);
                 case 'name': // name atom (optional)
                 case 'mean':
                 case 'rate': {
-                    const name = await this.tokenizer.readToken(new AtomToken.NameAtom(payLoadLength));
+                    const name = await this.readToken(new AtomToken.NameAtom(payLoadLength));
                     tagKey += `:${name.name}`;
                     break;
                 }
                 default: {
-                    const uint8Array = await this.tokenizer.readToken(new Token.Uint8ArrayType(payLoadLength));
+                    const uint8Array = await this.readToken(new Token.Uint8ArrayType(payLoadLength));
                     this.addWarning(`Unsupported meta-item: ${tagKey}[${child.header.name}] => value=${uint8ArrayToHex(uint8Array)} ascii=${textDecode(uint8Array, 'ascii')}`);
                 }
             }
-        }, metaAtom.getPayloadLength(0));
+        }, metaAtom.getPayloadLength());
     }
     async parseValueAtom(tagKey, metaAtom) {
-        const dataAtom = await this.tokenizer.readToken(new AtomToken.DataAtom(Number(metaAtom.header.length) - AtomToken.Header.len));
+        const dataAtom = await this.readToken(new AtomToken.DataAtom(metaAtom.getPayloadLength()));
         if (dataAtom.type.set !== 0) {
             throw new Mp4ContentError(`Unsupported type-set != 0: ${dataAtom.type.set}`);
         }
@@ -433,16 +450,18 @@ export class MP4Parser extends BasicParser {
                 await this.addTag(tagKey, textDecode(dataAtom.value));
                 break;
             case 13: // JPEG
-                if (this.options.skipCovers)
+                if (this.options.skipCovers) {
                     break;
+                }
                 await this.addTag(tagKey, {
                     format: 'image/jpeg',
                     data: Uint8Array.from(dataAtom.value)
                 });
                 break;
             case 14: // PNG
-                if (this.options.skipCovers)
+                if (this.options.skipCovers) {
                     break;
+                }
                 await this.addTag(tagKey, {
                     format: 'image/png',
                     data: Uint8Array.from(dataAtom.value)
@@ -473,19 +492,19 @@ export class MP4Parser extends BasicParser {
             media: {},
             fragments: []
         };
-        await trakBox.readAtoms(this.tokenizer, async (child, remaining) => {
-            const payLoadLength = child.getPayloadLength(remaining);
+        await trakBox.readAtoms(this.tokenizer, async (child) => {
+            const payLoadLength = child.getPayloadLength();
             switch (child.header.name) {
                 case 'chap': {
-                    const chap = await this.tokenizer.readToken(new ChapterTrackReferenceBox(remaining));
+                    const chap = await this.readToken(new ChapterTrackReferenceBox(payLoadLength));
                     track.chapterList = chap;
                     break;
                 }
                 case 'tkhd': // TrackHeaderBox
-                    track.header = await this.tokenizer.readToken(new AtomToken.TrackHeaderAtom(payLoadLength));
+                    track.header = await this.readToken(new AtomToken.TrackHeaderAtom(payLoadLength));
                     break;
                 case 'hdlr': // TrackHeaderBox
-                    track.handler = await this.tokenizer.readToken(new AtomToken.HandlerBox(payLoadLength));
+                    track.handler = await this.readToken(new AtomToken.HandlerBox(payLoadLength));
                     track.isAudio = () => track.handler.handlerType === 'audi' || track.handler.handlerType === 'soun';
                     track.isVideo = () => track.handler.handlerType === 'vide';
                     if (track.isAudio()) {
@@ -495,33 +514,37 @@ export class MP4Parser extends BasicParser {
                         this.hasVideoTrack = true;
                     }
                     break;
-                case 'mdhd': { // Parse media header (mdhd) box
-                    const mdhd_data = await this.tokenizer.readToken(new AtomToken.MdhdAtom(payLoadLength));
+                case 'mdhd': {
+                    // Parse media header (mdhd) box
+                    const mdhd_data = await this.readToken(new AtomToken.MdhdAtom(payLoadLength));
                     track.media.header = mdhd_data;
                     break;
                 }
                 case 'stco': {
-                    const stco = await this.tokenizer.readToken(new AtomToken.StcoAtom(payLoadLength));
+                    const stco = await this.readToken(new AtomToken.StcoAtom(payLoadLength));
                     track.chunkOffsetTable = stco.entries; // remember chunk offsets
                     break;
                 }
-                case 'stsc': { // sample-to-Chunk box
-                    const stsc = await this.tokenizer.readToken(new AtomToken.StscAtom(payLoadLength));
+                case 'stsc': {
+                    // sample-to-Chunk box
+                    const stsc = await this.readToken(new AtomToken.StscAtom(payLoadLength));
                     track.sampleToChunkTable = stsc.entries;
                     break;
                 }
-                case 'stsd': { // sample description box
-                    const stsd = await this.tokenizer.readToken(new AtomToken.StsdAtom(payLoadLength));
+                case 'stsd': {
+                    // sample description box
+                    const stsd = await this.readToken(new AtomToken.StsdAtom(payLoadLength));
                     track.soundSampleDescription = stsd.table.map(dfEntry => this.parseSoundSampleDescription(dfEntry));
                     break;
                 }
-                case 'stts': { // time-to-sample table
-                    const stts = await this.tokenizer.readToken(new AtomToken.SttsAtom(payLoadLength));
+                case 'stts': {
+                    // time-to-sample table
+                    const stts = await this.readToken(new AtomToken.SttsAtom(payLoadLength));
                     track.timeToSampleTable = stts.entries;
                     break;
                 }
                 case 'stsz': {
-                    const stsz = await this.tokenizer.readToken(new AtomToken.StszAtom(payLoadLength));
+                    const stsz = await this.readToken(new AtomToken.StszAtom(payLoadLength));
                     track.sampleSize = stsz.sampleSize;
                     track.sampleSizeTable = stsz.entries;
                     break;
@@ -537,26 +560,28 @@ export class MP4Parser extends BasicParser {
                     await this.tokenizer.ignore(payLoadLength);
                 }
             }
-        }, trakBox.getPayloadLength(0));
+        }, trakBox.getPayloadLength());
         // Register track
         this.tracks.set(track.header.trackId, track);
     }
     parseTrackFragmentBox(trafBox) {
         let tfhd;
-        return trafBox.readAtoms(this.tokenizer, async (child, remaining) => {
-            const payLoadLength = child.getPayloadLength(remaining);
+        return trafBox.readAtoms(this.tokenizer, async (child) => {
+            const payLoadLength = child.getPayloadLength();
             switch (child.header.name) {
-                case 'tfhd': { // TrackFragmentHeaderBox
-                    const fragmentHeaderBox = new AtomToken.TrackFragmentHeaderBox(child.getPayloadLength(remaining));
-                    tfhd = await this.tokenizer.readToken(fragmentHeaderBox);
+                case 'tfhd': {
+                    // TrackFragmentHeaderBox
+                    const fragmentHeaderBox = new AtomToken.TrackFragmentHeaderBox(child.getPayloadLength());
+                    tfhd = await this.readToken(fragmentHeaderBox);
                     break;
                 }
                 case 'tfdt': // TrackFragmentBaseMediaDecodeTimeBo
                     await this.tokenizer.ignore(payLoadLength);
                     break;
-                case 'trun': { // TrackRunBox
+                case 'trun': {
+                    // TrackRunBox
                     const trackRunBox = new AtomToken.TrackRunBox(payLoadLength);
-                    const trun = await this.tokenizer.readToken(trackRunBox);
+                    const trun = await this.readToken(trackRunBox);
                     if (tfhd) {
                         const track = this.tracks.get(tfhd.trackId);
                         track?.fragments.push({ header: tfhd, trackRun: trun });
@@ -568,7 +593,7 @@ export class MP4Parser extends BasicParser {
                     await this.tokenizer.ignore(payLoadLength);
                 }
             }
-        }, trafBox.getPayloadLength(0));
+        }, trafBox.getPayloadLength());
     }
     /**
      * @param sampleDescription
@@ -603,22 +628,22 @@ export class MP4Parser extends BasicParser {
     }
     async parseChapterTrack(chapterTrack, track, len) {
         if (!chapterTrack.sampleSize) {
-            if (chapterTrack.chunkOffsetTable.length !== chapterTrack.sampleSizeTable.length)
+            if (chapterTrack.chunkOffsetTable.length !== chapterTrack.sampleSizeTable.length) {
                 throw new Error('Expected equal chunk-offset-table & sample-size-table length.');
+            }
         }
         const chapters = [];
         for (let i = 0; i < chapterTrack.chunkOffsetTable.length && len > 0; ++i) {
-            const start = chapterTrack.timeToSampleTable
-                .slice(0, i)
-                .reduce((acc, cur) => acc + cur.duration, 0);
+            const start = chapterTrack.timeToSampleTable.slice(0, i).reduce((acc, cur) => acc + cur.duration, 0);
             const chunkOffset = chapterTrack.chunkOffsetTable[i];
             const nextChunkLen = chunkOffset - this.tokenizer.position;
             const sampleSize = chapterTrack.sampleSize > 0 ? chapterTrack.sampleSize : chapterTrack.sampleSizeTable[i];
             len -= nextChunkLen + sampleSize;
-            if (len < 0)
+            if (len < 0) {
                 throw new Mp4ContentError('Chapter chunk exceeding token length');
+            }
             await this.tokenizer.ignore(nextChunkLen);
-            const title = await this.tokenizer.readToken(new AtomToken.ChapterText(sampleSize));
+            const title = await this.readToken(new AtomToken.ChapterText(sampleSize));
             debug(`Chapter ${i + 1}: ${title}`);
             const chapter = {
                 title,

package/node_modules/music-metadata/lib/mp4/MP4TagMapper.d.ts

@@ -1,6 +1,6 @@
 import { CaseInsensitiveTagMap } from '../common/CaseInsensitiveTagMap.js';
-import type { ITag } from "../type.js";
-import type { INativeMetadataCollector } from "../common/MetadataCollector.js";
+import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import type { ITag } from '../type.js';
 export declare const tagType = "iTunes";
 export declare class MP4TagMapper extends CaseInsensitiveTagMap {
     constructor();

package/node_modules/music-metadata/lib/mpeg/MpegLoader.js

@@ -1,6 +1,6 @@
 export const mpegParserLoader = {
     parserType: 'mpeg',
-    extensions: ['.mp2', '.mp3', '.m2a', '.aac', 'aacp'],
+    extensions: ['.mp1', '.mp2', '.mp3', '.m2a', '.aac', 'aacp'],
     mimeTypes: ['audio/mpeg', 'audio/mp3', 'audio/aacs', 'audio/aacp'],
     async load() {
         return (await import('./MpegParser.js')).MpegParser;