@openclaw/whatsapp 2026.9.6 → 2026.9.7

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

@@ -0,0 +1,80 @@
+# @audio/decode-aac
+
+Decode AAC/M4A and ALAC audio to PCM float samples. FAAD2 WASM handles AAC; a pure-JS port of Apple's reference decoder handles ALAC. The M4A sample entry selects the codec.
+
+## Install
+
+```
+npm i @audio/decode-aac
+```
+
+## Usage
+
+```js
+import decode from '@audio/decode-aac'
+
+// M4A or raw ADTS; auto-detected
+let { channelData, sampleRate } = await decode(uint8array)
+// channelData: Float32Array[] (one per channel)
+// sampleRate: number
+```
+
+### Streaming
+
+```js
+import { decoder } from '@audio/decode-aac'
+
+let dec = await decoder()
+let { channelData, sampleRate } = dec.decode(chunk)
+dec.free()
+```
+
+`decoder()` is asynchronous. Its `decode()` and `flush()` methods are synchronous.
+
+## API
+
+### `decode(src: Uint8Array | ArrayBuffer): Promise<AudioData>`
+
+Whole-file decode. Auto-detects M4A (MP4 container) vs raw ADTS.
+
+### `decoder(opts?): Promise<AACDecoder>`
+
+Creates a decoder instance for manual control.
+
+- `dec.decode(data)`: decode a `Uint8Array` or `ArrayBuffer` chunk.
+- `dec.flush()`: discard buffered partial data and return an empty result.
+- `dec.free()`: release WASM memory.
+
+Without options the byte stream is auto-detected (M4A or ADTS). Container demuxers that hold the codec config out-of-band pass it up-front and feed raw access units — one frame, or an array of frames, per `decode()` call:
+
+```js
+let dec = await decoder({ asc })   // AudioSpecificConfig (esds, Matroska CodecPrivate, WAVEFORMATEX extra bytes)
+let dec = await decoder({ alac })  // ALAC magic cookie
+```
+
+This is how [@audio/decode-mp4](../decode-mp4), [@audio/decode-webm](../decode-webm) and [@audio/decode-avi](../decode-avi) decode AAC and ALAC tracks from video files.
+
+### `AudioData`
+
+```ts
+{ channelData: Float32Array[], sampleRate: number }
+```
+
+## Formats
+
+- M4A / MP4 / MOV with AAC audio (LC and HE-AAC v1/v2 with SBR or PS) — QuickTime sound descriptions v0, v1 and v2
+- M4A / MP4 with bit-exact pure-JS ALAC decoding at 16, 20, 24, or 32 bits
+- Raw ADTS streams (.aac)
+
+## Metadata
+
+```js
+import { parseMeta } from '@audio/decode-aac/meta'
+
+let { meta, sampleRate } = parseMeta(m4aBytes)
+// meta: { title, artist, album, year, genre, track, ..., pictures }
+```
+
+## License
+
+[ॐ](https://github.com/krishnized/license/) · AAC decoding [GPL-2.0](./LICENSE) (FAAD2), ALAC decoding Apache-2.0 (port of Apple's ALAC reference)

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

@@ -0,0 +1,326 @@
+/**
+ * ALAC (Apple Lossless) decoder — pure JS.
+ * Ported from Apple's ALAC reference decoder (Apache License 2.0):
+ *   ALACDecoder.cpp, ag_dec.c, dp_dec.c, matrix_dec.c, ALACBitUtilities.c
+ *   Copyright (c) 2011 Apple Inc. https://github.com/macosforge/alac
+ *
+ * createALAC(cookie) → { config, decodeFrame(frameBytes) → { channelData: Float32Array[], numSamples } }
+ */
+
+// ── constants (aglib.h) ──────────────────────────────────────────────
+const QBSHIFT = 9, QB = 1 << QBSHIFT
+const MMULSHIFT = 2, MDENSHIFT = QBSHIFT - MMULSHIFT - 1, MOFF = 1 << (MDENSHIFT - 2)
+const BITOFF = 24
+const MAX_PREFIX_16 = 9, MAX_PREFIX_32 = 9, MAX_DATATYPE_BITS_16 = 16
+const N_MAX_MEAN_CLAMP = 0xffff, N_MEAN_CLAMP_VAL = 0xffff
+// MPEG element ids (ALACBitUtilities.h)
+const ID_SCE = 0, ID_CPE = 1, ID_LFE = 3, ID_DSE = 4, ID_FIL = 6, ID_END = 7
+
+// ── bit reader (ALACBitUtilities.c) ──────────────────────────────────
+// pos = absolute bit index into data; data is padded with 8 trailing zeros so
+// 32-bit window reads near the end are always in-bounds.
+function bits(data, realLen) { return { data, pos: 0, realLen } }
+function read(bb, n) { // BitBufferRead — up to 16 bits, MSB first
+  let p = bb.pos, o = p >> 3, d = bb.data
+  let v = (((d[o] << 16) | (d[o + 1] << 8) | d[o + 2]) << (p & 7)) & 0xFFFFFF
+  bb.pos = p + n
+  return v >>> (24 - n)
+}
+function readOne(bb) { let p = bb.pos; bb.pos = p + 1; return (bb.data[p >> 3] >> (7 - (p & 7))) & 1 }
+function byteAlign(bb) { bb.pos = (bb.pos + 7) & ~7 }
+function read32(d, o) { return (((d[o] << 24) | (d[o + 1] << 16) | (d[o + 2] << 8) | d[o + 3]) >>> 0) }
+
+function getstreambits(d, bitoffset, numbits) {
+  let byteoffset = bitoffset >>> 3
+  let load1 = read32(d, byteoffset), result
+  if ((numbits + (bitoffset & 7)) > 32) {
+    result = (load1 << (bitoffset & 7)) >>> 0
+    let load2 = d[byteoffset + 4]
+    load2 = load2 >>> (8 - (numbits + (bitoffset & 7) - 32))
+    result = result >>> (32 - numbits)
+    result = (result | load2) >>> 0
+  } else {
+    result = load1 >>> (32 - numbits - (bitoffset & 7))
+  }
+  if (numbits !== 32) result = (result & (((1 << numbits) >>> 0) - 1)) >>> 0
+  return result >>> 0
+}
+
+// ── adaptive Golomb decode (ag_dec.c) ────────────────────────────────
+function lg3a(x) { return 31 - Math.clz32(x + 3) }
+
+// st = { p } carries the local bit position
+function dynGet32(d, st, m, k, maxbits) {
+  let tempbits = st.p
+  let streamlong = (read32(d, tempbits >> 3) << (tempbits & 7)) >>> 0
+  let result = Math.clz32((~streamlong) >>> 0)
+  if (result >= MAX_PREFIX_32) {
+    result = getstreambits(d, tempbits + MAX_PREFIX_32, maxbits)
+    tempbits += MAX_PREFIX_32 + maxbits
+  } else {
+    tempbits += result + 1
+    if (k !== 1) {
+      streamlong = (streamlong << (result + 1)) >>> 0
+      let v = streamlong >>> (32 - k)
+      tempbits += k - 1
+      result = Math.imul(result, m)
+      if (v >= 2) { result += v - 1; tempbits += 1 }
+    }
+  }
+  st.p = tempbits
+  return result
+}
+
+function dynGet(d, st, m, k) {
+  let tempbits = st.p
+  let streamlong = (read32(d, tempbits >> 3) << (tempbits & 7)) >>> 0
+  let pre = Math.clz32((~streamlong) >>> 0), result
+  if (pre >= MAX_PREFIX_16) {
+    pre = MAX_PREFIX_16
+    tempbits += pre
+    streamlong = (streamlong << pre) >>> 0
+    result = streamlong >>> (32 - MAX_DATATYPE_BITS_16)
+    tempbits += MAX_DATATYPE_BITS_16
+  } else {
+    tempbits += pre + 1
+    streamlong = (streamlong << (pre + 1)) >>> 0
+    let v = streamlong >>> (32 - k)
+    tempbits += k
+    result = Math.imul(pre, m) + v - 1
+    if (v < 2) { result -= (v - 1); tempbits -= 1 }
+  }
+  st.p = tempbits
+  return result
+}
+
+// fills pc[0..numSamples) with residuals; advances bb.pos
+function dynDecomp(p, bb, pc, numSamples, maxSize) {
+  let d = bb.data, st = { p: bb.pos }, maxPos = bb.realLen * 8
+  let mb = p.mb0, pb = p.pb, kb = p.kb, wb = p.wb
+  let zmode = 0, c = 0, o = 0
+  while (c < numSamples) {
+    if (st.p >= maxPos) throw Error('ALAC: ran past frame')
+    let m = mb >>> QBSHIFT
+    let k = Math.min(lg3a(m), kb)
+    m = (1 << k) - 1
+    let n = dynGet32(d, st, m, k, maxSize)
+    let ndecode = n + zmode
+    let mult = (-(ndecode & 1)) | 1
+    pc[o++] = ((ndecode + 1) >> 1) * mult
+    c++
+    mb = pb * (n + zmode) + mb - ((pb * mb) >> QBSHIFT)
+    if (n > N_MAX_MEAN_CLAMP) mb = N_MEAN_CLAMP_VAL
+    zmode = 0
+    if (((mb << MMULSHIFT) < QB) && (c < numSamples)) {
+      zmode = 1
+      k = Math.clz32(mb) - BITOFF + ((mb + MOFF) >> MDENSHIFT)
+      let mz = ((1 << k) - 1) & wb
+      n = dynGet(d, st, mz, k)
+      if (c + n > numSamples) throw Error('ALAC: zero-run overflow')
+      for (let j = 0; j < n; j++) { pc[o++] = 0; c++ }
+      if (n >= 65535) zmode = 0
+      mb = 0
+    }
+  }
+  bb.pos = st.p
+}
+
+// ── dynamic predictor (dp_dec.c) ─────────────────────────────────────
+function signOf(i) { return (((-i) >>> 31) | (i >> 31)) }
+
+function unpcBlock(pc1, out, num, coefs, numactive, chanbits, denshift) {
+  let chanshift = 32 - chanbits, denhalf = 1 << (denshift - 1)
+  out[0] = pc1[0]
+  if (numactive === 0) { for (let i = 1; i < num; i++) out[i] = pc1[i]; return }
+  if (numactive === 31) {
+    let prev = out[0]
+    for (let j = 1; j < num; j++) { let del = pc1[j] + prev; prev = (del << chanshift) >> chanshift; out[j] = prev }
+    return
+  }
+  for (let j = 1; j <= numactive; j++) { let del = pc1[j] + out[j - 1]; out[j] = (del << chanshift) >> chanshift }
+  let lim = numactive + 1
+  for (let j = lim; j < num; j++) {
+    let sum1 = 0, pb = j - 1, top = out[j - lim]
+    for (let kk = 0; kk < numactive; kk++) sum1 = (sum1 + Math.imul(coefs[kk], out[pb - kk] - top)) | 0
+    let del = pc1[j], del0 = del, sg = signOf(del)
+    del = (del + top + ((sum1 + denhalf) >> denshift)) | 0
+    out[j] = (del << chanshift) >> chanshift
+    if (sg > 0) {
+      for (let kk = numactive - 1; kk >= 0; kk--) {
+        let dd = top - out[pb - kk], sgn = signOf(dd)
+        coefs[kk] -= sgn
+        del0 -= Math.imul(numactive - kk, (Math.imul(sgn, dd) >> denshift))
+        if (del0 <= 0) break
+      }
+    } else if (sg < 0) {
+      for (let kk = numactive - 1; kk >= 0; kk--) {
+        let dd = top - out[pb - kk], sgn = signOf(dd)
+        coefs[kk] += sgn
+        del0 -= Math.imul(numactive - kk, (Math.imul(-sgn, dd) >> denshift))
+        if (del0 >= 0) break
+      }
+    }
+  }
+}
+
+// ── magic cookie (ALACSpecificConfig) ────────────────────────────────
+function parseConfig(c) {
+  let u32 = (o) => (c[o] * 0x1000000) + (c[o + 1] << 16) + (c[o + 2] << 8) + c[o + 3]
+  return {
+    frameLength: u32(0), bitDepth: c[5], pb: c[6], mb: c[7], kb: c[8],
+    numChannels: c[9], maxRun: (c[10] << 8) | c[11],
+    sampleRate: u32(20),
+  }
+}
+
+export function createALAC(cookie) {
+  let cfg = parseConfig(cookie)
+  let N = cfg.frameLength
+  let mixU = new Int32Array(N), mixV = new Int32Array(N), pred = new Int32Array(N)
+  let shiftBuf = new Int32Array(N * 2)
+  let scale = 1 / Math.pow(2, cfg.bitDepth - 1)
+
+  function agParams(pbFactor) {
+    let pb = ((cfg.pb * pbFactor) / 4) | 0
+    return { mb0: cfg.mb, pb, kb: cfg.kb, wb: (1 << cfg.kb) - 1 }
+  }
+
+  // decode one ALAC frame → per-channel Int32 samples; returns numSamples
+  function decodeElements(bb, chans, requested) {
+    let chanIndex = 0, numSamples = requested
+    while (true) {
+      if (bb.pos >> 3 >= bb.realLen) break
+      let tag = read(bb, 3)
+      if (tag === ID_SCE || tag === ID_LFE) {
+        read(bb, 4) // element instance tag
+        if (read(bb, 12) !== 0) throw Error('ALAC: bad header')
+        let hb = read(bb, 4)
+        let partial = hb >> 3, bytesShifted = (hb >> 1) & 3, escape = hb & 1
+        if (bytesShifted === 3) throw Error('ALAC: bad shift')
+        let shift = bytesShifted * 8
+        let chanBits = cfg.bitDepth - shift
+        if (partial) numSamples = ((read(bb, 16) << 16) | read(bb, 16)) >>> 0
+        if (!escape) {
+          read(bb, 8); read(bb, 8) // mixBits, mixRes (unused for mono)
+          let hu = read(bb, 8), modeU = hu >> 4, denShiftU = hu & 0xf
+          let pu = read(bb, 8), pbFactorU = pu >> 5, numU = pu & 0x1f
+          let coefsU = new Int16Array(32)
+          for (let i = 0; i < numU; i++) coefsU[i] = read(bb, 16)
+          let shiftPos = bb.pos
+          if (bytesShifted) bb.pos += shift * numSamples
+          dynDecomp(agParams(pbFactorU), bb, pred, numSamples, chanBits)
+          if (modeU === 0) unpcBlock(pred, mixU, numSamples, coefsU, numU, chanBits, denShiftU)
+          else { unpcBlock(pred, pred, numSamples, null, 31, chanBits, 0); unpcBlock(pred, mixU, numSamples, coefsU, numU, chanBits, denShiftU) }
+          readShift(bb, shiftPos, shift, numSamples, 1)
+        } else {
+          let s = 32 - chanBits
+          if (chanBits <= 16) {
+            for (let i = 0; i < numSamples; i++) mixU[i] = (read(bb, chanBits) << s) >> s
+          } else {
+            let extra = chanBits - 16
+            for (let i = 0; i < numSamples; i++) { let v = (read(bb, 16) << 16) >> s; mixU[i] = v | read(bb, extra) }
+          }
+          bytesShifted = 0
+        }
+        let out = new Int32Array(numSamples)
+        for (let i = 0; i < numSamples; i++) out[i] = bytesShifted ? ((mixU[i] << shift) | shiftBuf[i]) : mixU[i]
+        chans[chanIndex++] = out
+      } else if (tag === ID_CPE) {
+        read(bb, 4)
+        if (read(bb, 12) !== 0) throw Error('ALAC: bad header')
+        let hb = read(bb, 4)
+        let partial = hb >> 3, bytesShifted = (hb >> 1) & 3, escape = hb & 1
+        if (bytesShifted === 3) throw Error('ALAC: bad shift')
+        let shift = bytesShifted * 8
+        let chanBits = cfg.bitDepth - shift + 1
+        if (partial) numSamples = ((read(bb, 16) << 16) | read(bb, 16)) >>> 0
+        let mixBits = 0, mixRes = 0
+        if (!escape) {
+          mixBits = read(bb, 8); mixRes = (read(bb, 8) << 24) >> 24 // int8
+          let hu = read(bb, 8), modeU = hu >> 4, denShiftU = hu & 0xf
+          let pu = read(bb, 8), pbFactorU = pu >> 5, numU = pu & 0x1f
+          let coefsU = new Int16Array(32)
+          for (let i = 0; i < numU; i++) coefsU[i] = read(bb, 16)
+          let hv = read(bb, 8), modeV = hv >> 4, denShiftV = hv & 0xf
+          let pv = read(bb, 8), pbFactorV = pv >> 5, numV = pv & 0x1f
+          let coefsV = new Int16Array(32)
+          for (let i = 0; i < numV; i++) coefsV[i] = read(bb, 16)
+          let shiftPos = bb.pos
+          if (bytesShifted) bb.pos += shift * 2 * numSamples
+          dynDecomp(agParams(pbFactorU), bb, pred, numSamples, chanBits)
+          if (modeU === 0) unpcBlock(pred, mixU, numSamples, coefsU, numU, chanBits, denShiftU)
+          else { unpcBlock(pred, pred, numSamples, null, 31, chanBits, 0); unpcBlock(pred, mixU, numSamples, coefsU, numU, chanBits, denShiftU) }
+          dynDecomp(agParams(pbFactorV), bb, pred, numSamples, chanBits)
+          if (modeV === 0) unpcBlock(pred, mixV, numSamples, coefsV, numV, chanBits, denShiftV)
+          else { unpcBlock(pred, pred, numSamples, null, 31, chanBits, 0); unpcBlock(pred, mixV, numSamples, coefsV, numV, chanBits, denShiftV) }
+          readShift(bb, shiftPos, shift, numSamples, 2)
+        } else {
+          chanBits = cfg.bitDepth
+          let s = 32 - chanBits
+          if (chanBits <= 16) {
+            for (let i = 0; i < numSamples; i++) {
+              mixU[i] = (read(bb, chanBits) << s) >> s
+              mixV[i] = (read(bb, chanBits) << s) >> s
+            }
+          } else {
+            let extra = chanBits - 16
+            for (let i = 0; i < numSamples; i++) {
+              let v = (read(bb, 16) << 16) >> s; mixU[i] = v | read(bb, extra)
+              let w = (read(bb, 16) << 16) >> s; mixV[i] = w | read(bb, extra)
+            }
+          }
+          bytesShifted = 0
+        }
+        // un-mix
+        let l = new Int32Array(numSamples), r = new Int32Array(numSamples)
+        for (let j = 0; j < numSamples; j++) {
+          let a, b
+          if (mixRes !== 0) { a = mixU[j] + mixV[j] - ((mixRes * mixV[j]) >> mixBits); b = a - mixV[j] }
+          else { a = mixU[j]; b = mixV[j] }
+          if (bytesShifted) { a = (a << shift) | shiftBuf[2 * j]; b = (b << shift) | shiftBuf[2 * j + 1] }
+          l[j] = a; r[j] = b
+        }
+        chans[chanIndex++] = l; chans[chanIndex++] = r
+      } else if (tag === ID_DSE) { skipDSE(bb) }
+      else if (tag === ID_FIL) { skipFIL(bb) }
+      else if (tag === ID_END) { byteAlign(bb); break }
+      else throw Error('ALAC: unsupported element ' + tag)
+      if (chanIndex >= chans.length) break
+    }
+    return numSamples
+  }
+
+  function readShift(bb, shiftPos, shift, numSamples, nch) {
+    if (!shift) return
+    let sb = { data: bb.data, pos: shiftPos, realLen: bb.realLen }
+    let count = numSamples * nch
+    for (let i = 0; i < count; i++) shiftBuf[i] = read(sb, shift)
+  }
+
+  function skipFIL(bb) { let count = read(bb, 4); if (count === 15) count += read(bb, 8) - 1; bb.pos += count * 8 }
+  function skipDSE(bb) {
+    read(bb, 4); let align = readOne(bb)
+    let count = read(bb, 8); if (count === 255) count += read(bb, 8)
+    if (align) byteAlign(bb)
+    bb.pos += count * 8
+  }
+
+  return {
+    config: cfg,
+    decodeFrame(frame) {
+      let data = new Uint8Array(frame.length + 8)
+      data.set(frame)
+      let bb = bits(data, frame.length)
+      let chans = new Array(cfg.numChannels)
+      let numSamples = decodeElements(bb, chans, cfg.frameLength)
+      let channelData = []
+      for (let c = 0; c < cfg.numChannels; c++) {
+        let src = chans[c] || new Int32Array(numSamples)
+        let f = new Float32Array(numSamples)
+        for (let i = 0; i < numSamples; i++) f[i] = src[i] * scale
+        channelData.push(f)
+      }
+      return { channelData, numSamples }
+    },
+  }
+}

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

@@ -0,0 +1,15 @@
+// Generated from the audio.js manifest (params metadata is the source of truth).
+// Regenerate: node tools/dts.js in @audio/compile. Do not edit by hand.
+
+/** Automatable number — scalar, `t => value` fn, or breakpoint curve {t, v} */
+type Auto = number | ((t: number) => number) | { t: number[], v: number[] }
+/** Per-block param values as delivered by hosts (numbers arrive as 1-length Float32Array) */
+type Live = Record<string, Float32Array | string | boolean>
+type Ctx = { sampleRate: number, maxBlockSize: number, maxChannels: number, currentTime: number, duration?: number, events?: readonly any[], emit?: (name: string, ...args: any[]) => void, [k: string]: unknown }
+type Process = (inputs: Float32Array[][], outputs: Float32Array[][], params: Live) => void
+
+/** Codec plugin 'aac' — extends audio()'s openable formats / save() targets */
+export declare const aac: {
+  codec: 'aac'
+  decode(bytes: Uint8Array): { channelData: Float32Array[], sampleRate: number } | Promise<{ channelData: Float32Array[], sampleRate: number }>
+}

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

@@ -0,0 +1,10 @@
+// audio.js manifest — codec atom, decode half: whole-buffer bytes → { channelData,
+// sampleRate }. Hosts merge with the encode half (@audio/encode-aac) by format
+// name. Format detection is magic-byte (audio-type) — no test() needed here.
+
+import decodeFn from './decode-aac.js'
+
+export const aac = {
+	codec: 'aac',
+	decode: (bytes) => decodeFn(bytes),
+}

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

@@ -0,0 +1,24 @@
+export interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
+
+interface AACDecoder {
+  /** Byte stream (M4A/ADTS), or with `asc`/`alac` options: one raw access unit or an array of them */
+  decode(data: Uint8Array | ArrayBuffer | Uint8Array[]): AudioData;
+  flush(): AudioData;
+  free(): void;
+}
+
+/** Whole-file decode — auto-detects M4A vs ADTS */
+export default function decode(src: ArrayBuffer | Uint8Array): Promise<AudioData>;
+
+export interface RawOptions {
+  /** AudioSpecificConfig — decode raw AAC access units from a container demuxer */
+  asc?: Uint8Array;
+  /** ALAC magic cookie (24-byte ALACSpecificConfig, `alac` box body, or full atom) — decode raw ALAC frames */
+  alac?: Uint8Array;
+}
+
+/** Create streaming decoder instance. Auto-detects M4A vs ADTS, or decodes raw frames when a config is given. */
+export function decoder(opts?: RawOptions): Promise<AACDecoder>;