@openclaw/whatsapp 2026.5.28 → 2026.5.31-beta.1

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

@@ -1,92 +1,208 @@
 /**
- * Web-Audio-API decoder
- * @module  audio-decode
+ * Audio decoder: whole-file, streaming, chunked
+ * @module audio-decode
+ *
+ * let { channelData, sampleRate } = await decode(buf)
+ *
+ * for await (let pcm of decode.mp3(source)) { ... }
+ *
+ * let dec = await decode.mp3()
+ * let { channelData, sampleRate } = await dec(chunk)
+ * await dec() // close
  */
 
 import getType from 'audio-type';
-import AudioBufferShim from 'audio-buffer';
 
-const AudioBuffer = globalThis.AudioBuffer || AudioBufferShim;
+const EMPTY = Object.freeze({ channelData: Object.freeze([]), sampleRate: 0 })
 
 /**
- * Decode an audio buffer.
- *
- * @param {ArrayBuffer | Uint8Array} buf - The audio data to decode.
- * @returns {Promise<AudioBuffer>} A promise that resolves to the decoded audio buffer.
- * @throws {Error} Throws an error if the decode target is invalid or if the audio format is not supported.
+ * Decode audio.
+ * 1 arg:  whole-file — auto-detects format, returns Promise<AudioData>
+ * 2 args: chunked — streams from ReadableStream/AsyncIterable, returns AsyncGenerator<AudioData>
  */
-export default async function audioDecode(buf) {
-	if (!buf && !(buf.length || buf.buffer)) throw Error('Bad decode target')
-	buf = new Uint8Array(buf.buffer || buf)
-
-	let type = getType(buf);
-
-	if (!type) throw Error('Cannot detect audio format');
-
-	if (!decoders[type]) throw Error('Missing decoder for ' + type + ' format')
-
-	return decoders[type](buf)
-};
-
-export const decoders = {
-	async oga(buf) {
-		let { decoder } = decoders.oga
-		if (!decoder) {
-			let { OggVorbisDecoder } = await import('@wasm-audio-decoders/ogg-vorbis')
-			await (decoders.oga.decoder = decoder = new OggVorbisDecoder()).ready;
-		} else await decoder.reset()
-		return buf && createBuffer(await decoder.decodeFile(buf))
-	},
-	async mp3(buf) {
-		let { decoder } = decoders.mp3
-		if (!decoder) {
-			const { MPEGDecoder } = await import('mpg123-decoder')
-			await (decoders.mp3.decoder = decoder = new MPEGDecoder()).ready;
-		}
-		else await decoder.reset()
-		return buf && createBuffer(await decoder.decode(buf))
-	},
-	async flac(buf) {
-		let { decoder } = decoders.flac
-		if (!decoder) {
-			const { FLACDecoder } = await import('@wasm-audio-decoders/flac')
-			await (decoders.flac.decoder = decoder = new FLACDecoder()).ready
-		}
-		else await decoder.reset()
-		return buf && createBuffer(await decoder.decode(buf))
-	},
-	async opus(buf) {
-		let { decoder } = decoders.opus
-		if (!decoder) {
-			const { OggOpusDecoder } = await import('ogg-opus-decoder')
-			await (decoders.opus.decoder = decoder = new OggOpusDecoder()).ready
+export default function decode(src, format) {
+	if (format) return decodeChunked(src, format)
+	return decodeWhole(src)
+}
+
+async function decodeWhole(src) {
+	if (!src || typeof src === 'string' || !(src.buffer || src.byteLength || src.length))
+		throw TypeError('Expected ArrayBuffer or Uint8Array')
+	let buf = new Uint8Array(src)
+
+	let type = getType(buf)
+	if (!type) throw Error('Unknown audio format')
+	if (!decode[type]) throw Error('No decoder for ' + type)
+
+	let dec = await decode[type]()
+	try {
+		let result = await dec(buf)
+		let flushed = await dec()
+		return merge(result, flushed)
+	} catch (e) { dec.free(); throw e }
+}
+
+/**
+ * Decode a ReadableStream or async iterable of encoded audio chunks.
+ * @param {ReadableStream|AsyncIterable} source
+ * @param {string} format - codec name
+ * @returns {AsyncGenerator<{channelData: Float32Array[], sampleRate: number}>}
+ */
+export async function* decodeChunked(source, format) {
+	if (!decode[format]) throw Error('No decoder for ' + format)
+	let dec = await decode[format]()
+	try {
+		if (source.getReader) {
+			let reader = source.getReader()
+			while (true) {
+				let { done, value } = await reader.read()
+				if (done) break
+				let result = await dec(value instanceof Uint8Array ? value : new Uint8Array(value))
+				if (result.channelData.length) yield result
+			}
+		} else {
+			for await (let chunk of source) {
+				let result = await dec(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk))
+				if (result.channelData.length) yield result
+			}
 		}
-		else await decoder.reset()
-		return buf && createBuffer(await decoder.decodeFile(buf))
-	},
-	async wav(buf) {
-		let { decode } = decoders.wav
-		if (!decode) {
-			let module = await import('node-wav')
-			decode = decoders.wav.decode = module.default.decode
+		let flushed = await dec()
+		if (flushed.channelData.length) yield flushed
+	} finally {
+		dec.free()
+	}
+}
+
+// --- format registration ---
+
+function reg(name, load) {
+	decode[name] = fmt(name, async () => {
+		let mod = await load()
+		// @audio/* packages export { decoder, default }
+		if (mod.decoder) {
+			let codec = await mod.decoder()
+			return streamDecoder(
+				chunk => codec.decode(chunk),
+				codec.flush ? () => codec.flush() : null,
+				codec.free ? () => codec.free() : null
+			)
 		}
-		return buf && createBuffer(await decode(buf))
-	},
-	async qoa(buf) {
-		let { decode } = decoders.qoa
-		if (!decode) {
-			decoders.qoa.decode = decode = (await import('qoa-format')).decode
+		// wasm-audio-decoders export class with .ready
+		let init = mod.default || mod
+		let codec = typeof init === 'function' ? await init() : init
+		if (codec.ready) await codec.ready
+		return streamDecoder(
+			chunk => codec.decode(chunk),
+			codec.flush ? () => codec.flush() : null,
+			codec.free ? () => codec.free() : null
+		)
+	})
+}
+
+function fmt(name, init) {
+	let fn = (src) => {
+		if (!src) return init()
+		// async iterable / ReadableStream → streaming decode
+		if (src[Symbol.asyncIterator] || src.getReader) return decodeChunked(src, name)
+		// buffer → whole-file decode
+		console.warn('decode.' + name + '(data) is deprecated, use decode(data)')
+		return (async () => {
+			let dec = await init()
+			try {
+				let result = await dec(src instanceof Uint8Array ? src : new Uint8Array(src.buffer || src))
+				let flushed = await dec()
+				return merge(result, flushed)
+			} catch (e) { dec.free(); throw e }
+		})()
+	}
+	return fn
+}
+
+// --- codecs ---
+
+reg('mp3', () => import('@audio/decode-mp3'))
+reg('flac', () => import('@audio/decode-flac'))
+reg('opus', () => import('@audio/decode-opus'))
+reg('oga', () => import('@audio/decode-vorbis'))
+
+reg('m4a', () => import('@audio/decode-aac'))
+
+reg('wav', () => import('@audio/decode-wav'))
+reg('qoa', () => import('@audio/decode-qoa'))
+
+reg('aac', () => import('@audio/decode-aac'))
+reg('aiff', () => import('@audio/decode-aiff'))
+reg('caf', () => import('@audio/decode-caf'))
+reg('webm', () => import('@audio/decode-webm'))
+reg('amr', () => import('@audio/decode-amr'))
+reg('wma', () => import('@audio/decode-wma'))
+
+/**
+ * StreamDecoder — a callable function:
+ * dec(chunk)  — decode data, returns { channelData, sampleRate }
+ * dec()       — end of stream: flush remaining samples + free resources
+ * dec.flush() — flush without freeing
+ * dec.free()  — release resources without flushing
+ */
+function streamDecoder(onDecode, onFlush, onFree) {
+	let done = false
+	let fn = async (chunk) => {
+		if (chunk) {
+			if (done) throw Error('Decoder already freed')
+			try { return norm(await onDecode(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk))) }
+			catch (e) { done = true; onFree?.(); throw e }
 		}
-		return buf && createBuffer(await decode(buf))
+		// null/undefined = end of stream
+		if (done) return EMPTY
+		done = true
+		try {
+			let result = onFlush ? norm(await onFlush()) : EMPTY
+			onFree?.()
+			return result
+		} catch (e) { onFree?.(); throw e }
+	}
+	fn.flush = async () => {
+		if (done) return EMPTY
+		return onFlush ? norm(await onFlush()) : EMPTY
 	}
+	fn.free = () => {
+		if (done) return
+		done = true
+		onFree?.()
+	}
+	return fn
 }
 
-function createBuffer({ channelData, sampleRate }) {
-	let audioBuffer = new AudioBuffer({
-		sampleRate,
-		length: channelData[0].length,
-		numberOfChannels: channelData.length
-	})
-	for (let ch = 0; ch < channelData.length; ch++) audioBuffer.getChannelData(ch).set(channelData[ch])
-	return audioBuffer
+// extract { channelData, sampleRate } from codec result
+function norm(r) {
+	if (!r?.channelData?.length) return EMPTY
+	let { channelData, sampleRate, samplesDecoded } = r
+	if (samplesDecoded != null && samplesDecoded < channelData[0].length)
+		channelData = channelData.map(ch => ch.subarray(0, samplesDecoded))
+	if (!channelData[0]?.length) return EMPTY
+	// collapse duplicate stereo to mono (some decoders always output 2ch for mono sources)
+	if (channelData.length === 2) {
+		let a = channelData[0], b = channelData[1], same = true
+		for (let i = 0; i < a.length; i += 37) { if (a[i] !== b[i]) { same = false; break } }
+		if (same) channelData = [a]
+	}
+	return { channelData, sampleRate }
+}
+
+// merge two decode results
+function merge(a, b) {
+	if (!b?.channelData?.length) return a
+	if (!a?.channelData?.length) return b
+	let ach = a.channelData.length, bch = b.channelData.length
+	let ch = Math.max(ach, bch)
+	return {
+		channelData: Array.from({ length: ch }, (_, i) => {
+			let ac = a.channelData[i % ach], bc = b.channelData[i % bch]
+			let merged = new Float32Array(ac.length + bc.length)
+			merged.set(ac)
+			merged.set(bc, ac.length)
+			return merged
+		}),
+		sampleRate: a.sampleRate
+	}
 }

package/node_modules/audio-decode/meta.js

@@ -0,0 +1,11 @@
+/**
+ * Meta parsers — re-export from codec packages.
+ * @module audio-decode/meta
+ *
+ * import { wav, mp3, flac } from 'audio-decode/meta'
+ * let result = wav(bytes)  // { meta, markers, regions } | null
+ */
+
+export { parseMeta as wav } from '@audio/decode-wav/meta'
+export { parseMeta as mp3, parseId3v2 } from '@audio/decode-mp3/meta'
+export { parseMeta as flac } from '@audio/decode-flac/meta'

package/node_modules/audio-decode/package.json

@@ -1,49 +1,77 @@
 {
   "name": "audio-decode",
-  "version": "2.2.3",
+  "version": "3.10.1",
   "description": "Decode audio data in node or browser",
-  "main": "audio-decode.js",
-  "module": "audio-decode.js",
-  "browser": "audio-decode.js",
   "type": "module",
+  "sideEffects": false,
+  "main": "audio-decode.js",
   "types": "audio-decode.d.ts",
+  "exports": {
+    ".": {
+      "browser": "./audio-decode.js",
+      "node": "./audio-decode.js",
+      "default": "./audio-decode.js"
+    },
+    "./stream": "./stream.js",
+    "./meta": "./meta.js",
+    "./package.json": "./package.json"
+  },
+  "workspaces": [
+    "packages/*"
+  ],
   "dependencies": {
-    "@wasm-audio-decoders/flac": "^0.2.4",
-    "@wasm-audio-decoders/ogg-vorbis": "^0.1.15",
-    "audio-buffer": "^5.0.0",
-    "audio-type": "^2.2.1",
-    "mpg123-decoder": "^1.0.0",
-    "node-wav": "^0.0.2",
-    "ogg-opus-decoder": "^1.6.12",
-    "qoa-format": "^1.0.1"
+    "@audio/decode-aac": "^1.0.2",
+    "@audio/decode-aiff": "^1.0.0",
+    "@audio/decode-amr": "^1.0.0",
+    "@audio/decode-caf": "^1.0.0",
+    "@audio/decode-flac": "^1.1.0",
+    "@audio/decode-mp3": "^1.1.0",
+    "@audio/decode-opus": "^1.0.0",
+    "@audio/decode-qoa": "^1.0.0",
+    "@audio/decode-vorbis": "^1.0.0",
+    "@audio/decode-wav": "^1.2.0",
+    "@audio/decode-webm": "^1.0.0",
+    "@audio/decode-wma": "^1.0.0",
+    "audio-type": "^2.4.0"
   },
   "devDependencies": {
-    "audio-lena": "^2.3.0",
+    "audio-lena": "^3.0.0",
     "base64-arraybuffer": "^1.0.2",
-    "tst": "^7.3.0"
+    "esbuild": "^0.28.0",
+    "playwright": "^1.58.0",
+    "tst": "^9.2.2"
   },
   "scripts": {
-    "test": "node test.js"
+    "test": "node test.js",
+    "test:browser": "node test.browser.js",
+    "test:all": "node test.js && node test.browser.js",
+    "publish:all": "npm publish --workspaces && npm publish"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/audiojs/audio-decode.git"
   },
   "keywords": [
-    "audiojs",
     "audio",
-    "dsp",
     "decode",
-    "audio decode",
-    "audio decoder",
-    "web audio decoder",
+    "decoder",
     "codec",
     "mp3",
     "wav",
     "ogg",
     "vorbis",
     "opus",
-    "web-audio"
+    "flac",
+    "aac",
+    "m4a",
+    "qoa",
+    "aiff",
+    "caf",
+    "webm",
+    "amr",
+    "wma",
+    "pcm",
+    "streaming"
   ],
   "author": "ΔY <dfcreative@gmail.com>",
   "license": "MIT",

package/node_modules/audio-decode/readme.md

@@ -1,49 +1,149 @@
-# audio-decode [![test](https://github.com/audiojs/audio-decode/actions/workflows/test.js.yml/badge.svg)](https://github.com/audiojs/audio-decode/actions/workflows/test.js.yml) [![stable](https://img.shields.io/badge/stability-unstable-green.svg)](http://github.com/badges/stability-badges)
+# audio-decode [![test](https://github.com/audiojs/audio-decode/actions/workflows/test.js.yml/badge.svg)](https://github.com/audiojs/audio-decode/actions/workflows/test.js.yml)
 
-Decode audio data from supported format to [AudioBuffer](https://github.com/audiojs/audio-buffer).
+Decode any audio format to raw samples.<br>
+JS / WASM – no ffmpeg, no native bindings, works in both node and browser.<br>
+Small API, minimal size, near-native performance, lazy-loading, chunked decoding.
 
-Supported formats:
+[![npm install audio-decode](https://nodei.co/npm/audio-decode.png?mini=true)](https://npmjs.org/package/audio-decode/)
 
-* [x] `wav`
-* [x] `mp3`
-* [x] `ogg vorbis`
-* [x] `flac`
-* [x] `opus`
-* [ ] `alac`
-* [ ] `aac`
-* [ ] `m4a`
-* [x] [`qoa`](https://github.com/phoboslab/qoa)
+```js
+import decode from 'audio-decode';
 
-[![npm install audio-decode](https://nodei.co/npm/audio-decode.png?mini=true)](https://npmjs.org/package/audio-decode/)
+const { channelData, sampleRate } = await decode(anyAudioBuffer);
+```
+
+#### Supported formats
+
+| Format | Package | Size | Engine |
+|--------|---------|------|--------|
+| MP3 | [@audio/decode-mp3](./packages/decode-mp3) | 92 KB | WASM |
+| WAV | [@audio/decode-wav](./packages/decode-wav) | 4 KB | JS |
+| OGG Vorbis | [@audio/decode-vorbis](./packages/decode-vorbis) | 164 KB | WASM |
+| FLAC | [@audio/decode-flac](./packages/decode-flac) | 133 KB | WASM |
+| Opus | [@audio/decode-opus](./packages/decode-opus) | 178 KB | WASM |
+| M4A / AAC | [@audio/decode-aac](./packages/decode-aac) | 368 KB | WASM |
+| QOA | [@audio/decode-qoa](./packages/decode-qoa) | 8 KB | JS |
+| AIFF | [@audio/decode-aiff](./packages/decode-aiff) | 20 KB | JS |
+| CAF | [@audio/decode-caf](./packages/decode-caf) | 7 KB | JS |
+| WebM | [@audio/decode-webm](./packages/decode-webm) | 263 KB | WASM |
+| AMR | [@audio/decode-amr](./packages/decode-amr) | 241 KB | WASM |
+| WMA | [@audio/decode-wma](./packages/decode-wma) | 91 KB | WASM |
+
+### Whole-file
+
+Auto-detects format. Input can be _ArrayBuffer_, _Uint8Array_, or _Buffer_.
 
 ```js
-import decodeAudio from 'audio-decode';
-import buffer from 'audio-lena/mp3';
+import decode from 'audio-decode'
 
-let audioBuffer = await decode(buffer);
+let { channelData, sampleRate } = await decode(buf)
 ```
 
-`buffer` type can be: _ArrayBuffer_, _Uint8Array_ or _Buffer_.
+### Chunked
 
-`decode` is lazy: first call prepares decoder.
+```js
+let dec = await decode.mp3()
+let a = await dec(chunk1)    // { channelData, sampleRate }
+let b = await dec(chunk2)
+await dec()                  // close
+```
 
-To get more granular control over individual decoders, use `decoders`:
+### Streaming
 
 ```js
-import decode, {decoders} from 'audio-decode';
+import decode from 'audio-decode'
 
-await decoders.mp3(); // load & compile decoder
-const audioBuffer = await decoders.mp3(mp3buf); // decode
+for await (let { channelData, sampleRate } of decode.mp3(response.body)) {
+  // process chunks
+}
 ```
 
-## See also
+Works with `ReadableStream`, `fetch` body, Node stream, or any async iterable.
+
+Formats: `mp3`, `flac`, `opus`, `oga`, `m4a`, `wav`, `qoa`, `aac`, `aiff`, `caf`, `webm`, `amr`, `wma`.
+
+### Browser
+
+Each codec is a self-contained bundle under `@audio/*` — no transitive deps, no import map bloat.
+For selective loading in the browser (avoids bundling all codecs):
+
+```html
+<script type="importmap">
+{
+  "imports": {
+    "audio-decode": "https://esm.sh/audio-decode",
+    "audio-type": "https://esm.sh/audio-type",
+    "@audio/decode-mp3": "https://esm.sh/@audio/decode-mp3",
+    "@audio/decode-wav": "https://esm.sh/@audio/decode-wav",
+    "@audio/decode-flac": "https://esm.sh/@audio/decode-flac",
+    "@audio/decode-opus": "https://esm.sh/@audio/decode-opus",
+    "@audio/decode-vorbis": "https://esm.sh/@audio/decode-vorbis",
+    "@audio/decode-aac": "https://esm.sh/@audio/decode-aac",
+    "@audio/decode-qoa": "https://esm.sh/@audio/decode-qoa",
+    "@audio/decode-aiff": "https://esm.sh/@audio/decode-aiff",
+    "@audio/decode-caf": "https://esm.sh/@audio/decode-caf",
+    "@audio/decode-webm": "https://esm.sh/@audio/decode-webm",
+    "@audio/decode-amr": "https://esm.sh/@audio/decode-amr",
+    "@audio/decode-wma": "https://esm.sh/@audio/decode-wma"
+  }
+}
+</script>
+<script type="module">
+  import decode from 'audio-decode'
+  let { channelData, sampleRate } = await decode(buf)
+</script>
+```
+
+Only list the codecs you need — each `@audio/decode-*` package bundles all its WASM/JS deps internally.
+
+### Metadata
 
-* [wasm-audio-decoders](https://github.com/eshaz/wasm-audio-decoders) – best in class compact & fast WASM audio decoders.
-* [Web Audio Decoders](https://developer.mozilla.org/en-US/docs/Web/API/AudioDecoder) – native decoders API, hope one day will be fixed or alternatively polyfilled.
-* [decodeAudioData](https://github.com/eshaz/wasm-audio-decoders) – default in-browser decoding method.
-* [ffmpeg.wasm](https://github.com/ffmpegwasm/ffmpeg.wasm) – ultimate encoding/decoding library (8.5Mb of code).
+Read tags, pictures, markers and regions without decoding samples. Available for `wav`, `mp3`, `flac`.
 
-## License
+```js
+import { wav, mp3, flac } from 'audio-decode/meta'
+
+let { meta, sampleRate, markers, regions } = mp3(bytes)
+// meta: { title, artist, album, year, bpm, key, comment, pictures, raw, ... }
+// markers: [{ sample, label }]
+// regions: [{ sample, length, label }]
+```
+
+Each codec sub-package also exposes its parser directly:
+
+```js
+import { parseMeta } from '@audio/decode-wav/meta'
+let info = parseMeta(wavBytes)
+```
+
+### WebWorker
+
+Each `@audio/decode-*` package is a self-contained ESM module — import directly in a worker:
+
+```js
+// decode-worker.js
+import decode from '@audio/decode-mp3'
+
+self.onmessage = async ({ data }) => {
+  let pcm = await decode(data)
+  self.postMessage(pcm, pcm.channelData.map(ch => ch.buffer))
+}
+
+// main.js
+let worker = new Worker('./decode-worker.js', { type: 'module' })
+worker.postMessage(mp3buf, [mp3buf])
+worker.onmessage = ({ data }) => { /* { channelData, sampleRate } */ }
+```
+
+## See also
 
-[MIT](LICENSE)&nbsp;&nbsp;•&nbsp;&nbsp;<a href="https://github.com/krishnized/license/">🕉</a>
+* [audio-encode](https://github.com/audiojs/audio-encode) – encode PCM into any audio format.
+* [audio-type](https://github.com/audiojs/audio-type) – detect audio format from buffer.
+<!--
+* [wasm-audio-decoders](https://github.com/eshaz/wasm-audio-decoders) – compact & fast WASM audio decoders.
+* [AudioDecoder](https://developer.mozilla.org/en-US/docs/Web/API/AudioDecoder) – native WebCodecs decoder API.
+* [decodeAudioData](https://developer.mozilla.org/en-US/docs/Web/API/BaseAudioContext/decodeAudioData) – built-in browser decoding method.
+* [ffmpeg.wasm](https://github.com/ffmpegwasm/ffmpeg.wasm) – full encoding/decoding library.
+-->
 
+<p align="center"><a href="./LICENSE">MIT</a> • <a href="https://github.com/krishnized/license/">ॐ</a>

package/node_modules/audio-decode/stream.d.ts

@@ -0,0 +1,15 @@
+import type { AudioData } from './audio-decode.js';
+
+type Format = 'mp3' | 'flac' | 'opus' | 'oga' | 'm4a' | 'wav' | 'qoa' | 'aac' | 'aiff' | 'caf' | 'webm' | 'amr' | 'wma';
+
+/** Chunked decode from stream or async iterable. */
+declare function decodeChunked(
+  source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,
+  format: Format
+): AsyncGenerator<AudioData>;
+
+export default decodeChunked;
+export { decodeChunked };
+
+export default decodeStream;
+export { decodeStream };

package/node_modules/audio-decode/stream.js

@@ -0,0 +1 @@
+export { decodeChunked as default, decodeChunked } from './audio-decode.js'

package/node_modules/audio-decode/test.html

@@ -1,15 +1,34 @@
-<!DOCTYPE html>
+<!doctype html>
+<title>audio-decode tests</title>
 <script type="importmap">
- {
+{
   "imports": {
-    "tst": "./node_modules/tst/tst.js",
+    "./audio-decode.js": "./audio-decode.js",
+    "audio-lena/wav": "./node_modules/audio-lena/wav.js",
+    "audio-lena/mp3": "./node_modules/audio-lena/mp3.js",
+    "audio-lena/ogg": "./node_modules/audio-lena/ogg.js",
+    "audio-lena/flac": "./node_modules/audio-lena/flac.js",
+    "audio-lena/opus": "./node_modules/audio-lena/opus.js",
+    "audio-lena/aiff": "./node_modules/audio-lena/aiff.js",
+    "audio-lena/caf": "./node_modules/audio-lena/caf.js",
+    "audio-lena/webm": "./node_modules/audio-lena/webm.js",
+    "audio-lena/aac": "./node_modules/audio-lena/aac.js",
+    "audio-lena/m4a": "./node_modules/audio-lena/m4a.js",
     "audio-type": "./node_modules/audio-type/audio-type.js",
-    "audio-buffer": "./node_modules/audio-buffer/index.js",
-    "audio-lena/wav.js": "./node_modules/audio-lena/wav.js",
-    "audio-lena/mp3.js": "./node_modules/audio-lena/mp3.js",
-    "audio-lena/ogg.js": "./node_modules/audio-lena/ogg.js",
-    "audio-lena/flac.js": "./node_modules/audio-lena/flac.js"
+    "tst": "./node_modules/tst/tst.js",
+    "@audio/decode-mp3": "./packages/decode-mp3/decode-mp3.js",
+    "@audio/decode-wav": "./packages/decode-wav/decode-wav.js",
+    "@audio/decode-flac": "./packages/decode-flac/decode-flac.js",
+    "@audio/decode-opus": "./packages/decode-opus/decode-opus.js",
+    "@audio/decode-vorbis": "./packages/decode-vorbis/decode-vorbis.js",
+    "@audio/decode-aac": "./packages/decode-aac/decode-aac.js",
+    "@audio/decode-qoa": "./packages/decode-qoa/decode-qoa.js",
+    "@audio/decode-aiff": "./packages/decode-aiff/decode-aiff.js",
+    "@audio/decode-caf": "./packages/decode-caf/decode-caf.js",
+    "@audio/decode-webm": "./packages/decode-webm/decode-webm.js",
+    "@audio/decode-amr": "./packages/decode-amr/decode-amr.js",
+    "@audio/decode-wma": "./packages/decode-wma/decode-wma.js"
   }
- }
+}
 </script>
-<script src="./test.js" type="module"></script>
+<script type="module" src="./test.js"></script>