@openclaw/whatsapp 2026.5.31-beta.2 → 2026.5.31-beta.3

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

@@ -1,208 +1,92 @@
 /**
- * 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
+ * Web-Audio-API decoder
+ * @module  audio-decode
  */
 
 import getType from 'audio-type';
+import AudioBufferShim from 'audio-buffer';
 
-const EMPTY = Object.freeze({ channelData: Object.freeze([]), sampleRate: 0 })
+const AudioBuffer = globalThis.AudioBuffer || AudioBufferShim;
 
 /**
- * Decode audio.
- * 1 arg:  whole-file — auto-detects format, returns Promise<AudioData>
- * 2 args: chunked — streams from ReadableStream/AsyncIterable, returns AsyncGenerator<AudioData>
- */
-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}>}
+ * 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.
  */
-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
-			}
+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;
 		}
-		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
-			)
+		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
 		}
-		// 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 }
+		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
 		}
-		// 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
-}
-
-// 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]
+		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
+		}
+		return buf && createBuffer(await decode(buf))
+	},
+	async qoa(buf) {
+		let { decode } = decoders.qoa
+		if (!decode) {
+			decoders.qoa.decode = decode = (await import('qoa-format')).decode
+		}
+		return buf && createBuffer(await decode(buf))
 	}
-	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
-	}
+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
 }

package/node_modules/audio-decode/package.json

@@ -1,77 +1,49 @@
 {
   "name": "audio-decode",
-  "version": "3.10.1",
+  "version": "2.2.3",
   "description": "Decode audio data in node or browser",
-  "type": "module",
-  "sideEffects": false,
   "main": "audio-decode.js",
+  "module": "audio-decode.js",
+  "browser": "audio-decode.js",
+  "type": "module",
   "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": {
-    "@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"
+    "@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"
   },
   "devDependencies": {
-    "audio-lena": "^3.0.0",
+    "audio-lena": "^2.3.0",
     "base64-arraybuffer": "^1.0.2",
-    "esbuild": "^0.28.0",
-    "playwright": "^1.58.0",
-    "tst": "^9.2.2"
+    "tst": "^7.3.0"
   },
   "scripts": {
-    "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"
+    "test": "node test.js"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/audiojs/audio-decode.git"
   },
   "keywords": [
+    "audiojs",
     "audio",
+    "dsp",
     "decode",
-    "decoder",
+    "audio decode",
+    "audio decoder",
+    "web audio decoder",
     "codec",
     "mp3",
     "wav",
     "ogg",
     "vorbis",
     "opus",
-    "flac",
-    "aac",
-    "m4a",
-    "qoa",
-    "aiff",
-    "caf",
-    "webm",
-    "amr",
-    "wma",
-    "pcm",
-    "streaming"
+    "web-audio"
   ],
   "author": "ΔY <dfcreative@gmail.com>",
   "license": "MIT",

package/node_modules/audio-decode/readme.md

@@ -1,149 +1,49 @@
-# 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)
+# 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)
 
-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.
+Decode audio data from supported format to [AudioBuffer](https://github.com/audiojs/audio-buffer).
 
-[![npm install audio-decode](https://nodei.co/npm/audio-decode.png?mini=true)](https://npmjs.org/package/audio-decode/)
-
-```js
-import decode from '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 decode from 'audio-decode'
-
-let { channelData, sampleRate } = await decode(buf)
-```
-
-### Chunked
+Supported formats:
 
-```js
-let dec = await decode.mp3()
-let a = await dec(chunk1)    // { channelData, sampleRate }
-let b = await dec(chunk2)
-await dec()                  // close
-```
+* [x] `wav`
+* [x] `mp3`
+* [x] `ogg vorbis`
+* [x] `flac`
+* [x] `opus`
+* [ ] `alac`
+* [ ] `aac`
+* [ ] `m4a`
+* [x] [`qoa`](https://github.com/phoboslab/qoa)
 
-### Streaming
+[![npm install audio-decode](https://nodei.co/npm/audio-decode.png?mini=true)](https://npmjs.org/package/audio-decode/)
 
 ```js
-import decode from 'audio-decode'
+import decodeAudio from 'audio-decode';
+import buffer from 'audio-lena/mp3';
 
-for await (let { channelData, sampleRate } of decode.mp3(response.body)) {
-  // process chunks
-}
+let audioBuffer = await decode(buffer);
 ```
 
-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>
-```
+`buffer` type can be: _ArrayBuffer_, _Uint8Array_ or _Buffer_.
 
-Only list the codecs you need — each `@audio/decode-*` package bundles all its WASM/JS deps internally.
+`decode` is lazy: first call prepares decoder.
 
-### Metadata
-
-Read tags, pictures, markers and regions without decoding samples. Available for `wav`, `mp3`, `flac`.
+To get more granular control over individual decoders, use `decoders`:
 
 ```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 }]
-```
+import decode, {decoders} from 'audio-decode';
 
-Each codec sub-package also exposes its parser directly:
-
-```js
-import { parseMeta } from '@audio/decode-wav/meta'
-let info = parseMeta(wavBytes)
+await decoders.mp3(); // load & compile decoder
+const audioBuffer = await decoders.mp3(mp3buf); // decode
 ```
 
-### WebWorker
+## See also
 
-Each `@audio/decode-*` package is a self-contained ESM module — import directly in a worker:
+* [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).
 
-```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
+## License
 
-* [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.
--->
+[MIT](LICENSE)&nbsp;&nbsp;•&nbsp;&nbsp;<a href="https://github.com/krishnized/license/">🕉</a>
 
-<p align="center"><a href="./LICENSE">MIT</a> • <a href="https://github.com/krishnized/license/">ॐ</a>

package/node_modules/audio-decode/tea.yaml

@@ -0,0 +1,6 @@
+# https://tea.xyz/what-is-this-file
+---
+version: 1.0.0
+codeOwners:
+  - '0x18CEa38f92a0E9b028ea27DD935B36A55Cf83b06'
+quorum: 1

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

@@ -0,0 +1,11 @@
+import fs from 'fs/promises'
+
+async function main(options) {
+    const audioDecode = await import('./audio-decode.js');
+    const decode = audioDecode.default;
+    await audioDecode.decoders.mp3();
+    const buffer = await fs.readFile('test.mp3');
+    const decodedBuffer = await decode(buffer);
+}
+
+main().catch(console.error)

package/node_modules/audio-decode/test.html

@@ -1,34 +1,15 @@
-<!doctype html>
-<title>audio-decode tests</title>
+<!DOCTYPE html>
 <script type="importmap">
-{
+ {
   "imports": {
-    "./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",
     "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"
+    "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"
   }
-}
+ }
 </script>
-<script type="module" src="./test.js"></script>
+<script src="./test.js" type="module"></script>