@openclaw/whatsapp 2026.5.31-beta.2 → 2026.5.31-beta.4

package/node_modules/audio-buffer/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "audio-buffer",
+  "version": "5.0.0",
+  "description": "AudioBuffer class for node/browser",
+  "main": "index.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/audiojs/audio-buffer"
+  },
+  "scripts": {
+    "test": "node test"
+  },
+  "keywords": [
+    "audio",
+    "audiojs",
+    "pcm",
+    "dsp",
+    "sound",
+    "processing",
+    "ndsamples",
+    "ponyfill",
+    "audio-buffer",
+    "web-audio",
+    "waa",
+    "audiodata"
+  ],
+  "author": "Dmitry Iv <df.creative@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/audiojs/audio-buffer/issues"
+  },
+  "homepage": "https://github.com/audiojs/audio-buffer",
+  "devDependencies": {
+    "tape": "^5.6.3"
+  }
+}

package/node_modules/audio-buffer/readme.md

@@ -0,0 +1,56 @@
+# audio-buffer [![test](https://github.com/audiojs/audio-buffer/actions/workflows/node.js.yml/badge.svg)](https://github.com/audiojs/audio-buffer/actions/workflows/node.js.yml) [![stable](https://img.shields.io/badge/stability-stable-brightgreen.svg)](http://github.com/badges/stability-badges)
+
+_AudioBuffer_ - basic audio data container class.
+Useful instead of _Buffer_ in audio streams, [**@audiojs**](https://github.com/audiojs) components, in webworkers, nodejs, other environments without audio context.
+
+Implementation is compatible with [Web Audio API AudioBuffer](https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer), can be used as ponyfill.
+
+## Usage
+
+[![npm install audio-buffer](https://nodei.co/npm/audio-buffer.png?mini=true)](https://npmjs.org/package/audio-buffer/)
+
+### new AudioBuffer(options)
+
+Create audio buffer from `options`.
+
+* `options.length` — number of samples, minimum is 1.
+* `options.sampleRate` — default sample rate is 44100.
+* `options.numberOfChannels` — default number of channels is 1.
+
+### buffer.duration
+
+Duration of the underlying audio data, in seconds.
+
+### buffer.length
+
+Number of samples per channel.
+
+### buffer.sampleRate
+
+Default sample rate is 44100.
+
+### buffer.numberOfChannels
+
+Default number of channels is 1.
+
+### buffer.getChannelData(channel)
+
+Get array containing the data for the channel (not copied).
+
+### buffer.copyFromChannel(destination, channelNumber, startInChannel=0)
+
+Place data from channel to destination Float32Array.
+
+### buffer.copyToChannel(source, channelNumber, startInChannel=0)
+
+Place data from source Float32Array to the channel.
+
+
+## Similar
+
+* [ndsamples](https://github.com/livejs/ndsamples) — audio-wrapper for ndarrays. A somewhat alternative approach to wrap audio data, based on ndarrays, used by some modules in [livejs](https://github.com/livejs).
+* [1](https://www.npmjs.com/package/audiobuffer), [2](https://www.npmjs.com/package/audio-buffer), [3](https://github.com/sebpiq/node-web-audio-api/blob/master/lib/AudioBuffer.js), [4](https://developer.mozilla.org/en-US/docs/Web/API/AudioBuffer) — other AudioBuffer implementations.
+* [audiodata](https://www.npmjs.com/package/audiodata) alternative data holder from @mohayonao.
+
+
+<p align=center><a href="https://github.com/krishnized/license/">🕉</a></p>

package/node_modules/audio-decode/.eslintrc.json

@@ -0,0 +1,43 @@
+{
+    "env": {
+        "browser": true,
+        "node": true,
+        "commonjs": true,
+        "es6": true
+    },
+    "extends": "eslint:recommended",
+    "rules": {
+        "strict": 2,
+        "indent": 0,
+        "linebreak-style": 0,
+        "quotes": 0,
+        "semi": 0,
+        "no-cond-assign": 1,
+        "no-constant-condition": 1,
+        "no-duplicate-case": 1,
+        "no-empty": 1,
+        "no-ex-assign": 1,
+        "no-extra-boolean-cast": 1,
+        "no-extra-semi": 1,
+        "no-fallthrough": 1,
+        "no-func-assign": 1,
+        "no-global-assign": 1,
+        "no-implicit-globals": 2,
+        "no-inner-declarations": ["error", "functions"],
+        "no-irregular-whitespace": 2,
+        "no-loop-func": 1,
+        "no-multi-str": 1,
+        "no-mixed-spaces-and-tabs": 1,
+        "no-proto": 1,
+        "no-sequences": 1,
+        "no-throw-literal": 1,
+        "no-unmodified-loop-condition": 1,
+        "no-useless-call": 1,
+        "no-void": 1,
+        "no-with": 2,
+        "wrap-iife": 1,
+        "no-redeclare": 1,
+        "no-unused-vars": ["error", { "vars": "all", "args": "none" }],
+        "no-sparse-arrays": 1
+    }
+}

package/node_modules/audio-decode/.github/workflows/test.js.yml

@@ -1,22 +1,31 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
 name: test
 
 on:
   push:
-    branches: [master]
+    branches: [ "master" ]
   pull_request:
-    branches: [master]
+    branches: [ "master" ]
 
 jobs:
-  test:
+  build:
+
     runs-on: ubuntu-latest
+
     strategy:
       matrix:
-        node-version: [20.x, 22.x]
+        node-version: [14.x, 16.x, 18.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: npm
-      - run: npm ci
-      - run: npm test
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm run build --if-present
+    - run: npm test

package/node_modules/audio-decode/.travis.yml

@@ -0,0 +1,13 @@
+sudo: false
+language: node_js
+node_js:
+  - 'node'
+  - '6'
+  - '5'
+  - '4'
+matrix:
+  fast_finish: true
+  allow_failures:
+    - node_js: "4"
+    - node_js: "5"
+

package/node_modules/audio-decode/audio-decode.d.ts

@@ -1,52 +1,14 @@
-export interface AudioData {
-  channelData: Float32Array[];
-  sampleRate: number;
-}
-
-export interface StreamDecoder {
-  /** Feed a chunk of encoded audio data, or call empty to flush + free. */
-  (chunk?: Uint8Array): Promise<AudioData>;
-  /** Flush without freeing. */
-  flush(): Promise<AudioData>;
-  /** Free resources without flushing. */
-  free(): void;
-}
+// audio-decode.d.ts
 
-type Format = 'mp3' | 'flac' | 'opus' | 'oga' | 'm4a' | 'wav' | 'qoa' | 'aac' | 'aiff' | 'caf' | 'webm' | 'amr' | 'wma';
+export default function audioDecode(buf: ArrayBuffer | Uint8Array): Promise<AudioBuffer>;
 
-interface FormatDecoder {
-  /** Create a decoder instance. */
-  (): Promise<StreamDecoder>;
+export interface Decoders {
+  oga: (buf: Uint8Array) => Promise<AudioBuffer>;
+  mp3: (buf: Uint8Array) => Promise<AudioBuffer>;
+  flac: (buf: Uint8Array) => Promise<AudioBuffer>;
+  opus: (buf: Uint8Array) => Promise<AudioBuffer>;
+  wav: (buf: Uint8Array) => Promise<AudioBuffer>;
+  qoa: (buf: Uint8Array) => Promise<AudioBuffer>;
 }
 
-/** Whole-file decode: auto-detects format. */
-declare function decode(buf: ArrayBuffer | Uint8Array): Promise<AudioData>;
-/** Chunked decode from stream or async iterable. */
-declare function decode(
-  source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,
-  format: Format
-): AsyncGenerator<AudioData>;
-
-declare namespace decode {
-  export const mp3: FormatDecoder;
-  export const flac: FormatDecoder;
-  export const opus: FormatDecoder;
-  export const oga: FormatDecoder;
-  export const m4a: FormatDecoder;
-  export const wav: FormatDecoder;
-  export const qoa: FormatDecoder;
-  export const aac: FormatDecoder;
-  export const aiff: FormatDecoder;
-  export const caf: FormatDecoder;
-  export const webm: FormatDecoder;
-  export const amr: FormatDecoder;
-  export const wma: FormatDecoder;
-}
-
-export default decode;
-
-/** Chunked decode from stream or async iterable. */
-export function decodeChunked(
-  source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,
-  format: Format
-): AsyncGenerator<AudioData>;
+export const decoders: Decoders;

package/node_modules/audio-decode/audio-decode.js

@@ -1,208 +1,92 @@
 /**
- * Audio decoder: whole-file, streaming, chunked
- * @module audio-decode
- *
- * let { channelData, sampleRate } = await decode(buf)
- *
- * for await (let pcm of decode.mp3(source)) { ... }
- *
- * let dec = await decode.mp3()
- * let { channelData, sampleRate } = await dec(chunk)
- * await dec() // close
+ * Web-Audio-API decoder
+ * @module  audio-decode
  */
 
 import getType from 'audio-type';
+import AudioBufferShim from 'audio-buffer';
 
-const EMPTY = Object.freeze({ channelData: Object.freeze([]), sampleRate: 0 })
+const AudioBuffer = globalThis.AudioBuffer || AudioBufferShim;
 
 /**
- * Decode audio.
- * 1 arg:  whole-file — auto-detects format, returns Promise<AudioData>
- * 2 args: chunked — streams from ReadableStream/AsyncIterable, returns AsyncGenerator<AudioData>
- */
-export default function decode(src, format) {
-	if (format) return decodeChunked(src, format)
-	return decodeWhole(src)
-}
-
-async function decodeWhole(src) {
-	if (!src || typeof src === 'string' || !(src.buffer || src.byteLength || src.length))
-		throw TypeError('Expected ArrayBuffer or Uint8Array')
-	let buf = new Uint8Array(src)
-
-	let type = getType(buf)
-	if (!type) throw Error('Unknown audio format')
-	if (!decode[type]) throw Error('No decoder for ' + type)
-
-	let dec = await decode[type]()
-	try {
-		let result = await dec(buf)
-		let flushed = await dec()
-		return merge(result, flushed)
-	} catch (e) { dec.free(); throw e }
-}
-
-/**
- * Decode a ReadableStream or async iterable of encoded audio chunks.
- * @param {ReadableStream|AsyncIterable} source
- * @param {string} format - codec name
- * @returns {AsyncGenerator<{channelData: Float32Array[], sampleRate: number}>}
+ * Decode an audio buffer.
+ *
+ * @param {ArrayBuffer | Uint8Array} buf - The audio data to decode.
+ * @returns {Promise<AudioBuffer>} A promise that resolves to the decoded audio buffer.
+ * @throws {Error} Throws an error if the decode target is invalid or if the audio format is not supported.
  */
-export async function* decodeChunked(source, format) {
-	if (!decode[format]) throw Error('No decoder for ' + format)
-	let dec = await decode[format]()
-	try {
-		if (source.getReader) {
-			let reader = source.getReader()
-			while (true) {
-				let { done, value } = await reader.read()
-				if (done) break
-				let result = await dec(value instanceof Uint8Array ? value : new Uint8Array(value))
-				if (result.channelData.length) yield result
-			}
-		} else {
-			for await (let chunk of source) {
-				let result = await dec(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk))
-				if (result.channelData.length) yield result
-			}
+export default async function audioDecode(buf) {
+	if (!buf && !(buf.length || buf.buffer)) throw Error('Bad decode target')
+	buf = new Uint8Array(buf.buffer || buf)
+
+	let type = getType(buf);
+
+	if (!type) throw Error('Cannot detect audio format');
+
+	if (!decoders[type]) throw Error('Missing decoder for ' + type + ' format')
+
+	return decoders[type](buf)
+};
+
+export const decoders = {
+	async oga(buf) {
+		let { decoder } = decoders.oga
+		if (!decoder) {
+			let { OggVorbisDecoder } = await import('@wasm-audio-decoders/ogg-vorbis')
+			await (decoders.oga.decoder = decoder = new OggVorbisDecoder()).ready;
+		} else await decoder.reset()
+		return buf && createBuffer(await decoder.decodeFile(buf))
+	},
+	async mp3(buf) {
+		let { decoder } = decoders.mp3
+		if (!decoder) {
+			const { MPEGDecoder } = await import('mpg123-decoder')
+			await (decoders.mp3.decoder = decoder = new MPEGDecoder()).ready;
 		}
-		let flushed = await dec()
-		if (flushed.channelData.length) yield flushed
-	} finally {
-		dec.free()
-	}
-}
-
-// --- format registration ---
-
-function reg(name, load) {
-	decode[name] = fmt(name, async () => {
-		let mod = await load()
-		// @audio/* packages export { decoder, default }
-		if (mod.decoder) {
-			let codec = await mod.decoder()
-			return streamDecoder(
-				chunk => codec.decode(chunk),
-				codec.flush ? () => codec.flush() : null,
-				codec.free ? () => codec.free() : null
-			)
+		else await decoder.reset()
+		return buf && createBuffer(await decoder.decode(buf))
+	},
+	async flac(buf) {
+		let { decoder } = decoders.flac
+		if (!decoder) {
+			const { FLACDecoder } = await import('@wasm-audio-decoders/flac')
+			await (decoders.flac.decoder = decoder = new FLACDecoder()).ready
 		}
-		// wasm-audio-decoders export class with .ready
-		let init = mod.default || mod
-		let codec = typeof init === 'function' ? await init() : init
-		if (codec.ready) await codec.ready
-		return streamDecoder(
-			chunk => codec.decode(chunk),
-			codec.flush ? () => codec.flush() : null,
-			codec.free ? () => codec.free() : null
-		)
-	})
-}
-
-function fmt(name, init) {
-	let fn = (src) => {
-		if (!src) return init()
-		// async iterable / ReadableStream → streaming decode
-		if (src[Symbol.asyncIterator] || src.getReader) return decodeChunked(src, name)
-		// buffer → whole-file decode
-		console.warn('decode.' + name + '(data) is deprecated, use decode(data)')
-		return (async () => {
-			let dec = await init()
-			try {
-				let result = await dec(src instanceof Uint8Array ? src : new Uint8Array(src.buffer || src))
-				let flushed = await dec()
-				return merge(result, flushed)
-			} catch (e) { dec.free(); throw e }
-		})()
-	}
-	return fn
-}
-
-// --- codecs ---
-
-reg('mp3', () => import('@audio/decode-mp3'))
-reg('flac', () => import('@audio/decode-flac'))
-reg('opus', () => import('@audio/decode-opus'))
-reg('oga', () => import('@audio/decode-vorbis'))
-
-reg('m4a', () => import('@audio/decode-aac'))
-
-reg('wav', () => import('@audio/decode-wav'))
-reg('qoa', () => import('@audio/decode-qoa'))
-
-reg('aac', () => import('@audio/decode-aac'))
-reg('aiff', () => import('@audio/decode-aiff'))
-reg('caf', () => import('@audio/decode-caf'))
-reg('webm', () => import('@audio/decode-webm'))
-reg('amr', () => import('@audio/decode-amr'))
-reg('wma', () => import('@audio/decode-wma'))
-
-/**
- * StreamDecoder — a callable function:
- * dec(chunk)  — decode data, returns { channelData, sampleRate }
- * dec()       — end of stream: flush remaining samples + free resources
- * dec.flush() — flush without freeing
- * dec.free()  — release resources without flushing
- */
-function streamDecoder(onDecode, onFlush, onFree) {
-	let done = false
-	let fn = async (chunk) => {
-		if (chunk) {
-			if (done) throw Error('Decoder already freed')
-			try { return norm(await onDecode(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk))) }
-			catch (e) { done = true; onFree?.(); throw e }
+		else await decoder.reset()
+		return buf && createBuffer(await decoder.decode(buf))
+	},
+	async opus(buf) {
+		let { decoder } = decoders.opus
+		if (!decoder) {
+			const { OggOpusDecoder } = await import('ogg-opus-decoder')
+			await (decoders.opus.decoder = decoder = new OggOpusDecoder()).ready
 		}
-		// null/undefined = end of stream
-		if (done) return EMPTY
-		done = true
-		try {
-			let result = onFlush ? norm(await onFlush()) : EMPTY
-			onFree?.()
-			return result
-		} catch (e) { onFree?.(); throw e }
-	}
-	fn.flush = async () => {
-		if (done) return EMPTY
-		return onFlush ? norm(await onFlush()) : EMPTY
-	}
-	fn.free = () => {
-		if (done) return
-		done = true
-		onFree?.()
-	}
-	return fn
-}
-
-// extract { channelData, sampleRate } from codec result
-function norm(r) {
-	if (!r?.channelData?.length) return EMPTY
-	let { channelData, sampleRate, samplesDecoded } = r
-	if (samplesDecoded != null && samplesDecoded < channelData[0].length)
-		channelData = channelData.map(ch => ch.subarray(0, samplesDecoded))
-	if (!channelData[0]?.length) return EMPTY
-	// collapse duplicate stereo to mono (some decoders always output 2ch for mono sources)
-	if (channelData.length === 2) {
-		let a = channelData[0], b = channelData[1], same = true
-		for (let i = 0; i < a.length; i += 37) { if (a[i] !== b[i]) { same = false; break } }
-		if (same) channelData = [a]
+		else await decoder.reset()
+		return buf && createBuffer(await decoder.decodeFile(buf))
+	},
+	async wav(buf) {
+		let { decode } = decoders.wav
+		if (!decode) {
+			let module = await import('node-wav')
+			decode = decoders.wav.decode = module.default.decode
+		}
+		return buf && createBuffer(await decode(buf))
+	},
+	async qoa(buf) {
+		let { decode } = decoders.qoa
+		if (!decode) {
+			decoders.qoa.decode = decode = (await import('qoa-format')).decode
+		}
+		return buf && createBuffer(await decode(buf))
 	}
-	return { channelData, sampleRate }
 }
 
-// merge two decode results
-function merge(a, b) {
-	if (!b?.channelData?.length) return a
-	if (!a?.channelData?.length) return b
-	let ach = a.channelData.length, bch = b.channelData.length
-	let ch = Math.max(ach, bch)
-	return {
-		channelData: Array.from({ length: ch }, (_, i) => {
-			let ac = a.channelData[i % ach], bc = b.channelData[i % bch]
-			let merged = new Float32Array(ac.length + bc.length)
-			merged.set(ac)
-			merged.set(bc, ac.length)
-			return merged
-		}),
-		sampleRate: a.sampleRate
-	}
+function createBuffer({ channelData, sampleRate }) {
+	let audioBuffer = new AudioBuffer({
+		sampleRate,
+		length: channelData[0].length,
+		numberOfChannels: channelData.length
+	})
+	for (let ch = 0; ch < channelData.length; ch++) audioBuffer.getChannelData(ch).set(channelData[ch])
+	return audioBuffer
 }

package/node_modules/audio-decode/package.json

@@ -1,77 +1,49 @@
 {
   "name": "audio-decode",
-  "version": "3.10.1",
+  "version": "2.2.3",
   "description": "Decode audio data in node or browser",
-  "type": "module",
-  "sideEffects": false,
   "main": "audio-decode.js",
+  "module": "audio-decode.js",
+  "browser": "audio-decode.js",
+  "type": "module",
   "types": "audio-decode.d.ts",
-  "exports": {
-    ".": {
-      "browser": "./audio-decode.js",
-      "node": "./audio-decode.js",
-      "default": "./audio-decode.js"
-    },
-    "./stream": "./stream.js",
-    "./meta": "./meta.js",
-    "./package.json": "./package.json"
-  },
-  "workspaces": [
-    "packages/*"
-  ],
   "dependencies": {
-    "@audio/decode-aac": "^1.0.2",
-    "@audio/decode-aiff": "^1.0.0",
-    "@audio/decode-amr": "^1.0.0",
-    "@audio/decode-caf": "^1.0.0",
-    "@audio/decode-flac": "^1.1.0",
-    "@audio/decode-mp3": "^1.1.0",
-    "@audio/decode-opus": "^1.0.0",
-    "@audio/decode-qoa": "^1.0.0",
-    "@audio/decode-vorbis": "^1.0.0",
-    "@audio/decode-wav": "^1.2.0",
-    "@audio/decode-webm": "^1.0.0",
-    "@audio/decode-wma": "^1.0.0",
-    "audio-type": "^2.4.0"
+    "@wasm-audio-decoders/flac": "^0.2.4",
+    "@wasm-audio-decoders/ogg-vorbis": "^0.1.15",
+    "audio-buffer": "^5.0.0",
+    "audio-type": "^2.2.1",
+    "mpg123-decoder": "^1.0.0",
+    "node-wav": "^0.0.2",
+    "ogg-opus-decoder": "^1.6.12",
+    "qoa-format": "^1.0.1"
   },
   "devDependencies": {
-    "audio-lena": "^3.0.0",
+    "audio-lena": "^2.3.0",
     "base64-arraybuffer": "^1.0.2",
-    "esbuild": "^0.28.0",
-    "playwright": "^1.58.0",
-    "tst": "^9.2.2"
+    "tst": "^7.3.0"
   },
   "scripts": {
-    "test": "node test.js",
-    "test:browser": "node test.browser.js",
-    "test:all": "node test.js && node test.browser.js",
-    "publish:all": "npm publish --workspaces && npm publish"
+    "test": "node test.js"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/audiojs/audio-decode.git"
   },
   "keywords": [
+    "audiojs",
     "audio",
+    "dsp",
     "decode",
-    "decoder",
+    "audio decode",
+    "audio decoder",
+    "web audio decoder",
     "codec",
     "mp3",
     "wav",
     "ogg",
     "vorbis",
     "opus",
-    "flac",
-    "aac",
-    "m4a",
-    "qoa",
-    "aiff",
-    "caf",
-    "webm",
-    "amr",
-    "wma",
-    "pcm",
-    "streaming"
+    "web-audio"
   ],
   "author": "ΔY <dfcreative@gmail.com>",
   "license": "MIT",