@openclaw/whatsapp 2026.9.34 → 2026.9.36

package/node_modules/baileys/node_modules/music-metadata/lib/core.js

@@ -1,14 +1,14 @@
 /**
  * Primary entry point, Node.js specific entry point is MusepackParser.ts
  */
-import { fromWebStream, fromBuffer, fromBlob } from 'strtok3';
-import { ParserFactory } from './ParserFactory.js';
+import { fromBlob, fromBuffer, fromWebStream } from 'strtok3';
 import { APEv2Parser } from './apev2/APEv2Parser.js';
 import { hasID3v1Header } from './id3v1/ID3v1Parser.js';
 import { getLyricsHeaderLength } from './lyrics3/Lyrics3.js';
-export { LyricsContentType, TimestampFormat } from './type.js';
-export { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
+import { ParserFactory } from './ParserFactory.js';
 export * from './ParseError.js';
+export { CouldNotDetermineFileTypeError, UnsupportedFileTypeError } from './ParseError.js';
+export { LyricsContentType, TimestampFormat } from './type.js';
 /**
  * Parse Web API File
  * Requires Blob to be able to stream using a ReadableStreamBYOBReader, only available since Node.js ≥ 20
@@ -33,7 +33,9 @@ export async function parseBlob(blob, options = {}) {
  * @returns Metadata
  */
 export async function parseWebStream(webStream, fileInfo, options = {}) {
-    const tokenizer = fromWebStream(webStream, { fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo });
+    const tokenizer = fromWebStream(webStream, {
+        fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo
+    });
     try {
         return await parseFromTokenizer(tokenizer, options);
     }
@@ -50,7 +52,9 @@ export async function parseWebStream(webStream, fileInfo, options = {}) {
  * Ref: https://github.com/Borewit/strtok3/blob/e6938c81ff685074d5eb3064a11c0b03ca934c1d/src/index.ts#L15
  */
 export async function parseBuffer(uint8Array, fileInfo, options = {}) {
-    const tokenizer = fromBuffer(uint8Array, { fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo });
+    const tokenizer = fromBuffer(uint8Array, {
+        fileInfo: typeof fileInfo === 'string' ? { mimeType: fileInfo } : fileInfo
+    });
     return parseFromTokenizer(tokenizer, options);
 }
 /**
@@ -89,11 +93,14 @@ export function ratingToStars(rating) {
  * @return Cover image, if any, otherwise null
  */
 export function selectCover(pictures) {
-    return pictures ? pictures.reduce((acc, cur) => {
-        if (cur.name && cur.name.toLowerCase() in ['front', 'cover', 'cover (front)'])
-            return cur;
-        return acc;
-    }) : null;
+    return pictures
+        ? pictures.reduce((acc, cur) => {
+            if (cur.name && cur.name.toLowerCase() in ['front', 'cover', 'cover (front)']) {
+                return cur;
+            }
+            return acc;
+        })
+        : null;
 }
 export async function scanAppendingHeaders(tokenizer, options = {}) {
     let apeOffset = tokenizer.fileInfo.size;

package/node_modules/baileys/node_modules/music-metadata/lib/dsdiff/DsdiffParser.js

@@ -1,11 +1,11 @@
-import * as Token from 'token-types';
 import initDebug from 'debug';
 import * as strtok3 from 'strtok3';
-import { FourCcToken } from '../common/FourCC.js';
+import * as Token from 'token-types';
 import { BasicParser } from '../common/BasicParser.js';
+import { FourCcToken } from '../common/FourCC.js';
 import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
-import { ChunkHeader64 } from './DsdiffToken.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { ChunkHeader64 } from './DsdiffToken.js';
 const debug = initDebug('music-metadata:parser:aiff');
 export class DsdiffContentParseError extends makeUnexpectedFileContentError('DSDIFF') {
 }
@@ -18,8 +18,9 @@ export class DsdiffContentParseError extends makeUnexpectedFileContentError('DSD
 export class DsdiffParser extends BasicParser {
     async parse() {
         const header = await this.tokenizer.readToken(ChunkHeader64);
-        if (header.chunkID !== 'FRM8')
+        if (header.chunkID !== 'FRM8') {
             throw new DsdiffContentParseError('Unexpected chunk-ID');
+        }
         this.metadata.setAudioOnly();
         const type = (await this.tokenizer.readToken(FourCcToken)).trim();
         switch (type) {
@@ -37,26 +38,30 @@ export class DsdiffParser extends BasicParser {
             //  If the data is an odd number of bytes in length, a pad byte must be added at the end
             debug(`Chunk id=${chunkHeader.chunkID}`);
             await this.readData(chunkHeader);
-            remainingSize -= (BigInt(ChunkHeader64.len) + chunkHeader.chunkSize);
+            remainingSize -= BigInt(ChunkHeader64.len) + chunkHeader.chunkSize;
         }
     }
     async readData(header) {
         debug(`Reading data of chunk[ID=${header.chunkID}, size=${header.chunkSize}]`);
         const p0 = this.tokenizer.position;
         switch (header.chunkID.trim()) {
-            case 'FVER': { // 3.1 FORMAT VERSION CHUNK
+            case 'FVER': {
+                // 3.1 FORMAT VERSION CHUNK
                 const version = await this.tokenizer.readToken(Token.UINT32_LE);
                 debug(`DSDIFF version=${version}`);
                 break;
             }
-            case 'PROP': { // 3.2 PROPERTY CHUNK
+            case 'PROP': {
+                // 3.2 PROPERTY CHUNK
                 const propType = await this.tokenizer.readToken(FourCcToken);
-                if (propType !== 'SND ')
+                if (propType !== 'SND ') {
                     throw new DsdiffContentParseError('Unexpected PROP-chunk ID');
+                }
                 await this.handleSoundPropertyChunks(header.chunkSize - BigInt(FourCcToken.len));
                 break;
             }
-            case 'ID3': { // Unofficial ID3 tag support
+            case 'ID3': {
+                // Unofficial ID3 tag support
                 const id3_data = await this.tokenizer.readToken(new Token.Uint8ArrayType(Number(header.chunkSize)));
                 const rst = strtok3.fromBuffer(id3_data);
                 await new ID3v2Parser().parse(this.metadata, rst, this.options);
@@ -64,7 +69,7 @@ export class DsdiffParser extends BasicParser {
             }
             case 'DSD':
                 if (this.metadata.format.numberOfChannels) {
-                    this.metadata.setFormat('numberOfSamples', Number(header.chunkSize * BigInt(8) / BigInt(this.metadata.format.numberOfChannels)));
+                    this.metadata.setFormat('numberOfSamples', Number((header.chunkSize * BigInt(8)) / BigInt(this.metadata.format.numberOfChannels)));
                 }
                 if (this.metadata.format.numberOfSamples && this.metadata.format.sampleRate) {
                     this.metadata.setFormat('duration', this.metadata.format.numberOfSamples / this.metadata.format.sampleRate);
@@ -87,18 +92,21 @@ export class DsdiffParser extends BasicParser {
             debug(`Sound-property-chunk[ID=${sndPropHeader.chunkID}, size=${sndPropHeader.chunkSize}]`);
             const p0 = this.tokenizer.position;
             switch (sndPropHeader.chunkID.trim()) {
-                case 'FS': { // 3.2.1 Sample Rate Chunk
+                case 'FS': {
+                    // 3.2.1 Sample Rate Chunk
                     const sampleRate = await this.tokenizer.readToken(Token.UINT32_BE);
                     this.metadata.setFormat('sampleRate', sampleRate);
                     break;
                 }
-                case 'CHNL': { // 3.2.2 Channels Chunk
+                case 'CHNL': {
+                    // 3.2.2 Channels Chunk
                     const numChannels = await this.tokenizer.readToken(Token.UINT16_BE);
                     this.metadata.setFormat('numberOfChannels', numChannels);
                     await this.handleChannelChunks(sndPropHeader.chunkSize - BigInt(Token.UINT16_BE.len));
                     break;
                 }
-                case 'CMPR': { // 3.2.3 Compression Type Chunk
+                case 'CMPR': {
+                    // 3.2.3 Compression Type Chunk
                     const compressionIdCode = (await this.tokenizer.readToken(FourCcToken)).trim();
                     const count = await this.tokenizer.readToken(Token.UINT8);
                     const compressionName = await this.tokenizer.readToken(new Token.StringType(count, 'ascii'));
@@ -109,7 +117,8 @@ export class DsdiffParser extends BasicParser {
                     this.metadata.setFormat('codec', `${compressionIdCode} (${compressionName})`);
                     break;
                 }
-                case 'ABSS': { // 3.2.4 Absolute Start Time Chunk
+                case 'ABSS': {
+                    // 3.2.4 Absolute Start Time Chunk
                     const hours = await this.tokenizer.readToken(Token.UINT16_BE);
                     const minutes = await this.tokenizer.readToken(Token.UINT8);
                     const seconds = await this.tokenizer.readToken(Token.UINT8);
@@ -117,7 +126,8 @@ export class DsdiffParser extends BasicParser {
                     debug(`ABSS ${hours}:${minutes}:${seconds}.${samples}`);
                     break;
                 }
-                case 'LSCO': { // 3.2.5 Loudspeaker Configuration Chunk
+                case 'LSCO': {
+                    // 3.2.5 Loudspeaker Configuration Chunk
                     const lsConfig = await this.tokenizer.readToken(Token.UINT16_BE);
                     debug(`LSCO lsConfig=${lsConfig}`);
                     break;
@@ -134,7 +144,10 @@ export class DsdiffParser extends BasicParser {
             remainingSize -= BigInt(ChunkHeader64.len) + sndPropHeader.chunkSize;
             debug(`Parsing sound-property-chunks, remainingSize=${remainingSize}`);
         }
-        if (this.metadata.format.lossless && this.metadata.format.sampleRate && this.metadata.format.numberOfChannels && this.metadata.format.bitsPerSample) {
+        if (this.metadata.format.lossless &&
+            this.metadata.format.sampleRate &&
+            this.metadata.format.numberOfChannels &&
+            this.metadata.format.bitsPerSample) {
             const bitrate = this.metadata.format.sampleRate * this.metadata.format.numberOfChannels * this.metadata.format.bitsPerSample;
             this.metadata.setFormat('bitrate', bitrate);
         }

package/node_modules/baileys/node_modules/music-metadata/lib/dsf/DsfChunk.d.ts

@@ -43,7 +43,7 @@ export declare const ChannelType: {
     '5 channels': number;
     '5.1 channels': number;
 };
-export type ChannelType = typeof ChannelType[keyof typeof ChannelType];
+export type ChannelType = (typeof ChannelType)[keyof typeof ChannelType];
 /**
  * Interface to format chunk payload chunk
  */

package/node_modules/baileys/node_modules/music-metadata/lib/dsf/DsfParser.js

@@ -1,9 +1,9 @@
 import initDebug from 'debug';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
-import { ChunkHeader, DsdChunk, FormatChunk } from './DsfChunk.js';
 import { ID3v2Parser } from '../id3v2/ID3v2Parser.js';
-import { makeUnexpectedFileContentError } from '../ParseError.js';
 import { ID3v2Header } from '../id3v2/ID3v2Token.js';
+import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { ChunkHeader, DsdChunk, FormatChunk } from './DsfChunk.js';
 const debug = initDebug('music-metadata:parser:DSF');
 export class DsdContentParseError extends makeUnexpectedFileContentError('DSD') {
 }
@@ -66,9 +66,7 @@ export class DsfParser extends AbstractID3Parser {
                     this.metadata.setFormat('bitsPerSample', formatChunk.bitsPerSample);
                     this.metadata.setFormat('numberOfSamples', formatChunk.sampleCount);
                     this.metadata.setFormat('duration', Number(formatChunk.sampleCount) / formatChunk.samplingFrequency);
-                    const bitrate = formatChunk.bitsPerSample *
-                        formatChunk.samplingFrequency *
-                        formatChunk.channelNum;
+                    const bitrate = formatChunk.bitsPerSample * formatChunk.samplingFrequency * formatChunk.channelNum;
                     this.metadata.setFormat('bitrate', bitrate);
                     return; // We got what we want, stop further processing of chunks
                 }

package/node_modules/baileys/node_modules/music-metadata/lib/ebml/EbmlIterator.d.ts

@@ -28,7 +28,7 @@ export declare const ParseAction: {
     readonly TerminateParsing: 4;
     readonly SkipElement: 5;
 };
-export type ParseAction = typeof ParseAction[keyof typeof ParseAction];
+export type ParseAction = (typeof ParseAction)[keyof typeof ParseAction];
 /**
  * @return true, to quit the parser
  */

package/node_modules/baileys/node_modules/music-metadata/lib/ebml/EbmlIterator.js

@@ -1,9 +1,9 @@
-import { Float32_BE, Float64_BE, StringType, UINT8 } from 'token-types';
 import initDebug from 'debug';
 import { EndOfStreamError } from 'strtok3';
-import { DataType } from './types.js';
 import * as Token from 'token-types';
+import { Float32_BE, Float64_BE, StringType, UINT8 } from 'token-types';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
+import { DataType } from './types.js';
 const debug = initDebug('music-metadata:parser:ebml');
 export class EbmlContentError extends makeUnexpectedFileContentError('EBML') {
 }
@@ -61,14 +61,15 @@ export class EbmlIterator {
                 switch (action) {
                     case ParseAction.ReadNext:
                         {
-                            if (element.id === 0x1F43B675) {
+                            if (element.id === 0x1f43b675) {
                                 // Hack to ignore remaining segment, when cluster element received
                                 // await this.tokenizer.ignore(posDone - this.tokenizer.position);
                                 // break;
                             }
                             debug(`Read element: name=${getElementPath(child)}{id=0x${element.id.toString(16)}, container=${!!child.container}} at position=${elementPosition}`);
                             if (child.container) {
-                                const res = await this.parseContainer(child, element.len >= 0 ? this.tokenizer.position + element.len : -1, listener);
+                                const childEnd = Math.min(posDone, this.tokenizer.fileInfo.size ?? Number.POSITIVE_INFINITY, element.len >= 0 ? this.tokenizer.position + element.len : posDone);
+                                const res = await this.parseContainer(child, childEnd, listener);
                                 if (child.multiple) {
                                     if (!tree[child.name]) {
                                         tree[child.name] = [];
@@ -83,6 +84,13 @@ export class EbmlIterator {
                             else {
                                 const parser = this.parserMap.get(child.value);
                                 if (typeof parser === 'function') {
+                                    // Validate before leaf readers allocate buffers or string tokens from the declared length.
+                                    const end = Math.min(posDone, this.tokenizer.fileInfo.size ?? Number.POSITIVE_INFINITY);
+                                    if (!Number.isSafeInteger(element.len) ||
+                                        element.len < 0 ||
+                                        element.len > end - this.tokenizer.position) {
+                                        throw new EbmlContentError(`Invalid element length: ${element.len}`);
+                                    }
                                     const value = await parser(element);
                                     tree[child.name] = value;
                                     await listener.elementValue(child, value, elementPosition);
@@ -166,10 +174,30 @@ export class EbmlIterator {
         return readUIntBE(buf, e.len);
     }
     async readString(e) {
-        const rawString = await this.tokenizer.readToken(new StringType(e.len, 'utf-8'));
+        const buf = await this.readBuffer(e);
+        const rawString = new StringType(e.len, 'utf-8').get(buf, 0);
         return rawString.replace(/\x00.*$/g, '');
     }
     async readBuffer(e) {
+        const chunkSize = 64 * 1024;
+        if ((!this.tokenizer.supportsRandomAccess() || this.tokenizer.fileInfo.size === undefined) && e.len > chunkSize) {
+            // Neither a declared container size nor an advertised stream size proves these bytes exist.
+            // Allocate incrementally, and only assemble the leaf after reading its payload.
+            const chunks = [];
+            for (let remaining = e.len; remaining > 0;) {
+                const chunk = new Uint8Array(Math.min(remaining, chunkSize));
+                await this.tokenizer.readBuffer(chunk);
+                chunks.push(chunk);
+                remaining -= chunk.length;
+            }
+            const buf = new Uint8Array(e.len);
+            let offset = 0;
+            for (const chunk of chunks) {
+                buf.set(chunk, offset);
+                offset += chunk.length;
+            }
+            return buf;
+        }
         const buf = new Uint8Array(e.len);
         await this.tokenizer.readBuffer(buf);
         return buf;
@@ -202,7 +230,8 @@ function linkParents(element) {
             const child = element.container[id];
             child.id = Number.parseInt(id, 10);
             return child;
-        }).forEach(child => {
+        })
+            .forEach(child => {
             child.parent = element;
             linkParents(child);
         });

package/node_modules/baileys/node_modules/music-metadata/lib/ebml/types.d.ts

@@ -9,7 +9,7 @@ export declare const DataType: {
     readonly binary: 4;
     readonly float: 5;
 };
-export type DataType = typeof DataType[keyof typeof DataType];
+export type DataType = (typeof DataType)[keyof typeof DataType];
 export type ValueType = string | number | Uint8Array | boolean | ITree | ITree[];
 export interface IHeader {
     id: number;

package/node_modules/baileys/node_modules/music-metadata/lib/ebml/types.js

@@ -4,5 +4,5 @@ export const DataType = {
     uid: 2,
     bool: 3,
     binary: 4,
-    float: 5,
+    float: 5
 };

package/node_modules/baileys/node_modules/music-metadata/lib/flac/FlacParser.d.ts

@@ -1,5 +1,5 @@
-import { type IVorbisPicture } from '../ogg/vorbis/Vorbis.js';
 import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+import { type IVorbisPicture } from '../ogg/vorbis/Vorbis.js';
 import type { IBlockStreamInfo } from './FlacToken.js';
 export declare class FlacParser extends AbstractID3Parser {
     private vorbisParser;

package/node_modules/baileys/node_modules/music-metadata/lib/flac/FlacParser.js

@@ -1,10 +1,10 @@
 import initDebug from 'debug';
 import { Uint8ArrayType } from 'token-types';
-import { VorbisPictureToken } from '../ogg/vorbis/Vorbis.js';
-import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
 import { FourCcToken } from '../common/FourCC.js';
-import { VorbisStream } from '../ogg/vorbis/VorbisStream.js';
+import { AbstractID3Parser } from '../id3v2/AbstractID3Parser.js';
+import { VorbisPictureToken } from '../ogg/vorbis/Vorbis.js';
 import { VorbisDecoder } from '../ogg/vorbis/VorbisDecoder.js';
+import { VorbisStream } from '../ogg/vorbis/VorbisStream.js';
 import { makeUnexpectedFileContentError } from '../ParseError.js';
 import * as Flac from './FlacToken.js';
 const debug = initDebug('music-metadata:parser:FLAC');
@@ -29,7 +29,7 @@ export class FlacParser extends AbstractID3Parser {
         } while (!blockHeader.lastBlock);
         if (this.tokenizer.fileInfo.size && this.metadata.format.duration) {
             const dataSize = this.tokenizer.fileInfo.size - this.tokenizer.position;
-            this.metadata.setFormat('bitrate', 8 * dataSize / this.metadata.format.duration);
+            this.metadata.setFormat('bitrate', (8 * dataSize) / this.metadata.format.duration);
         }
     }
     async parseDataBlock(blockHeader) {
@@ -60,8 +60,9 @@ export class FlacParser extends AbstractID3Parser {
      * Parse STREAMINFO
      */
     async readBlockStreamInfo(dataLen) {
-        if (dataLen !== Flac.BlockStreamInfo.len)
+        if (dataLen !== Flac.BlockStreamInfo.len) {
             throw new FlacContentError('Unexpected block-stream-info length');
+        }
         const streamInfo = await this.tokenizer.readToken(Flac.BlockStreamInfo);
         this.metadata.setFormat('container', 'FLAC');
         this.processsStreamInfo(streamInfo);

package/node_modules/baileys/node_modules/music-metadata/lib/flac/FlacToken.d.ts

@@ -12,7 +12,7 @@ export declare const BlockType: {
     CUESHEET: number;
     PICTURE: number;
 };
-export type BlockType = typeof BlockType[keyof typeof BlockType];
+export type BlockType = (typeof BlockType)[keyof typeof BlockType];
 /**
  * METADATA_BLOCK_DATA
  * Ref: https://xiph.org/flac/format.html#metadata_block_streaminfo

package/node_modules/baileys/node_modules/music-metadata/lib/flac/FlacToken.js

@@ -1,5 +1,5 @@
-import * as util from '../common/Util.js';
 import { UINT16_BE, UINT24_BE, Uint8ArrayType } from 'token-types';
+import * as util from '../common/Util.js';
 /**
  * FLAC supports up to 128 kinds of metadata blocks; currently the following are defined:
  * ref: https://xiph.org/flac/format.html#metadata_block

package/node_modules/baileys/node_modules/music-metadata/lib/id3v1/ID3v1Parser.d.ts

@@ -1,7 +1,7 @@
 import type { IRandomAccessTokenizer, ITokenizer } from 'strtok3';
 import { BasicParser } from '../common/BasicParser.js';
-import type { IPrivateOptions } from '../type.js';
 import type { INativeMetadataCollector } from '../common/MetadataCollector.js';
+import type { IPrivateOptions } from '../type.js';
 /**
  * ID3v1 Genre mappings
  * Ref: https://de.wikipedia.org/wiki/Liste_der_ID3v1-Genres