@openclaw/whatsapp 2026.5.28 → 2026.5.31-beta.1

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

@@ -0,0 +1,190 @@
+/**
+ * CAF (Core Audio Format) decoder
+ * Decodes CAF containers with lpcm, alaw, ulaw audio to Float32 PCM
+ *
+ * let { channelData, sampleRate } = await decode(cafbuf)
+ */
+
+const EMPTY = Object.freeze({ channelData: [], sampleRate: 0 })
+
+/**
+ * Whole-file decode
+ * @param {Uint8Array|ArrayBuffer} src
+ * @returns {Promise<{channelData: Float32Array[], sampleRate: number}>}
+ */
+export default async function decode(src) {
+	let dec = await decoder()
+	try { return dec.decode(src) }
+	finally { dec.free() }
+}
+
+/**
+ * Create decoder instance (streaming-aware)
+ * @returns {Promise<{decode(chunk: Uint8Array): {channelData, sampleRate}, flush(), free()}>}
+ */
+export async function decoder() {
+	let hdr = null, left = null, freed = false
+	return {
+		decode(data) {
+			if (freed) throw Error('Decoder already freed')
+			if (!data || !data.byteLength) return EMPTY
+			let chunk = data instanceof Uint8Array ? data : new Uint8Array(data)
+			if (left) { chunk = catB(left, chunk); left = null }
+			if (!hdr) {
+				hdr = scanCafHdr(chunk)
+				if (!hdr) { left = chunk.slice(); return EMPTY }
+				chunk = chunk.subarray(hdr.dataStart)
+			}
+			let fb = hdr.frameBytes
+			let complete = Math.floor(chunk.length / fb) * fb
+			if (!complete) { if (chunk.length) left = chunk.slice(); return EMPTY }
+			if (chunk.length > complete) left = chunk.subarray(complete).slice()
+			return decodeCafRaw(chunk.subarray(0, complete), hdr)
+		},
+		flush() { left = null; return EMPTY },
+		free() { freed = true; left = null; hdr = null },
+	}
+}
+
+function catB(a, b) {
+	let r = new Uint8Array(a.length + b.length)
+	r.set(a); r.set(b, a.length)
+	return r
+}
+
+function scanCafHdr(buf) {
+	if (buf.length < 8) return null
+	if (buf[0] !== 0x63 || buf[1] !== 0x61 || buf[2] !== 0x66 || buf[3] !== 0x66) throw Error('Not a CAF file')
+	let dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+	if (dv.getUint16(4, false) !== 1) throw Error('Unsupported CAF version')
+	let off = 8, desc = null
+	while (off + 12 <= buf.length) {
+		let type = String.fromCharCode(buf[off], buf[off + 1], buf[off + 2], buf[off + 3])
+		let sizeHi = dv.getUint32(off + 4, false), sizeLo = dv.getUint32(off + 8, false)
+		let size = sizeHi * 0x100000000 + sizeLo
+		off += 12
+		if (type === 'desc') {
+			if (off + 32 > buf.length) return null
+			desc = {
+				sampleRate: dv.getFloat64(off, false),
+				formatID: String.fromCharCode(buf[off + 8], buf[off + 9], buf[off + 10], buf[off + 11]),
+				formatFlags: dv.getUint32(off + 12, false),
+				bytesPerPacket: dv.getUint32(off + 16, false),
+				framesPerPacket: dv.getUint32(off + 20, false),
+				channelsPerFrame: dv.getUint32(off + 24, false),
+				bitsPerChannel: dv.getUint32(off + 28, false),
+			}
+		} else if (type === 'data') {
+			if (!desc) return null
+			let dataStart = off + 4 // skip editCount
+			if (dataStart > buf.length) return null
+			let { formatID, formatFlags, channelsPerFrame: ch, bitsPerChannel: bits } = desc
+			let bytesPerSample = bits >> 3
+			let frameBytes
+			if (formatID === 'alaw' || formatID === 'ulaw') frameBytes = ch
+			else frameBytes = ch * bytesPerSample
+			if (!frameBytes) return null
+			return { ...desc, dataStart, frameBytes }
+		}
+		if (size < 0) break
+		if (sizeHi === 0xFFFFFFFF && sizeLo === 0xFFFFFFFF) break
+		off += size
+	}
+	return null
+}
+
+function decodeCafRaw(raw, hdr) {
+	let { sampleRate, formatID, formatFlags, channelsPerFrame: ch, bitsPerChannel: bits, frameBytes } = hdr
+	let frames = Math.floor(raw.length / frameBytes)
+	if (!frames) return EMPTY
+	let samples
+	if (formatID === 'lpcm') samples = decodeLPCM(raw, formatFlags, bits, ch)
+	else if (formatID === 'alaw') samples = decodeAlaw(raw, ch)
+	else if (formatID === 'ulaw') samples = decodeUlaw(raw, ch)
+	else throw Error('CAF: unsupported format ' + formatID)
+	return { channelData: samples, sampleRate }
+}
+
+function decodeLPCM(data, flags, bits, ch) {
+	let isFloat = flags & 1, isLE = flags & 2
+	let bytesPerSample = bits >> 3
+	let totalSamples = (data.length / bytesPerSample) | 0
+	let framesCount = (totalSamples / ch) | 0
+	if (!framesCount) return []
+
+	let dv = new DataView(data.buffer, data.byteOffset, data.byteLength)
+	let channelData = Array.from({ length: ch }, () => new Float32Array(framesCount))
+
+	if (isFloat && bits === 32) {
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off += 4)
+				channelData[c][i] = dv.getFloat32(off, !!isLE)
+	} else if (isFloat && bits === 64) {
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off += 8)
+				channelData[c][i] = dv.getFloat64(off, !!isLE)
+	} else if (bits === 32) {
+		let norm = 1 / 2147483648
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off += 4)
+				channelData[c][i] = dv.getInt32(off, !!isLE) * norm
+	} else if (bits === 24) {
+		let norm = 1 / 8388608
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off += 3) {
+				let s
+				if (!isLE) s = (data[off] << 16) | (data[off + 1] << 8) | data[off + 2]
+				else s = data[off] | (data[off + 1] << 8) | (data[off + 2] << 16)
+				if (s & 0x800000) s |= ~0xFFFFFF
+				channelData[c][i] = s * norm
+			}
+	} else if (bits === 16) {
+		let norm = 1 / 32768
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off += 2)
+				channelData[c][i] = dv.getInt16(off, !!isLE) * norm
+	} else if (bits === 8) {
+		let norm = 1 / 128
+		for (let i = 0, off = 0; i < framesCount; i++)
+			for (let c = 0; c < ch; c++, off++)
+				channelData[c][i] = dv.getInt8(off) * norm
+	} else {
+		throw Error('CAF: unsupported LPCM bit depth ' + bits)
+	}
+
+	return channelData
+}
+
+function alawDecode(val) {
+	val ^= 0x55
+	let sign = val & 0x80, seg = (val >> 4) & 7, quant = val & 0x0F
+	let sample = seg ? ((quant << 1) | 0x21) << (seg - 1) : (quant << 1) | 1
+	return (sign ? -sample : sample) / 32768
+}
+
+function ulawDecode(val) {
+	val = ~val & 0xFF
+	let sign = val & 0x80, exp = (val >> 4) & 7, mant = val & 0x0F
+	let sample = ((mant << 1) | 0x21) << exp
+	return (sign ? -(sample - 33) : (sample - 33)) / 32768
+}
+
+function decodeAlaw(data, ch) {
+	let framesCount = (data.length / ch) | 0
+	if (!framesCount) return []
+	let channelData = Array.from({ length: ch }, () => new Float32Array(framesCount))
+	for (let i = 0, off = 0; i < framesCount; i++)
+		for (let c = 0; c < ch; c++, off++)
+			channelData[c][i] = alawDecode(data[off])
+	return channelData
+}
+
+function decodeUlaw(data, ch) {
+	let framesCount = (data.length / ch) | 0
+	if (!framesCount) return []
+	let channelData = Array.from({ length: ch }, () => new Float32Array(framesCount))
+	for (let i = 0, off = 0; i < framesCount; i++)
+		for (let c = 0; c < ch; c++, off++)
+			channelData[c][i] = ulawDecode(data[off])
+	return channelData
+}

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

@@ -0,0 +1,43 @@
+{
+  "name": "@audio/decode-caf",
+  "version": "1.1.1",
+  "description": "Decode CAF (Core Audio Format) audio to PCM samples",
+  "type": "module",
+  "main": "decode-caf.js",
+  "types": "decode-caf.d.ts",
+  "exports": {
+    ".": "./decode-caf.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "decode-caf.js",
+    "decode-caf.d.ts",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "caf",
+    "core-audio",
+    "apple",
+    "audio",
+    "decode",
+    "decoder",
+    "pcm"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "audiojs",
+  "homepage": "https://github.com/audiojs/decode-caf#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/decode-caf.git"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "bugs": "https://github.com/audiojs/decode-caf/issues"
+}

package/node_modules/{audio-buffer → @audio/decode-flac}/LICENSE

@@ -1,6 +1,10 @@
+This work is offered to Krishna (https://github.com/krishnized/license).
+
+---
+
 The MIT License (MIT)
-Copyright (c) 2018 Dmitry Yvanov <df.creative@gmail.com>
 
+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
@@ -19,4 +23,3 @@ 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-flac/README.md

@@ -0,0 +1,23 @@
+# @audio/decode-flac
+
+Decode FLAC audio to PCM samples. Self-contained WASM bundle — no import map entries needed.
+
+Wraps [@wasm-audio-decoders/flac](https://github.com/eshaz/wasm-audio-decoders).
+
+```js
+import decode, { decoder } from '@audio/decode-flac'
+
+// whole-file
+let { channelData, sampleRate } = await decode(flacbuf)
+
+// streaming
+let dec = await decoder()
+let a = dec.decode(chunk1)
+let b = dec.decode(chunk2)
+let c = dec.flush()
+dec.free()
+```
+
+## License
+
+[MIT](./LICENSE) · [ॐ](https://github.com/krishnized/license/)

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

@@ -0,0 +1,16 @@
+interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
+
+interface FlacDecoder {
+  decode(data: Uint8Array): AudioData;
+  flush(): AudioData;
+  free(): void;
+}
+
+/** Whole-file FLAC decode */
+export default function decode(src: ArrayBuffer | Uint8Array): Promise<AudioData>;
+
+/** Create streaming decoder instance */
+export function decoder(): Promise<FlacDecoder>;