@audio/decode 3.11.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+Copyright (c) 2018 Dmitry Ivanov <df.creative@gmail.com>
+
+
+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/audio-decode.d.ts

@@ -0,0 +1,52 @@
+export interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
+
+export interface StreamDecoder {
+  /** Feed a chunk of encoded audio data, or call empty to flush + free. */
+  (chunk?: Uint8Array): Promise<AudioData>;
+  /** Flush without freeing. */
+  flush(): Promise<AudioData>;
+  /** Free resources without flushing. */
+  free(): void;
+}
+
+type Format = 'mp3' | 'flac' | 'opus' | 'oga' | 'm4a' | 'wav' | 'qoa' | 'aac' | 'aiff' | 'caf' | 'webm' | 'amr' | 'wma';
+
+interface FormatDecoder {
+  /** Create a decoder instance. */
+  (): Promise<StreamDecoder>;
+}
+
+/** Whole-file decode: auto-detects format. Accepts raw bytes or any source that materializes to bytes (Blob/File/Response). */
+declare function decode(buf: ArrayBuffer | Uint8Array | Blob | Response): Promise<AudioData>;
+/** Chunked decode from stream or async iterable. */
+declare function decode(
+  source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,
+  format: Format
+): AsyncGenerator<AudioData>;
+
+declare namespace decode {
+  export const mp3: FormatDecoder;
+  export const flac: FormatDecoder;
+  export const opus: FormatDecoder;
+  export const oga: FormatDecoder;
+  export const m4a: FormatDecoder;
+  export const wav: FormatDecoder;
+  export const qoa: FormatDecoder;
+  export const aac: FormatDecoder;
+  export const aiff: FormatDecoder;
+  export const caf: FormatDecoder;
+  export const webm: FormatDecoder;
+  export const amr: FormatDecoder;
+  export const wma: FormatDecoder;
+}
+
+export default decode;
+
+/** Chunked decode from stream or async iterable. */
+export function decodeChunked(
+  source: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,
+  format: Format
+): AsyncGenerator<AudioData>;

package/audio-decode.js

@@ -0,0 +1,210 @@
+/**
+ * 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';
+
+const EMPTY = Object.freeze({ channelData: Object.freeze([]), sampleRate: 0 })
+
+/**
+ * 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) {
+	// Blob / File / Response — anything that materializes to an ArrayBuffer
+	if (src && typeof src.arrayBuffer === 'function') src = await src.arrayBuffer()
+	if (!src || typeof src === 'string' || !(src.buffer || src.byteLength || src.length))
+		throw TypeError('Expected ArrayBuffer, Uint8Array, Buffer, Blob, File, or Response')
+	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
+			}
+		}
+		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
+			)
+		}
+		// 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 }
+		}
+		// 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]
+	}
+	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/meta.js

@@ -0,0 +1,14 @@
+/**
+ * Meta parsers — re-export from codec packages.
+ * @module audio-decode/meta
+ *
+ * import { wav, mp3, flac, oga, opus, m4a } from 'audio-decode/meta'
+ * let result = wav(bytes)  // { meta, sampleRate, 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'
+export { parseMeta as oga } from '@audio/decode-vorbis/meta'
+export { parseMeta as opus } from '@audio/decode-opus/meta'
+export { parseMeta as m4a } from '@audio/decode-aac/meta'

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@audio/decode",
+  "version": "3.11.0",
+  "description": "Decode audio data in node or browser",
+  "type": "module",
+  "sideEffects": false,
+  "main": "audio-decode.js",
+  "types": "audio-decode.d.ts",
+  "files": [
+    "audio-decode.js",
+    "audio-decode.d.ts",
+    "stream.js",
+    "stream.d.ts",
+    "meta.js",
+    "test.html"
+  ],
+  "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.2.0",
+    "@audio/decode-aiff": "^1.1.3",
+    "@audio/decode-amr": "^1.0.0",
+    "@audio/decode-caf": "^1.2.0",
+    "@audio/decode-flac": "^1.1.0",
+    "@audio/decode-mp3": "^1.1.0",
+    "@audio/decode-opus": "^1.1.0",
+    "@audio/decode-qoa": "^1.0.0",
+    "@audio/decode-vorbis": "^1.1.0",
+    "@audio/decode-wav": "^1.3.0",
+    "@audio/decode-webm": "^1.0.0",
+    "@audio/decode-wma": "^1.0.0",
+    "audio-type": "^2.4.0"
+  },
+  "devDependencies": {
+    "audio-lena": "^3.0.0",
+    "base64-arraybuffer": "^1.0.2",
+    "esbuild": "^0.28.0",
+    "playwright": "^1.58.0",
+    "tst": "^9.2.2"
+  },
+  "scripts": {
+    "test": "node test.js",
+    "test:browser": "node test.browser.js",
+    "test:all": "node test.js && node test.browser.js",
+    "publish:all": "for d in packages/* .; do [ -f \"$d/package.json\" ] || continue; id=$(node -p \"require('./'+'$d'+'/package.json').name+'@'+require('./'+'$d'+'/package.json').version\"); npm view \"$id\" version >/dev/null 2>&1 && echo \"skip $id\" || (cd \"$d\" && npm publish); done"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/audiojs/decode.git"
+  },
+  "keywords": [
+    "audio",
+    "decode",
+    "decoder",
+    "codec",
+    "mp3",
+    "wav",
+    "ogg",
+    "vorbis",
+    "opus",
+    "flac",
+    "aac",
+    "m4a",
+    "qoa",
+    "aiff",
+    "caf",
+    "webm",
+    "amr",
+    "wma",
+    "pcm",
+    "streaming"
+  ],
+  "author": "Dmitry Iv. <dfcreative@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/audiojs/decode/issues"
+  },
+  "homepage": "https://github.com/audiojs/decode#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/readme.md

@@ -0,0 +1,154 @@
+# @audio/decode [![test](https://github.com/audiojs/decode/actions/workflows/test.js.yml/badge.svg)](https://github.com/audiojs/decode/actions/workflows/test.js.yml)
+
+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.
+
+[![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 / ALAC | [@audio/decode-aac](./packages/decode-aac) | 368 KB | WASM + JS |
+| 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_, _Buffer_, or anything
+that materializes to bytes — a _Blob_/_File_ (browser file input, drag-drop) or a fetch _Response_.
+
+```js
+import decode from '@audio/decode'
+
+let { channelData, sampleRate } = await decode(buf)
+let fromFile = await decode(fileInput.files[0])   // File
+let fromUrl  = await decode(await fetch(url))      // Response
+```
+
+
+### Chunked
+
+```js
+let dec = await decode.mp3()
+let a = await dec(chunk1)    // { channelData, sampleRate }
+let b = await dec(chunk2)
+await dec()                  // close
+```
+
+### Streaming
+
+```js
+import decode from '@audio/decode'
+
+for await (let { channelData, sampleRate } of decode.mp3(response.body)) {
+  // process chunks
+}
+```
+
+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
+
+Read tags, pictures, markers and regions without decoding samples. Available for
+`wav`, `mp3`, `flac`, `oga` (Ogg Vorbis), `opus`, and `m4a`.
+
+```js
+import { wav, mp3, flac, oga, opus, m4a } 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
+
+* [encode](https://github.com/audiojs/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/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/stream.js

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

package/test.html

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