@openclaw/whatsapp 2026.9.5 → 2026.9.7

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

@@ -0,0 +1,20 @@
+export interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
+
+interface MpcDecoder {
+  /** Decode a chunk of an SV7 (`MP+`) or SV8 (`MPCK`) Musepack stream synchronously. Returns whatever full frames the data seen so far allows; call again as more bytes arrive. */
+  decode(data: Uint8Array | ArrayBuffer): AudioData;
+  /** Signal end of stream: decode any frames a safety margin was withholding. */
+  flush(): AudioData;
+  free(): void;
+  /** Frames that failed to decode (bitstream desync — stops the decoder) */
+  errors: number;
+}
+
+/** Decode a complete Musepack (SV7 or SV8) stream. Throws if the stream never parses as Musepack. */
+export default function decode(src: ArrayBuffer | Uint8Array): Promise<AudioData>;
+
+/** Initialize WASM and create a decoder with synchronous methods. */
+export function decoder(): Promise<MpcDecoder>;

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

@@ -0,0 +1,158 @@
+/**
+ * Musepack (MPC) decoder — libmpcdec compiled to WASM (single-file ES module, host-neutral).
+ * Decodes SV7 (`MP+`) and SV8 (`MPCK`) streams, container demuxing included (APEv2/ID3v1
+ * tags and seek tables are parsed and skipped; not surfaced).
+ *
+ * let { channelData, sampleRate } = await decode(mpcBytes)
+ *
+ * let dec = await decoder()
+ * let head = dec.decode(chunk1)   // synchronous; returns audio decoded from data seen so far
+ * let tail = dec.flush()
+ * dec.free()
+ *
+ * Streaming: SV7 needs only its ~30-byte fixed header before frames start decoding as bytes
+ * arrive. SV8 keeps its seek table near the end of the stream (mpcenc can only patch the
+ * header's pointer to it after encoding, once the final offset is known) and libmpcdec reads
+ * that table during mpc_demux_init() — so an SV8 decoder only starts producing samples once
+ * (near) the whole stream has been fed. Either way decode(chunk) never blocks: it returns
+ * whatever it can given the bytes seen so far and picks up where it left off on the next call.
+ */
+import createMpc from './src/mpc.wasm.js'
+
+const EMPTY = Object.freeze({ channelData: [], sampleRate: 0 })
+// libmpcdec/internal.h MAX_FRAME_SIZE: worst-case compressed frame size. mpc_demux_decode()
+// has no way to signal "not enough data yet" separately from "end of stream", and a failed
+// frame decode leaves the demuxer's bit position permanently desynced (no retry). Keeping
+// this many bytes buffered ahead of the reader's cursor before decoding a frame guarantees
+// the reader is never asked for a short read except at genuine end of stream.
+const SAFE_MARGIN = 4352
+
+let modP
+function getMod() {
+	if (modP) return modP
+	let p = createMpc()
+	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)
+	if (!buf.length) return EMPTY
+	let dec = await decoder()
+	try {
+		let head = dec.decode(buf)
+		let tail = dec.flush()
+		if (!dec.inited) throw Error('Not a valid Musepack (MPC) stream')
+		return merge(head, tail)
+	} finally { dec.free() }
+}
+
+/** Create streaming decoder instance — decode() and flush() are synchronous. */
+export async function decoder() {
+	return new MpcDecoder(await getMod())
+}
+
+class MpcDecoder {
+	constructor(m) {
+		this.m = m
+		this.h = m._audio_mpc_create()
+		if (!this.h) throw Error('MPC decoder allocation failed')
+		this.inited = false
+		this.failed = false
+		this.done = false
+		this.channels = 0
+		this.sampleRate = 0
+		this.errors = 0
+		this.ptr = 0; this.cap = 0
+		this.freed = false
+	}
+
+	decode(data) {
+		if (this.freed) throw Error('Decoder already freed')
+		if (this.failed) throw Error('Not a valid Musepack (MPC) stream')
+		if (!data || !data.byteLength) return EMPTY
+		let buf = data instanceof Uint8Array ? data : new Uint8Array(data)
+		let m = this.m
+		let ptr = this.alloc(buf.length)
+		m.HEAPU8.set(buf, ptr)
+		if (m._audio_mpc_feed(this.h, ptr, buf.length) < 0) throw Error('MPC: out of WASM memory')
+
+		if (!this.inited) {
+			let r = m._audio_mpc_init(this.h)
+			if (r < 0) { this.failed = true; throw Error('Not a valid Musepack (MPC) stream') }
+			if (r === 0) return EMPTY // header incomplete — retry once more bytes arrive
+			this.inited = true
+			this.channels = m._audio_mpc_channels(this.h)
+			this.sampleRate = m._audio_mpc_sample_rate(this.h)
+		}
+		return this.drain(false)
+	}
+
+	/** Drop the streaming state (see class doc); at real end of stream this decodes any frames the safety margin was withholding. */
+	flush() {
+		if (this.freed) throw Error('Decoder already freed')
+		if (this.failed) throw Error('Not a valid Musepack (MPC) stream')
+		if (!this.inited) {
+			let r = this.m._audio_mpc_init(this.h) // one last attempt now that no more data is coming
+			if (r < 0) { this.failed = true; throw Error('Not a valid Musepack (MPC) stream') }
+			if (r === 0) return EMPTY // stream ended before a header could be parsed
+			this.inited = true
+			this.channels = this.m._audio_mpc_channels(this.h)
+			this.sampleRate = this.m._audio_mpc_sample_rate(this.h)
+		}
+		return this.drain(true)
+	}
+
+	drain(final) {
+		if (this.done) return EMPTY
+		let m = this.m, parts = [], ch = this.channels
+		for (; ;) {
+			if (!final && m._audio_mpc_avail(this.h) < SAFE_MARGIN) break
+			let n = m._audio_mpc_decode(this.h)
+			if (n <= 0) { this.done = true; if (n < 0) this.errors++; break }
+			let out = m._audio_mpc_output(this.h) >> 2
+			parts.push(Array.from({ length: ch }, (_, c) => {
+				let a = new Float32Array(n)
+				for (let i = 0; i < n; i++) a[i] = m.HEAPF32[out + i * ch + c]
+				return a
+			}))
+		}
+		if (!parts.length) return EMPTY
+		let total = parts.reduce((s, p) => s + p[0].length, 0)
+		let channelData = Array.from({ length: ch }, (_, 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: this.sampleRate }
+	}
+
+	free() {
+		if (this.freed) return
+		this.freed = true
+		this.m._audio_mpc_destroy(this.h); this.h = 0
+		if (this.ptr) this.m._free(this.ptr)
+		this.ptr = 0; this.cap = 0
+	}
+
+	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('MPC: 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-mpc/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@audio/decode-mpc",
+  "version": "1.0.0",
+  "description": "Decode Musepack (MPC, SV7 and SV8) audio with libmpcdec WASM",
+  "type": "module",
+  "main": "decode-mpc.js",
+  "types": "decode-mpc.d.ts",
+  "exports": {
+    ".": "./decode-mpc.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-mpc.js",
+    "decode-mpc.d.ts",
+    "src/mpc.wasm.js",
+    "audio.js",
+    "audio.d.ts",
+    "LICENSE",
+    "LICENSE.libmpcdec"
+  ],
+  "devDependencies": {
+    "tst": "^9.2.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mpc",
+    "musepack",
+    "mp+",
+    "mpck",
+    "sv7",
+    "sv8",
+    "audio",
+    "decode",
+    "decoder",
+    "wasm",
+    "libmpcdec"
+  ],
+  "license": "BSD-3-Clause",
+  "author": "audiojs",
+  "homepage": "https://github.com/audiojs/decode/tree/main/packages/decode-mpc",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/decode.git",
+    "directory": "packages/decode-mpc"
+  },
+  "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-opus/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-opus/LICENSE.libopus

@@ -0,0 +1,44 @@
+Copyright 2001-2023 Xiph.Org, Skype Limited, Octasic,
+                    Jean-Marc Valin, Timothy B. Terriberry,
+                    CSIRO, Gregory Maxwell, Mark Borgerding,
+                    Erik de Castro Lopo, Mozilla, Amazon
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+- Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+- Neither the name of Internet Society, IETF or IETF Trust, nor the
+names of specific contributors, may be used to endorse or promote
+products derived from this software without specific prior written
+permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Opus is subject to the royalty-free patent licenses which are
+specified at:
+
+Xiph.Org Foundation:
+https://datatracker.ietf.org/ipr/1524/
+
+Microsoft Corporation:
+https://datatracker.ietf.org/ipr/1914/
+
+Broadcom Corporation:
+https://datatracker.ietf.org/ipr/1526/

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

@@ -0,0 +1,32 @@
+# @audio/decode-opus
+
+Decode Ogg Opus audio to PCM samples with libopus WASM.
+
+```js
+import decode, { decoder } from '@audio/decode-opus'
+
+let { channelData, sampleRate } = await decode(opusBytes)
+
+let dec = await decoder() // initialize WASM
+let a = dec.decode(chunk1)
+let b = dec.decode(chunk2)
+let tail = dec.flush()
+dec.free()
+```
+
+`decoder()` is asynchronous. Its `decode()` and `flush()` methods are synchronous. `flush()` ends the stream.
+
+## Metadata
+
+Read OpusTags metadata and cover art without decoding audio:
+
+```js
+import { parseMeta } from '@audio/decode-opus/meta'
+
+let { meta, sampleRate } = parseMeta(opusBytes)
+// meta: { title, artist, album, year, genre, ..., pictures }
+```
+
+## License
+
+[ॐ](https://github.com/krishnized/license/) · [MIT](./LICENSE). Bundled [libopus](https://opus-codec.org/) is [BSD 3-Clause](./LICENSE.libopus).

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

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

package/node_modules/audio-decode/node_modules/@audio/decode-opus/core.d.ts

@@ -0,0 +1,33 @@
+export interface OpusOptions {
+  sampleRate?: 8000 | 12000 | 16000 | 24000 | 48000;
+  channels: number;
+  streamCount?: number;
+  coupledStreamCount?: number;
+  channelMappingTable?: number[] | Uint8Array;
+  preSkip?: number;
+  outputGain?: number;
+}
+
+export interface DecodedOpus {
+  errors: Array<{
+    message: string;
+    frameLength: number;
+    frameNumber: number;
+    inputBytes: number;
+    outputSamples: number;
+  }>;
+  channelData: Float32Array[];
+  samplesDecoded: number;
+  sampleRate: number;
+  bitDepth: 32;
+}
+
+export interface OpusPacketDecoder {
+  configure(options: OpusOptions): void;
+  decodeFrames(frames: Uint8Array[]): DecodedOpus;
+  unconfigure(): void;
+  free(): void;
+}
+
+/** Initialize libopus WASM without configuring a stream. */
+export function createOpusDecoder(): Promise<OpusPacketDecoder>;

package/node_modules/audio-decode/node_modules/@audio/decode-opus/core.js

@@ -0,0 +1,147 @@
+import createOpus from './src/opus.wasm.js'
+
+const ERRORS = new Map([
+	[-1, 'OPUS_BAD_ARG'],
+	[-2, 'OPUS_BUFFER_TOO_SMALL'],
+	[-3, 'OPUS_INTERNAL_ERROR'],
+	[-4, 'OPUS_INVALID_PACKET'],
+	[-5, 'OPUS_UNIMPLEMENTED'],
+	[-6, 'OPUS_INVALID_STATE'],
+	[-7, 'OPUS_ALLOC_FAIL']
+])
+
+let modulePromise
+
+async function getModule() {
+	if (modulePromise) return modulePromise
+	let promise = createOpus()
+	modulePromise = promise
+	try { return await promise }
+	catch (error) { modulePromise = null; throw error }
+}
+
+export async function createOpusDecoder() {
+	return new OpusDecoder(await getModule())
+}
+
+class OpusDecoder {
+	constructor(module) {
+		this.module = module
+		this.handle = 0
+		this.input = 0
+		this.capacity = 0
+		this.channels = 0
+		this.sampleRate = 0
+		this.frameNumber = 0
+		this.inputBytes = 0
+		this.outputSamples = 0
+		this.freed = false
+	}
+
+	configure(options) {
+		if (this.freed) throw Error('Decoder already freed')
+		let sampleRate = options.sampleRate ?? 48000
+		let channels = options.channels
+		if (![8000, 12000, 16000, 24000, 48000].includes(sampleRate)) throw RangeError('Invalid Opus sample rate')
+		if (!Number.isInteger(channels) || channels < 1 || channels > 255) throw RangeError('Invalid Opus channel count')
+
+		let streams = options.streamCount ?? 1
+		let coupled = options.coupledStreamCount ?? (channels === 2 ? 1 : 0)
+		if (!Number.isInteger(streams) || streams < 1 || streams > 255 ||
+			!Number.isInteger(coupled) || coupled < 0 || coupled > streams || streams + coupled > 255)
+			throw RangeError('Invalid Opus stream layout')
+
+		let mapping = options.channelMappingTable ?? (channels === 1 ? [0] : channels === 2 ? [0, 1] : null)
+		if (!mapping || mapping.length !== channels) throw Error('Invalid Opus channel mapping')
+		mapping = Array.from(mapping)
+		let codedChannels = streams + coupled
+		if (mapping.some(value => !Number.isInteger(value) || value < 0 || value > 255 || (value >= codedChannels && value !== 255)))
+			throw Error('Invalid Opus channel mapping')
+
+		let preSkip = options.preSkip ?? 0
+		let outputGain = options.outputGain ?? 0
+		if (!Number.isSafeInteger(preSkip) || preSkip < 0 || preSkip > 0x7fffffff) throw RangeError('Invalid Opus pre-skip')
+		if (!Number.isInteger(outputGain) || outputGain < -32768 || outputGain > 32767) throw RangeError('Invalid Opus output gain')
+
+		this.unconfigure()
+		let map = this.module._malloc(channels)
+		if (!map) throw Error('Unable to allocate Opus channel mapping')
+		try {
+			this.module.HEAPU8.set(mapping, map)
+			this.handle = this.module._audio_opus_create(sampleRate, channels, streams, coupled, map, preSkip, outputGain)
+		} finally { this.module._free(map) }
+		if (!this.handle) {
+			let code = this.module._audio_opus_last_error()
+			throw Error('libopus ' + code + ' ' + (ERRORS.get(code) || 'UNKNOWN_ERROR'))
+		}
+
+		this.channels = channels
+		this.sampleRate = sampleRate
+		this.frameNumber = 0
+		this.inputBytes = 0
+		this.outputSamples = 0
+	}
+
+	decodeFrames(frames) {
+		if (this.freed) throw Error('Decoder already freed')
+		if (!this.handle) throw Error('Opus decoder is not configured')
+		let chunks = [], errors = [], samplesDecoded = 0
+
+		for (let packet of frames) {
+			if (!(packet instanceof Uint8Array)) throw TypeError('Opus packet must be a Uint8Array')
+			if (packet.length > this.capacity) {
+				let input = this.module._malloc(packet.length)
+				if (!input) throw Error('Unable to allocate Opus input buffer')
+				if (this.input) this.module._free(this.input)
+				this.input = input
+				this.capacity = packet.length
+			}
+			if (packet.length) this.module.HEAPU8.set(packet, this.input)
+
+			let decoded = this.module._audio_opus_decode(this.handle, this.input, packet.length)
+			if (decoded < 0) {
+				errors.push({
+					message: 'libopus ' + decoded + ' ' + (ERRORS.get(decoded) || 'UNKNOWN_ERROR'),
+					frameLength: packet.length,
+					frameNumber: this.frameNumber,
+					inputBytes: this.inputBytes,
+					outputSamples: this.outputSamples
+				})
+			} else if (decoded) {
+				let offset = this.module._audio_opus_output(this.handle) >> 2
+				chunks.push(Array.from({ length: this.channels }, (_, channel) =>
+					this.module.HEAPF32.slice(offset + channel * decoded, offset + (channel + 1) * decoded)
+				))
+				samplesDecoded += decoded
+				this.outputSamples += decoded
+			}
+			this.frameNumber++
+			this.inputBytes += packet.length
+		}
+
+		let channelData = samplesDecoded ? Array.from({ length: this.channels }, (_, channel) => {
+			let output = new Float32Array(samplesDecoded), offset = 0
+			for (let chunk of chunks) { output.set(chunk[channel], offset); offset += chunk[channel].length }
+			return output
+		}) : []
+
+		return { errors, channelData, samplesDecoded, sampleRate: this.sampleRate, bitDepth: 32 }
+	}
+
+	unconfigure() {
+		if (!this.handle) return
+		this.module._audio_opus_destroy(this.handle)
+		this.handle = 0
+		this.channels = 0
+		this.sampleRate = 0
+	}
+
+	free() {
+		if (this.freed) return
+		this.unconfigure()
+		if (this.input) this.module._free(this.input)
+		this.input = 0
+		this.capacity = 0
+		this.freed = true
+	}
+}

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

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

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

@@ -0,0 +1 @@
+export { default, decoder } from './src/decode-opus.js'