@openclaw/whatsapp 2026.5.30-beta.1 → 2026.5.31-beta.2

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

@@ -0,0 +1,391 @@
+/**
+ * AAC decoder — FAAD2 compiled to WASM
+ * Decodes M4A (MP4/AAC) and raw ADTS streams
+ *
+ * let { channelData, sampleRate } = await decode(m4abuf)
+ */
+
+let _modP
+
+async function getMod() {
+	if (_modP) return _modP
+	let p = (async () => {
+		let createAAC
+		if (typeof process !== 'undefined' && process.versions?.node) {
+			let m = 'module'
+			let { createRequire } = await import(m)
+			createAAC = createRequire(import.meta.url)('./src/aac.wasm.cjs')
+		} else {
+			let mod = await import('./src/aac.wasm.cjs')
+			createAAC = mod.default || mod
+		}
+		return createAAC()
+	})()
+	_modP = p
+	try { return await p }
+	catch (e) { _modP = null; throw e }
+}
+
+/**
+ * Whole-file decode
+ * @param {Uint8Array|ArrayBuffer} src
+ * @returns {Promise<{channelData: Float32Array[], sampleRate: number}>}
+ */
+export default async function decode(src) {
+	let buf = src instanceof Uint8Array ? src : new Uint8Array(src)
+	let dec = await decoder()
+	try {
+		return dec.decode(buf)
+	} finally {
+		dec.free()
+	}
+}
+
+/**
+ * Create decoder instance
+ * @returns {Promise<{decode(chunk: Uint8Array): {channelData, sampleRate}, flush(), free()}>}
+ */
+export async function decoder() {
+	return new AACDecoder(await getMod())
+}
+
+const EMPTY = Object.freeze({ channelData: [], sampleRate: 0 })
+
+class AACDecoder {
+	constructor(mod) {
+		this.m = mod
+		this.h = null
+		this.sr = 0
+		this.ch = 0
+		this.done = false
+		this._ptr = 0
+		this._cap = 0
+		this._left = null
+		this._fileOff = 0     // absolute file offset of _left[0] (M4A streaming)
+		this._skip = 0        // bytes to discard from incoming data (M4A streaming, when next frame is past _left)
+		this._m4a = null      // M4A streaming iterator: { sizes, stco, stsc, idx, ci, sInC, spc, nextOff }
+		this._accum = null    // Uint8Array[] — M4A header accumulator
+		this._accumLen = 0
+	}
+
+	decode(data) {
+		if (this.done) throw Error('Decoder already freed')
+		if (!data?.length) return EMPTY
+
+		let buf = data instanceof Uint8Array ? data : new Uint8Array(data)
+
+		if (this._m4a) return this._feedM4AData(buf)
+		if (this.h) return this._decodeADTS(buf)
+		// M4A: accumulating moov+mdat header, or first chunk starts with ftyp
+		if (this._accum || (buf.length > 8 && buf[4] === 0x66 && buf[5] === 0x74 && buf[6] === 0x79 && buf[7] === 0x70)) {
+			(this._accum ??= []).push(buf)
+			this._accumLen += buf.length
+			return this._tryM4AInit()
+		}
+		return this._decodeADTS(buf)
+	}
+
+	flush() {
+		this._left = null
+		return EMPTY
+	}
+
+	free() {
+		if (this.done) return
+		this.done = true
+		if (this.h) {
+			this.m._aac_close(this.h)
+			this.m._aac_free_buf()
+			this.h = null
+		}
+		if (this._ptr) {
+			this.m._free(this._ptr)
+			this._ptr = 0
+			this._cap = 0
+		}
+		this._accum = null; this._accumLen = 0
+		this._m4a = null; this._left = null
+		this._fileOff = 0; this._skip = 0
+	}
+
+	_catAccum() {
+		if (this._accum.length === 1) return this._accum[0]
+		let buf = new Uint8Array(this._accumLen), off = 0
+		for (let c of this._accum) { buf.set(c, off); off += c.length }
+		return buf
+	}
+
+	_tryM4AInit() {
+		let buf = this._catAccum()
+		let asc = null, stsz = null, stco = null, stsc = null
+
+		parseBoxes(buf, 0, buf.length, (type, data) => {
+			if (type === 'esds') asc = parseEsds(data)
+			else if (type === 'stsz') stsz = parseStsz(data)
+			else if (type === 'stco') stco = parseStco(data)
+			else if (type === 'co64') stco = parseCo64(data)
+			else if (type === 'stsc') stsc = parseStsc(data)
+		})
+
+		if (!asc || !stsz || !stco?.length) return EMPTY // moov/tables not ready
+
+		// Init WASM decoder with ASC
+		let m = this.m, h = m._aac_create()
+		let srP = m._aac_sr_ptr(), chP = m._aac_ch_ptr()
+		let ptr = this._alloc(asc.length)
+		m.HEAPU8.set(asc, ptr)
+		let err = m._aac_init2(h, ptr, asc.length, srP, chP)
+		if (err < 0) { m._aac_close(h); throw Error('M4A init failed (code ' + err + ')') }
+		this.sr = m.getValue(srP, 'i32')
+		this.ch = m.getValue(chP, 'i8')
+		if (!this.ch) { m._aac_close(h); throw Error('M4A init: no channels in ASC') }
+		this.h = h
+
+		// Streaming: walk sample tables by absolute file offset so chunk boundaries are irrelevant.
+		this._accum = null; this._accumLen = 0
+		this._m4a = { sizes: stsz, stco, stsc, idx: 0, ci: 0, sInC: 0, spc: spcAt(0, stsc), nextOff: stco[0] }
+		this._left = buf
+		this._fileOff = 0
+		this._skip = 0
+		return this._extractM4A()
+	}
+
+	_feedM4AData(buf) {
+		if (this._skip > 0) {
+			let n = Math.min(this._skip, buf.length)
+			this._skip -= n
+			this._fileOff += n
+			buf = buf.subarray(n)
+			if (!buf.length) return EMPTY
+		}
+		this._left = append(this._left, buf)
+		return this._extractM4A()
+	}
+
+	_extractM4A() {
+		let st = this._m4a, frames = []
+		while (st.idx < st.sizes.length) {
+			let off = st.nextOff, sz = st.sizes[st.idx]
+			let bufOff = off - this._fileOff
+			if (bufOff + sz > this._left.length) break
+			if (bufOff >= 0) frames.push(this._left.subarray(bufOff, bufOff + sz))
+			advanceM4A(st)
+		}
+
+		if (st.idx < st.sizes.length) {
+			let nextOff = st.nextOff, end = this._fileOff + this._left.length
+			if (nextOff >= end) {
+				this._skip = nextOff - end
+				this._fileOff = end
+				this._left = null
+			} else if (nextOff > this._fileOff) {
+				this._left = this._left.subarray(nextOff - this._fileOff).slice()
+				this._fileOff = nextOff
+			}
+		} else {
+			this._left = null
+		}
+
+		return frames.length ? this._feedFrames(frames) : EMPTY
+	}
+
+	_alloc(len) {
+		if (len > this._cap) {
+			if (this._ptr) this.m._free(this._ptr)
+			this._cap = len
+			this._ptr = this.m._malloc(len)
+		}
+		return this._ptr
+	}
+
+	_decodeADTS(buf) {
+		let m = this.m
+
+		if (this._left) { buf = append(this._left, buf); this._left = null }
+
+		if (!this.h) {
+			if (buf.length < 7) { this._left = buf.slice(); return EMPTY }
+			let h = m._aac_create()
+			let srP = m._aac_sr_ptr(), chP = m._aac_ch_ptr()
+			let ptr = this._alloc(buf.length)
+			m.HEAPU8.set(buf, ptr)
+			let consumed = m._aac_init(h, ptr, buf.length, srP, chP)
+			if (consumed < 0) { m._aac_close(h); throw Error('ADTS init failed (code ' + consumed + ')') }
+			this.sr = m.getValue(srP, 'i32')
+			this.ch = m.getValue(chP, 'i8')
+			if (!this.ch) {
+				// not enough data to detect channels — buffer for next call
+				m._aac_close(h)
+				this._left = buf.length < 8192 ? buf.slice() : null
+				return EMPTY
+			}
+			this.h = h
+			buf = buf.subarray(consumed)
+		}
+
+		// extract complete ADTS frames only — never feed partial data to FAAD2
+		let frames = [], pos = 0
+		while (pos + 6 < buf.length) {
+			if (buf[pos] !== 0xFF || (buf[pos + 1] & 0xF6) !== 0xF0) { pos++; continue }
+			let flen = ((buf[pos + 3] & 0x03) << 11) | (buf[pos + 4] << 3) | (buf[pos + 5] >> 5)
+			if (flen < 7 || pos + flen > buf.length) break
+			frames.push(buf.subarray(pos, pos + flen))
+			pos += flen
+		}
+
+		if (pos < buf.length) {
+			let left = buf.subarray(pos)
+			this._left = left.length < 8192 ? left.slice() : null
+		}
+
+		if (!frames.length) return EMPTY
+		return this._feedFrames(frames)
+	}
+
+	_feedFrames(frames) {
+		let m = this.m, h = this.h
+		let chunks = [], totalPerCh = 0, channels = this.ch, errors = 0
+
+		for (let frame of frames) {
+			let ptr = this._alloc(frame.length)
+			m.HEAPU8.set(frame, ptr)
+			let out = m._aac_decode(h, ptr, frame.length)
+			if (!out) { errors++; continue }
+
+			let n = m._aac_samples()
+			let sr = m._aac_samplerate()
+			if (sr) this.sr = sr
+			let ch = m._aac_channels()
+			if (ch) channels = ch
+
+			let spc = n / channels
+			chunks.push({ data: new Float32Array(m.HEAPF32.buffer, out, n).slice(), ch: channels, spc })
+			totalPerCh += spc
+		}
+
+		if (!totalPerCh) return EMPTY
+
+		let channelData = Array.from({ length: channels }, () => new Float32Array(totalPerCh))
+		let pos = 0
+		for (let { data, ch, spc } of chunks) {
+			for (let c = 0; c < ch; c++) {
+				let out = channelData[c]
+				for (let s = 0; s < spc; s++) out[pos + s] = data[s * ch + c]
+			}
+			pos += spc
+		}
+
+		return { channelData, sampleRate: this.sr, errors }
+	}
+}
+
+
+// ===== M4A demuxer =====
+
+function append(left, buf) {
+	if (!left?.length) return buf.slice()
+	let merged = new Uint8Array(left.length + buf.length)
+	merged.set(left); merged.set(buf, left.length)
+	return merged
+}
+
+const CONTAINERS = new Set(['moov', 'trak', 'mdia', 'minf', 'stbl', 'udta', 'meta', 'edts', 'sinf'])
+
+function parseBoxes(buf, start, end, cb) {
+	let off = start
+	while (off < end - 8) {
+		let size = r32(buf, off)
+		let type = String.fromCharCode(buf[off + 4], buf[off + 5], buf[off + 6], buf[off + 7])
+
+		if (size === 0) size = end - off
+		else if (size === 1 && off + 16 <= end) {
+			size = r32(buf, off + 12)
+			if (size < 16) break
+		} else if (size < 8) break
+
+		// skip mdat fast — the raw frames don't interest us here
+		if (type === 'mdat') { off += size; continue }
+		// truncated non-mdat box: tables would be garbage — wait for more data
+		if (off + size > end) break
+
+		let bodyOff = off + 8
+		if (type === 'stsd') parseSampleDesc(buf, bodyOff, size - 8, cb)
+		else if (CONTAINERS.has(type)) parseBoxes(buf, bodyOff + (type === 'meta' ? 4 : 0), off + size, cb)
+		else cb(type, buf.subarray(bodyOff, off + size))
+
+		off += size
+	}
+}
+
+function parseSampleDesc(buf, off, len, cb) {
+	let entries = r32(buf, off + 4), pos = off + 8
+	for (let i = 0; i < entries && pos < off + len; i++) {
+		let eSize = r32(buf, pos)
+		let eType = String.fromCharCode(buf[pos + 4], buf[pos + 5], buf[pos + 6], buf[pos + 7])
+		if (eType === 'mp4a' && eSize > 36) parseBoxes(buf, pos + 36, pos + eSize, cb)
+		pos += eSize
+	}
+}
+
+function parseEsds(data) {
+	let off = 4
+	while (off < data.length - 2) {
+		let tag = data[off++], len = 0, b
+		do { b = data[off++]; len = (len << 7) | (b & 0x7f) } while (b & 0x80 && off < data.length)
+		if (tag === 0x03) off += 3
+		else if (tag === 0x04) off += 13
+		else if (tag === 0x05) return data.subarray(off, off + len)
+		else off += len
+	}
+	return null
+}
+
+function parseStsz(data) {
+	let sz = r32(data, 4), n = r32(data, 8)
+	if (sz) return Array(n).fill(sz)
+	let sizes = new Array(n)
+	for (let i = 0; i < n; i++) sizes[i] = r32(data, 12 + i * 4)
+	return sizes
+}
+
+function parseStco(data) {
+	let n = r32(data, 4), o = new Array(n)
+	for (let i = 0; i < n; i++) o[i] = r32(data, 8 + i * 4)
+	return o
+}
+
+function parseCo64(data) {
+	let n = r32(data, 4), o = new Array(n)
+	for (let i = 0; i < n; i++) o[i] = r32(data, 8 + i * 8 + 4)
+	return o
+}
+
+function parseStsc(data) {
+	let n = r32(data, 4), e = new Array(n)
+	for (let i = 0; i < n; i++) e[i] = { first: r32(data, 8 + i * 12), spc: r32(data, 12 + i * 12) }
+	return e
+}
+
+function spcAt(ci, stsc) {
+	if (!stsc?.length) return 1
+	let spc = 1, cn = ci + 1
+	for (let j = stsc.length - 1; j >= 0; j--)
+		if (cn >= stsc[j].first) { spc = stsc[j].spc; break }
+	return spc
+}
+
+function advanceM4A(st) {
+	st.nextOff += st.sizes[st.idx]
+	st.idx++
+	st.sInC++
+	if (st.sInC >= st.spc && st.ci + 1 < st.stco.length) {
+		st.ci++
+		st.sInC = 0
+		st.spc = spcAt(st.ci, st.stsc)
+		st.nextOff = st.stco[st.ci]
+	}
+}
+
+function r32(buf, off) {
+	return (buf[off] << 24 | buf[off + 1] << 16 | buf[off + 2] << 8 | buf[off + 3]) >>> 0
+}

package/node_modules/@audio/decode-aac/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@audio/decode-aac",
+  "version": "1.1.3",
+  "description": "Decode AAC/M4A audio via FAAD2 WASM",
+  "type": "module",
+  "main": "decode-aac.js",
+  "types": "decode-aac.d.ts",
+  "exports": {
+    ".": "./decode-aac.js",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bash build.sh",
+    "prepack": "npm run build",
+    "test": "node test.js"
+  },
+  "files": [
+    "decode-aac.js",
+    "decode-aac.d.ts",
+    "src/aac.wasm.cjs",
+    "LICENSE"
+  ],
+  "keywords": [
+    "aac",
+    "m4a",
+    "mp4",
+    "audio",
+    "decode",
+    "decoder",
+    "wasm",
+    "faad2"
+  ],
+  "license": "GPL-2.0",
+  "author": "audiojs",
+  "homepage": "https://github.com/audiojs/decode-aac#readme",
+  "bugs": "https://github.com/audiojs/decode-aac/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/decode-aac.git"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}

package/node_modules/@audio/decode-aiff/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 audiojs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@audio/decode-aiff/README.md

@@ -0,0 +1,53 @@
+# @audio/decode-aiff
+
+Decode AIFF and AIFF-C audio to PCM float samples.<br>
+Part of [audio-decode](https://github.com/audiojs/audio-decode).
+
+## Install
+
+```
+npm i @audio/decode-aiff
+```
+
+## Usage
+
+```js
+import decode from '@audio/decode-aiff'
+
+let { channelData, sampleRate } = await decode(aiffBuffer)
+// channelData: Float32Array[] (one per channel)
+// sampleRate: number
+```
+
+### Streaming
+
+```js
+import { decoder } from '@audio/decode-aiff'
+
+let dec = await decoder()
+let result = dec.decode(chunk)
+dec.free()
+```
+
+## API
+
+### `decode(src): Promise<AudioData>`
+
+Whole-file decode. Accepts `Uint8Array` or `ArrayBuffer`.
+
+### `decoder(): Promise<AIFFDecoder>`
+
+Creates a decoder instance.
+
+- **`dec.decode(data)`** — decode chunk, returns `{ channelData, sampleRate }`
+- **`dec.flush()`** — flush (returns empty — AIFF is stateless)
+- **`dec.free()`** — release resources
+
+## Formats
+
+- AIFF — 8, 16, 24, 32-bit signed integer PCM (big-endian)
+- AIFF-C — `NONE`/`twos` (BE PCM), `sowt` (LE PCM), `fl32`/`fl64` (float), `alaw`, `ulaw`
+
+## License
+
+MIT — [krishnized](https://github.com/krishnized/license)

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

@@ -0,0 +1,16 @@
+interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
+
+interface AIFFDecoder {
+  decode(data: Uint8Array): AudioData;
+  flush(): AudioData;
+  free(): void;
+}
+
+/** Decode AIFF/AIFF-C audio buffer to PCM samples */
+export default function decode(src: ArrayBuffer | Uint8Array): Promise<AudioData>;
+
+/** Create decoder instance */
+export function decoder(): Promise<AIFFDecoder>;