@openclaw/whatsapp 2026.9.5 → 2026.9.7

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

@@ -0,0 +1,124 @@
+/**
+ * E-AC-3 (Dolby Digital Plus) decoder — FFmpeg's `eac3` libavcodec decoder (LGPL-2.1-or-later)
+ * compiled to a single-file WASM ES module. The same decoder function also parses plain AC-3
+ * frames (bitstream_id <= 10 — see libavcodec/ac3dec.c parse_frame_header()), so this package
+ * decodes both raw AC-3 and E-AC-3 sync-frame streams (.ac3 / .ec3 / .eac3); container demuxers
+ * (@audio/decode-mp4, -webm, -avi) route their E-AC-3 tracks here.
+ *
+ * Sync-frame framing (syncword 0x0B77, frame size from ffmpeg's public av_ac3_parse_header —
+ * frmsiz for E-AC-3, the frmsizecod/fscod table for classic AC-3, see libavcodec/ac3_parser.c) is
+ * cut in JS, one packet per frame — same shape as @audio/decode-ac3. Output channels come out in
+ * WAV order already: ffmpeg's ac3 decoder builds a native (bitmask) AVChannelLayout, and native
+ * layouts order channels by ascending AV_CH_* bit value, which is WAV order (FL, FR, FC, LFE, BL,
+ * BR, …) — see src/eac3_glue.c. Dynamic range compression (drc_scale) is forced to 0 so output
+ * stays full-scale with no gain applied, matching @audio/decode-ac3 (liba52, no dialnorm/DRC).
+ *
+ * let { channelData, sampleRate } = await decode(eac3buf)
+ * let dec = await decoder(); let result = dec.decode(chunk)
+ */
+import createEac3 from './src/eac3.wasm.js'
+
+const EMPTY = Object.freeze({ channelData: [], sampleRate: 0 })
+const HEADER = 8          // bytes av_ac3_parse_header needs to read through channel_mode/lfe_on (7 for AC-3, less for E-AC-3) — see libavcodec/ac3_parser.c ff_ac3_parse_header
+const MAX_SAMPLES = 1536  // AC3_MAX_BLOCKS(6) * AC3_BLOCK_SIZE(256) — one sync frame, matches src/eac3_glue.c's output stride
+const MAX_LEFT = 65536    // partial-frame carry-over cap
+
+let modP
+function getMod() {
+	if (modP) return modP
+	let p = createEac3()
+	modP = p
+	return 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 merge(dec.decode(buf), dec.flush()) }
+	finally { dec.free() }
+}
+
+/** Create streaming decoder instance — decode() and flush() are synchronous. */
+export async function decoder() {
+	return new Eac3Decoder(await getMod())
+}
+
+class Eac3Decoder {
+	constructor(m) {
+		this.m = m
+		this.h = m._audio_eac3_create()
+		if (!this.h) throw Error('E-AC-3 decoder allocation failed')
+		this.ptr = 0; this.cap = 0
+		this.left = null
+		this.errors = 0
+		this.freed = false
+	}
+
+	decode(data) {
+		if (this.freed) throw Error('Decoder already freed')
+		if (!data || !data.byteLength) return EMPTY
+		let buf = data instanceof Uint8Array ? data : new Uint8Array(data)
+		if (this.left) { let j = new Uint8Array(this.left.length + buf.length); j.set(this.left); j.set(buf, this.left.length); buf = j; this.left = null }
+
+		let m = this.m, parts = [], pos = 0, sampleRate = 0, channels = 0
+		while (pos + HEADER <= buf.length) {
+			if (!(buf[pos] === 0x0B && buf[pos + 1] === 0x77)) { pos++; continue }
+			let ptr = this.alloc(HEADER)
+			m.HEAPU8.set(buf.subarray(pos, pos + HEADER), ptr)
+			let len = m._audio_eac3_syncinfo(ptr, HEADER)
+			if (!len) { pos++; continue }
+			if (pos + len > buf.length) break // partial frame — wait for more
+			ptr = this.alloc(len)
+			m.HEAPU8.set(buf.subarray(pos, pos + len), ptr)
+			let n = m._audio_eac3_decode(this.h, ptr, len)
+			pos += len
+			if (n < 0) { this.errors++; continue }
+			if (n > 0) {
+				let nch = m._audio_eac3_channels(this.h), out = m._audio_eac3_output(this.h) >> 2
+				sampleRate = m._audio_eac3_sample_rate(this.h)
+				channels = nch
+				parts.push(Array.from({ length: nch }, (_, c) => m.HEAPF32.slice(out + c * MAX_SAMPLES, out + c * MAX_SAMPLES + n)))
+			}
+		}
+		if (pos < buf.length) this.left = buf.length - pos <= MAX_LEFT ? buf.subarray(pos).slice() : null
+		if (!parts.length) return EMPTY
+		let total = parts.reduce((s, p) => s + p[0].length, 0)
+		let channelData = Array.from({ length: channels }, (_, c) => {
+			let o = new Float32Array(total), off = 0
+			for (let p of parts) { o.set(p[c], off); off += p[c].length }
+			return o
+		})
+		return { channelData, sampleRate }
+	}
+
+	flush() { this.left = null; return EMPTY }
+
+	free() {
+		if (this.freed) return
+		this.freed = true
+		this.m._audio_eac3_destroy(this.h); this.h = 0
+		if (this.ptr) this.m._free(this.ptr)
+		this.ptr = 0; this.cap = 0; this.left = null
+	}
+
+	alloc(len) {
+		if (len > this.cap) {
+			if (this.ptr) this.m._free(this.ptr)
+			this.cap = len
+			this.ptr = this.m._malloc(len)
+			if (!this.ptr) throw Error('E-AC-3: out of WASM memory')
+		}
+		return this.ptr
+	}
+}
+
+function merge(a, b) {
+	if (!b?.channelData?.length) return a
+	if (!a?.channelData?.length) return b
+	return { channelData: a.channelData.map((ch, i) => { let m = new Float32Array(ch.length + b.channelData[i].length); m.set(ch); m.set(b.channelData[i], ch.length); return m }), sampleRate: a.sampleRate }
+}

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

@@ -0,0 +1,68 @@
+{
+  "name": "@audio/decode-eac3",
+  "version": "1.0.0",
+  "description": "Decode E-AC-3 (Dolby Digital Plus) and AC-3 with FFmpeg's eac3 decoder, WASM",
+  "type": "module",
+  "main": "decode-eac3.js",
+  "types": "decode-eac3.d.ts",
+  "exports": {
+    ".": "./decode-eac3.js",
+    "./audio": {
+      "types": "./audio.d.ts",
+      "default": "./audio.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bash build.sh",
+    "prepack": "npm run build",
+    "test": "node test.js"
+  },
+  "files": [
+    "decode-eac3.js",
+    "decode-eac3.d.ts",
+    "src/eac3.wasm.js",
+    "audio.js",
+    "audio.d.ts",
+    "LICENSE",
+    "LICENSE.ffmpeg"
+  ],
+  "devDependencies": {
+    "tst": "^9.2.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "eac3",
+    "e-ac-3",
+    "ac3",
+    "ac-3",
+    "dolby digital plus",
+    "dolby",
+    "surround",
+    "5.1",
+    "7.1",
+    "audio",
+    "decode",
+    "decoder",
+    "wasm",
+    "ffmpeg",
+    "libavcodec"
+  ],
+  "license": "LGPL-2.1-or-later",
+  "author": "audiojs",
+  "homepage": "https://github.com/audiojs/decode/tree/main/packages/decode-eac3",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/decode.git",
+    "directory": "packages/decode-eac3"
+  },
+  "bugs": "https://github.com/audiojs/decode/issues",
+  "audio": "./audio.js",
+  "sideEffects": false,
+  "funding": "https://github.com/sponsors/audiojs"
+}

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

@@ -0,0 +1,25 @@
+This work is offered to Krishna (https://github.com/krishnized/license).
+
+---
+
+The MIT License (MIT)
+
+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/node_modules/@audio/decode-flac/README.md

@@ -0,0 +1,23 @@
+# @audio/decode-flac
+
+Decode raw FLAC and Ogg FLAC audio with [@wasm-audio-decoders/flac](https://github.com/eshaz/wasm-audio-decoders).
+
+```js
+import decode, { decoder } from '@audio/decode-flac'
+
+let { channelData, sampleRate } = await decode(flacBytes)
+
+let dec = await decoder() // initialize WASM
+let a = dec.decode(chunk1)
+let b = dec.decode(chunk2)
+let tail = dec.flush()
+dec.free()
+```
+
+`decoder()` initializes asynchronously. `decode()` and `flush()` are synchronous.
+`decode()` accepts consecutive raw FLAC and complete Ogg FLAC files. Raw FLAC may omit
+the STREAMINFO sample total. For chunked input, `flush()` ends the decoder.
+
+## License
+
+[ॐ](https://github.com/krishnized/license/) · [MIT](./LICENSE)

package/node_modules/audio-decode/node_modules/@audio/decode-flac/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 'flac' — extends audio()'s openable formats / save() targets */
+export declare const flac: {
+  codec: 'flac'
+  decode(bytes: Uint8Array): { channelData: Float32Array[], sampleRate: number } | Promise<{ channelData: Float32Array[], sampleRate: number }>
+}

package/node_modules/audio-decode/node_modules/@audio/decode-flac/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-flac) by format
+// name. Format detection is magic-byte (audio-type) — no test() needed here.
+
+import decodeFn from './decode-flac.js'
+
+export const flac = {
+	codec: 'flac',
+	decode: (bytes) => decodeFn(bytes),
+}

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

@@ -0,0 +1,18 @@
+export interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
+
+interface FlacDecoder {
+  /** Decode a chunk synchronously. */
+  decode(data: Uint8Array | ArrayBuffer): AudioData;
+  /** Finish chunked input synchronously. This ends the decoder. */
+  flush(): AudioData;
+  free(): void;
+}
+
+/** Decode a complete FLAC file. */
+export default function decode(src: ArrayBuffer | Uint8Array): Promise<AudioData>;
+
+/** Initialize WASM and create a decoder with synchronous methods. */
+export function decoder(): Promise<FlacDecoder>;