@openclaw/whatsapp 2026.9.34 → 2026.9.36

package/node_modules/baileys/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/baileys/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/baileys/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;

package/node_modules/baileys/node_modules/music-metadata/lib/mpeg/MpegParser.js

@@ -1,10 +1,10 @@
-import * as Token from 'token-types';
-import { EndOfStreamError } from 'strtok3';
 import initDebug from 'debug';
+import { EndOfStreamError } from 'strtok3';
+import * as Token from 'token-types';
 import * as common from '../common/Util.js';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import { InfoTagHeaderTag, LameEncoderVersion, readXingHeader } from './XingTag.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { InfoTagHeaderTag, LameEncoderVersion, readXingHeader } from './XingTag.js';
 const debug = initDebug('music-metadata:parser:mpeg');
 export class MpegContentError extends makeUnexpectedFileContentError('MPEG') {
 }
@@ -31,7 +31,22 @@ const MPEG4 = {
      * https://wiki.multimedia.cx/index.php/MPEG-4_Audio#Sampling_Frequencies
      */
     SamplingFrequencies: [
-        96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350, null, null, null
+        96000,
+        88200,
+        64000,
+        48000,
+        44100,
+        32000,
+        24000,
+        22050,
+        16000,
+        12000,
+        11025,
+        8000,
+        7350,
+        null,
+        null,
+        null
     ]
     /**
      * Channel Configurations
@@ -87,14 +102,15 @@ class MpegFrameHeader {
         this.isProtectedByCRC = !common.isBitSet(buf, off + 1, 7);
     }
     calcDuration(numFrames) {
-        return this.samplingRate == null ? null : (numFrames * this.calcSamplesPerFrame() / this.samplingRate);
+        return this.samplingRate == null ? null : (numFrames * this.calcSamplesPerFrame()) / this.samplingRate;
     }
     calcSamplesPerFrame() {
         return MpegFrameHeader.samplesInFrameTable[this.version === 1 ? 0 : 1][this.layer];
     }
     calculateSideInfoLength() {
-        if (this.layer !== 3)
+        if (this.layer !== 3) {
             return 2;
+        }
         if (this.channelModeIndex === 3) {
             // mono
             if (this.version === 1) {
@@ -153,7 +169,7 @@ class MpegFrameHeader {
         }
     }
     parseAdtsHeader(buf, off) {
-        debug("layer=0 => ADTS");
+        debug('layer=0 => ADTS');
         this.version = this.versionIndex === 2 ? 4 : 2;
         this.container = `ADTS/MPEG-${this.version}`;
         const profileIndex = common.getBitAllignedNumber(buf, off + 2, 0, 2);
@@ -170,7 +186,8 @@ class MpegFrameHeader {
     }
     calcBitrate() {
         if (this.bitrateIndex === 0x00 || // free
-            this.bitrateIndex === 0x0F) { // reserved
+            this.bitrateIndex === 0x0f) {
+            // reserved
             return null;
         }
         if (this.version && this.bitrateIndex) {
@@ -180,13 +197,14 @@ class MpegFrameHeader {
         return null;
     }
     calcSamplingRate() {
-        if (this.sampRateFreqIndex === 0x03 || this.version === null || this.sampRateFreqIndex == null)
+        if (this.sampRateFreqIndex === 0x03 || this.version === null || this.sampRateFreqIndex == null) {
             return null; // 'reserved'
+        }
         return MpegFrameHeader.sampling_rate_freq_index[this.version][this.sampRateFreqIndex];
     }
 }
-MpegFrameHeader.SyncByte1 = 0xFF;
-MpegFrameHeader.SyncByte2 = 0xE0;
+MpegFrameHeader.SyncByte1 = 0xff;
+MpegFrameHeader.SyncByte2 = 0xe0;
 MpegFrameHeader.VersionID = [2.5, null, 2, 1];
 MpegFrameHeader.LayerDescription = [0, 3, 2, 1];
 MpegFrameHeader.ChannelMode = ['stereo', 'joint_stereo', 'dual_channel', 'mono'];
@@ -264,7 +282,7 @@ export class MpegParser extends AbstractID3Parser {
         }
         catch (err) {
             if (err instanceof EndOfStreamError) {
-                debug("End-of-stream");
+                debug('End-of-stream');
                 if (this.calculateEofDuration) {
                     if (this.samplesPerFrame !== null) {
                         const numberOfSamples = this.frameCount * this.samplesPerFrame;
@@ -292,7 +310,7 @@ export class MpegParser extends AbstractID3Parser {
             if (format.duration && this.tokenizer.fileInfo.size) {
                 const mpegSize = this.tokenizer.fileInfo.size - this.mpegOffset - (hasID3v1 ? 128 : 0);
                 if (format.codecProfile && format.codecProfile[0] === 'V') {
-                    this.metadata.setFormat('bitrate', mpegSize * 8 / format.duration);
+                    this.metadata.setFormat('bitrate', (mpegSize * 8) / format.duration);
                 }
             }
             if (this.tokenizer.fileInfo.size && format.codecProfile === 'CBR') {
@@ -302,7 +320,7 @@ export class MpegParser extends AbstractID3Parser {
                     this.metadata.setFormat('numberOfSamples', numberOfSamples);
                     if (format.sampleRate && !format.duration) {
                         const duration = numberOfSamples / format.sampleRate;
-                        debug("Calculate CBR duration based on file size: %s", duration);
+                        debug('Calculate CBR duration based on file size: %s', duration);
                         this.metadata.setFormat('duration', duration);
                     }
                 }
@@ -318,7 +336,7 @@ export class MpegParser extends AbstractID3Parser {
                 throw new EndOfStreamError();
             }
             while (true) {
-                if (gotFirstSync && (this.syncPeek.buf[bo] & 0xE0) === 0xE0) {
+                if (gotFirstSync && (this.syncPeek.buf[bo] & 0xe0) === 0xe0) {
                     this.buf_frame_header[0] = MpegFrameHeader.SyncByte1;
                     this.buf_frame_header[1] = this.syncPeek.buf[bo];
                     await this.tokenizer.ignore(bo);
@@ -372,7 +390,9 @@ export class MpegParser extends AbstractID3Parser {
         this.metadata.setFormat('lossless', false);
         this.metadata.setFormat('sampleRate', header.samplingRate);
         this.frameCount++;
-        return header.version !== null && header.version >= 2 && header.layer === 0 ? this.parseAdts(header) : this.parseAudioFrameHeader(header);
+        return header.version !== null && header.version >= 2 && header.layer === 0
+            ? this.parseAdts(header)
+            : this.parseAudioFrameHeader(header);
     }
     /**
      * @return {Promise<boolean>} true if parser should quit
@@ -391,7 +411,7 @@ export class MpegParser extends AbstractID3Parser {
         debug(`samples_per_frame=${samples_per_frame}`);
         const bps = samples_per_frame / 8.0;
         if (header.bitrate !== null && header.samplingRate != null) {
-            const fsize = (bps * header.bitrate / header.samplingRate) + ((header.padding) ? slot_size : 0);
+            const fsize = (bps * header.bitrate) / header.samplingRate + (header.padding ? slot_size : 0);
             this.frame_size = Math.floor(fsize);
         }
         this.audioFrameHeader = header;
@@ -410,8 +430,9 @@ export class MpegParser extends AbstractID3Parser {
                 // Actual calculation will be done in finalize
                 this.samplesPerFrame = samples_per_frame;
                 this.metadata.setFormat('codecProfile', 'CBR');
-                if (this.tokenizer.fileInfo.size)
+                if (this.tokenizer.fileInfo.size) {
                     return true; // Will calculate duration based on the file size
+                }
             }
             else if (this.metadata.format.duration) {
                 return true; // We already got the duration, stop processing MPEG stream any further
@@ -556,8 +577,9 @@ export class MpegParser extends AbstractID3Parser {
         return infoTag;
     }
     async skipFrameData(frameDataLeft) {
-        if (frameDataLeft < 0)
+        if (frameDataLeft < 0) {
             throw new MpegContentError('frame-data-left cannot be negative');
+        }
         await this.tokenizer.ignore(frameDataLeft);
     }
     areAllSame(array) {

package/node_modules/baileys/node_modules/music-metadata/lib/mpeg/ReplayGainDataFormat.d.ts

@@ -21,7 +21,7 @@ declare const NameCode: {
      */
     audiophile: number;
 };
-type NameCode = typeof NameCode[keyof typeof NameCode];
+type NameCode = (typeof NameCode)[keyof typeof NameCode];
 /**
  * https://github.com/Borewit/music-metadata/wiki/Replay-Gain-Data-Format#originator-code
  */
@@ -47,7 +47,7 @@ declare const ReplayGainOriginator: {
      */
     rms_average: number;
 };
-type ReplayGainOriginator = typeof ReplayGainOriginator[keyof typeof ReplayGainOriginator];
+type ReplayGainOriginator = (typeof ReplayGainOriginator)[keyof typeof ReplayGainOriginator];
 /**
  * Replay Gain Data Format
  *

package/node_modules/baileys/node_modules/music-metadata/lib/mpeg/ReplayGainDataFormat.js

@@ -56,7 +56,7 @@ export const ReplayGain = {
             return {
                 type: common.getBitAllignedNumber(buf, off, 0, 3),
                 origin: common.getBitAllignedNumber(buf, off, 3, 3),
-                adjustment: (sign ? -gain_adj : gain_adj)
+                adjustment: sign ? -gain_adj : gain_adj
             };
         }
         return undefined;

package/node_modules/baileys/node_modules/music-metadata/lib/mpeg/XingTag.d.ts

@@ -1,5 +1,5 @@
-import * as Token from 'token-types';
 import type { IGetToken, ITokenizer } from 'strtok3';
+import * as Token from 'token-types';
 import { type IExtendedLameHeader } from './ExtendedLameHeader.js';
 export interface IXingHeaderFlags {
     frames: boolean;

package/node_modules/baileys/node_modules/music-metadata/lib/musepack/MusepackParser.js

@@ -1,9 +1,9 @@
 import initDebug from 'debug';
 import * as Token from 'token-types';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import { MpcSv8Parser } from './sv8/MpcSv8Parser.js';
-import { MpcSv7Parser } from './sv7/MpcSv7Parser.js';
 import { MusepackContentError } from './MusepackConentError.js';
+import { MpcSv7Parser } from './sv7/MpcSv7Parser.js';
+import { MpcSv8Parser } from './sv8/MpcSv8Parser.js';
 const debug = initDebug('music-metadata:parser:musepack');
 export class MusepackParser extends AbstractID3Parser {
     async postId3v2Parse() {

package/node_modules/baileys/node_modules/music-metadata/lib/musepack/sv7/BitReader.js

@@ -16,7 +16,7 @@ export class BitReader {
         let out = this.dword;
         this.pos += bits;
         if (this.pos < 32) {
-            out >>>= (32 - this.pos);
+            out >>>= 32 - this.pos;
             return out & ((1 << bits) - 1);
         }
         this.pos -= 32;

package/node_modules/baileys/node_modules/music-metadata/lib/musepack/sv7/MpcSv7Parser.js

@@ -1,9 +1,9 @@
 import initDebug from 'debug';
-import { BasicParser } from '../../common/BasicParser.js';
 import { tryParseApeHeader } from '../../apev2/APEv2Parser.js';
+import { BasicParser } from '../../common/BasicParser.js';
+import { MusepackContentError } from '../MusepackConentError.js';
 import { BitReader } from './BitReader.js';
 import * as SV7 from './StreamVersion7.js';
-import { MusepackContentError } from '../MusepackConentError.js';
 const debug = initDebug('music-metadata:parser:musepack');
 export class MpcSv7Parser extends BasicParser {
     constructor() {
@@ -14,8 +14,9 @@ export class MpcSv7Parser extends BasicParser {
     }
     async parse() {
         const header = await this.tokenizer.readToken(SV7.Header);
-        if (header.signature !== 'MP+')
+        if (header.signature !== 'MP+') {
             throw new MusepackContentError('Unexpected magic number');
+        }
         debug(`stream-version=${header.streamMajorVersion}.${header.streamMinorVersion}`);
         this.metadata.setFormat('container', 'Musepack, SV7');
         this.metadata.setFormat('sampleRate', header.sampleFrequency);

package/node_modules/baileys/node_modules/music-metadata/lib/musepack/sv7/StreamVersion7.js

@@ -1,6 +1,6 @@
+import { textDecode } from '@borewit/text-codec';
 import * as Token from 'token-types';
 import * as util from '../../common/Util.js';
-import { textDecode } from '@borewit/text-codec';
 /**
  * BASIC STRUCTURE
  */
@@ -30,10 +30,10 @@ export const Header = {
             albumPeak: Token.UINT16_LE.get(buf, off + 16),
             albumGain: Token.UINT16_LE.get(buf, off + 18),
             // word
-            lastFrameLength: (Token.UINT32_LE.get(buf, off + 20) >>> 20) & 0x7FF,
+            lastFrameLength: (Token.UINT32_LE.get(buf, off + 20) >>> 20) & 0x7ff,
             trueGapless: util.isBitSet(buf, off + 23, 0)
         };
-        header.lastFrameLength = header.trueGapless ? (Token.UINT32_LE.get(buf, 20) >>> 20) & 0x7FF : 0;
+        header.lastFrameLength = header.trueGapless ? (Token.UINT32_LE.get(buf, 20) >>> 20) & 0x7ff : 0;
         return header;
     }
 };