audio-decode 2.2.2 → 4.0.0

package/.github/workflows/test.js.yml

@@ -1,31 +1,22 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
 name: test
 
 on:
   push:
-    branches: [ "master" ]
+    branches: [master]
   pull_request:
-    branches: [ "master" ]
+    branches: [master]
 
 jobs:
-  build:
-
+  test:
     runs-on: ubuntu-latest
-
     strategy:
       matrix:
-        node-version: [14.x, 16.x, 18.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
+        node-version: [20.x, 22.x]
     steps:
-    - uses: actions/checkout@v3
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v3
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm ci
-    - run: npm run build --if-present
-    - run: npm test
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: npm
+      - run: npm ci
+      - run: npm test

package/.work/todo.md

@@ -0,0 +1,9 @@
+## Missing codecs
+
+- [ ] aiff decoder
+- [ ] aac (raw ADTS) decoder
+- [ ] wma decoder
+- [ ] amr decoder
+- [ ] webm audio decoder
+- [ ] caf decoder
+- [ ] midi decoder

package/audio-decode.d.ts

@@ -1,14 +1,32 @@
-// audio-decode.d.ts
-
-export default function audioDecode(buf: ArrayBuffer | Uint8Array): Promise<AudioBuffer>;
+export interface AudioData {
+  channelData: Float32Array[];
+  sampleRate: number;
+}
 
-export interface Decoders {
-  oga: (buf: Uint8Array) => Promise<AudioBuffer>;
-  mp3: (buf: Uint8Array) => Promise<AudioBuffer>;
-  flac: (buf: Uint8Array) => Promise<AudioBuffer>;
-  opus: (buf: Uint8Array) => Promise<AudioBuffer>;
-  wav: (buf: Uint8Array) => Promise<AudioBuffer>;
-  qoa: (buf: Uint8Array) => Promise<AudioBuffer>;
+export interface StreamDecoder {
+  /** Feed a chunk of encoded audio data. */
+  decode(chunk: Uint8Array): Promise<AudioData>;
+  /** Flush remaining buffered data and free resources. */
+  decode(): Promise<AudioData>;
+  /** Free resources without flushing. */
+  free(): void;
 }
 
-export const decoders: Decoders;
+/** Whole-file decode: auto-detects format. */
+export default function decode(buf: ArrayBuffer | Uint8Array): Promise<AudioData>;
+
+/** Decode a ReadableStream of audio chunks. */
+export function decodeStream(
+  stream: ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>,
+  format: 'mp3' | 'flac' | 'opus' | 'oga' | 'm4a' | 'wav' | 'qoa'
+): AsyncGenerator<AudioData>;
+
+export declare const decoders: {
+  mp3(): Promise<StreamDecoder>;
+  flac(): Promise<StreamDecoder>;
+  opus(): Promise<StreamDecoder>;
+  oga(): Promise<StreamDecoder>;
+  m4a(): Promise<StreamDecoder>;
+  wav(): Promise<StreamDecoder>;
+  qoa(): Promise<StreamDecoder>;
+};

package/audio-decode.js

@@ -1,92 +1,159 @@
 /**
- * Web-Audio-API decoder
- * @module  audio-decode
+ * Audio decoder: whole-file and streaming
+ * @module audio-decode
+ *
+ * let { channelData, sampleRate } = await decode(mp3buf)
+ *
+ * let dec = await decoders.mp3()
+ * let { channelData, sampleRate } = await dec.decode(chunk)
+ * await dec.decode() // flush + free
  */
 
 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.
+ * Whole-file decode: auto-detects format
+ * @param {ArrayBuffer|Uint8Array} src - encoded audio data
+ * @returns {Promise<{channelData: Float32Array[], sampleRate: number}>}
  */
-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);
+export default async function decode(src) {
+	if (!src || typeof src === 'string' || !(src.buffer || src.byteLength || src.length))
+		throw TypeError('Expected ArrayBuffer or Uint8Array')
+	let buf = new Uint8Array(src.buffer || src)
 
-	if (!type) throw Error('Cannot detect audio format');
+	let type = getType(buf)
+	if (!type) throw Error('Unknown audio format')
+	if (!decoders[type]) throw Error('No decoder for ' + type)
 
-	if (!decoders[type]) throw Error('Missing decoder for ' + type + ' format')
+	let dec = await decoders[type]()
+	try {
+		let result = await dec.decode(buf)
+		let flushed = await dec.decode()
+		return merge(result, flushed)
+	} catch (e) {
+		dec.free()
+		throw e
+	}
+}
 
-	return decoders[type](buf)
-};
+/**
+ * Decode a ReadableStream of audio chunks
+ * @param {ReadableStream} stream - stream of Uint8Array chunks
+ * @param {string} format - codec name (mp3, flac, opus, oga, m4a, wav, qoa)
+ * @returns {AsyncGenerator<{channelData: Float32Array[], sampleRate: number}>}
+ */
+export async function* decodeStream(stream, format) {
+	if (!decoders[format]) throw Error('No decoder for ' + format)
+	let dec = await decoders[format]()
+	try {
+		for await (let chunk of stream) {
+			let result = await dec.decode(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk))
+			if (result.channelData.length) yield result
+		}
+		let flushed = await dec.decode()
+		if (flushed.channelData.length) yield flushed
+	} finally {
+		dec.free()
+	}
+}
 
+// codec registry: each returns an initialized StreamDecoder
 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() {
+		const { MPEGDecoder } = await import('mpg123-decoder')
+		let dec = new MPEGDecoder()
+		await dec.ready
+		return streamDecoder(chunk => dec.decode(chunk), null, () => dec.free())
 	},
-	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() {
+		const { FLACDecoder } = await import('@wasm-audio-decoders/flac')
+		let dec = new FLACDecoder()
+		await dec.ready
+		return streamDecoder(chunk => dec.decode(chunk), () => dec.flush(), () => dec.free())
 	},
-	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() {
+		const { OggOpusDecoder } = await import('ogg-opus-decoder')
+		let dec = new OggOpusDecoder()
+		await dec.ready
+		return streamDecoder(chunk => dec.decode(chunk), () => dec.flush(), () => dec.free())
 	},
-	async opus(buf) {
-		let { decoder } = decoders.opus
-		if (!decoder) {
-			const { OggOpusDecoder } = await import('ogg-opus-decoder')
-			await (decoders.opus.decoder = decoder = new OggOpusDecoder()).ready
-		}
-		else await decoder.reset()
-		return buf && createBuffer(await decoder.decodeFile(buf))
+
+	async oga() {
+		const { OggVorbisDecoder } = await import('@wasm-audio-decoders/ogg-vorbis')
+		let dec = new OggVorbisDecoder()
+		await dec.ready
+		return streamDecoder(chunk => dec.decode(chunk), () => dec.flush(), () => dec.free())
 	},
-	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 m4a() {
+		const { decoder } = await import('aac-decode')
+		let dec = await decoder()
+		return streamDecoder(chunk => dec.decode(chunk), () => dec.flush(), () => dec.free())
+	},
+
+	async wav() {
+		let { default: { decode: wavDecode } } = await import('node-wav')
+		return streamDecoder(chunk => wavDecode(chunk))
+	},
+
+	async qoa() {
+		let { decode } = await import('qoa-format')
+		return streamDecoder(chunk => decode(chunk))
 	},
-	async qoa(buf) {
-		let { decode } = decoders.qoa
-		if (!decode) {
-			decoders.qoa.decode = decode = (await import('qoa-format')).decode
+}
+
+/**
+ * StreamDecoder: unified interface
+ * .decode(chunk) — decode data, returns { channelData, sampleRate }
+ * .decode()      — flush remaining + free resources
+ * .free()        — free resources without flushing
+ */
+function streamDecoder(onDecode, onFlush, onFree) {
+	let done = false
+	return {
+		async decode(chunk) {
+			if (chunk?.length) {
+				if (done) throw Error('Decoder already freed')
+				try { return norm(await onDecode(chunk)) }
+				catch (e) { done = true; onFree?.(); throw e }
+			}
+			if (done) return EMPTY
+			done = true
+			try {
+				let result = onFlush ? norm(await onFlush()) : EMPTY
+				onFree?.()
+				return result
+			} catch (e) { onFree?.(); throw e }
+		},
+		free() {
+			if (done) return
+			done = true
+			onFree?.()
 		}
-		return buf && createBuffer(await decode(buf))
 	}
 }
 
-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
+	return { channelData: r.channelData, sampleRate: r.sampleRate }
+}
+
+// merge two decode results
+function merge(a, b) {
+	if (!b?.channelData?.length) return a
+	if (!a?.channelData?.length) return b
+	return {
+		channelData: a.channelData.map((ch, i) => {
+			let merged = new Float32Array(ch.length + b.channelData[i].length)
+			merged.set(ch)
+			merged.set(b.channelData[i], ch.length)
+			return merged
+		}),
+		sampleRate: a.sampleRate
+	}
 }

package/package.json

@@ -1,26 +1,28 @@
 {
   "name": "audio-decode",
-  "version": "2.2.2",
+  "version": "4.0.0",
   "description": "Decode audio data in node or browser",
-  "main": "audio-decode.js",
-  "module": "audio-decode.js",
-  "browser": "audio-decode.js",
   "type": "module",
+  "main": "audio-decode.js",
   "types": "audio-decode.d.ts",
+  "exports": {
+    ".": "./audio-decode.js",
+    "./package.json": "./package.json"
+  },
   "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",
+    "@wasm-audio-decoders/flac": "^0.2.10",
+    "@wasm-audio-decoders/ogg-vorbis": "^0.1.20",
+    "aac-decode": "^1.0.0",
+    "audio-type": "^2.4.0",
+    "mpg123-decoder": "^1.0.3",
     "node-wav": "^0.0.2",
-    "ogg-opus-decoder": "^1.6.12",
+    "ogg-opus-decoder": "^1.7.3",
     "qoa-format": "^1.0.1"
   },
   "devDependencies": {
     "audio-lena": "^2.3.0",
     "base64-arraybuffer": "^1.0.2",
-    "tst": "^7.3.0"
+    "tst": "^9.2.2"
   },
   "scripts": {
     "test": "node test.js"
@@ -30,20 +32,21 @@
     "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",
+    "pcm",
+    "streaming"
   ],
   "author": "ΔY <dfcreative@gmail.com>",
   "license": "MIT",

package/readme.md

@@ -1,49 +1,80 @@
-# 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 audio data in node or browser. Returns `{ channelData, sampleRate }`, where `channelData` is an array of `Float32Array` PCM channels.
 
-Supported formats:
+ESM-only package:
 
-* [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';
+```
+
+Supported formats: `wav`, `mp3`, `ogg vorbis`, `flac`, `opus`, `m4a`/`aac`, [`qoa`](https://github.com/phoboslab/qoa).
 
 [![npm install audio-decode](https://nodei.co/npm/audio-decode.png?mini=true)](https://npmjs.org/package/audio-decode/)
 
+### Whole-file decode
+
+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);
+const { channelData, sampleRate } = await decode(mp3buf);
 ```
 
-`buffer` type can be: _ArrayBuffer_, _Uint8Array_ or _Buffer_.
+### Chunked decoding
+
+Use `decoders` for chunk-by-chunk decoding when you already know the codec.
 
-Decoder's code is lazy: first run loads decoder's sources and compiles module before decoding.
+```js
+import { decoders } from 'audio-decode';
+
+const decoder = await decoders.mp3();
+const a = await decoder.decode(chunk1);  // { channelData, sampleRate }
+const b = await decoder.decode(chunk2);
+const c = await decoder.decode();        // flush + free
+```
 
-To get more granular control over individual decoders, use `decoders`:
+Call `.free()` to release resources without flushing:
 
 ```js
-import decode, {decoders} from 'audio-decode';
+decoder.free();
+```
+
+### Stream decoding
+
+Decode a `ReadableStream` or async iterable when you already know the codec:
 
-await decoders.mp3(); // load & compile decoder
-const audioBuffer = await decoders.mp3(mp3buf); // decode
+```js
+import { decodeStream } from 'audio-decode';
+
+for await (const { channelData, sampleRate } of decodeStream(stream, 'mp3')) {
+  // process each decoded chunk
+}
+```
+
+Available stream codec keys: `mp3`, `flac`, `opus`, `oga`, `m4a`, `wav`, `qoa`.
+
+AAC-in-M4A/MP4 stream decoding is available through `decoders.m4a()` and `decodeStream(stream, 'm4a')`.
+
+There is no separate `decoders.aac()` or `decodeStream(stream, 'aac')` alias.
+
+### Custom decoders
+
+The `decoders` registry is extensible:
+
+```js
+import { decoders } from 'audio-decode';
+decoders.myformat = async () => ({ decode: chunk => ..., free() {} });
 ```
 
 ## See also
 
-* [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).
+* [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.
 
 ## License
 
 [MIT](LICENSE)&nbsp;&nbsp;•&nbsp;&nbsp;<a href="https://github.com/krishnized/license/">🕉</a>
-

package/test.js

@@ -1,107 +1,293 @@
-
-import decodeAudio, { decoders } from './audio-decode.js';
+import decode, { decoders, decodeStream } from './audio-decode.js';
 import wav from 'audio-lena/wav.js';
 import mp3 from 'audio-lena/mp3.js';
 import ogg from 'audio-lena/ogg.js';
 import flac from 'audio-lena/flac.js';
 import opus from 'audio-lena/opus.js';
-import t, { is, throws } from 'tst';
-import b64 from 'base64-arraybuffer'
-
-
-//as a callback
-t('wav buffer', async function (t) {
-	console.time('wav first')
-	await decoders.wav()
-	console.timeEnd('wav first')
-
-	console.time('wav second')
-	let audioBuffer = await decodeAudio(wav)
-	console.timeEnd('wav second')
-	is(audioBuffer.duration | 0, 12, 'wav duration')
-});
-
-t('mp3 buffer', async function (t) {
-	console.time('mp3 first')
-	await decoders.mp3()
-	console.timeEnd('mp3 first')
-
-	console.time('mp3 second')
-	let audioBuffer = await decodeAudio(mp3)
-	console.timeEnd('mp3 second')
-	is(audioBuffer.duration | 0, 12, 'mp3 duration')
-});
-
-t('ogg buffer', async function (t) {
-	console.time('ogg first')
-	let audioBuffer = await decodeAudio(ogg)
-	console.timeEnd('ogg first')
-	is(audioBuffer.duration | 0, 12, 'ogg duration')
-
-	console.time('ogg second')
-	audioBuffer = await decodeAudio(ogg)
-	console.timeEnd('ogg second')
-	is(audioBuffer.duration | 0, 12, 'ogg duration')
-});
-
-t('flac buffer', async function (t) {
-	console.time('flac first')
-	let audioBuffer = await decodeAudio(flac)
-	console.timeEnd('flac first')
-	is(audioBuffer.duration | 0, 12, 'flac duration')
-
-	console.time('flac second')
-	audioBuffer = await decodeAudio(flac)
-	console.timeEnd('flac second')
-	is(audioBuffer.duration | 0, 12, 'flac duration')
-});
-
-t('opus buffer', async function (t) {
-	console.time('opus first')
-	let audioBuffer = await decodeAudio(opus)
-	console.timeEnd('opus first')
-	is(audioBuffer.duration | 0, 12, 'opus duration')
-
-	console.time('opus second')
-	audioBuffer = await decodeAudio(opus)
-	console.timeEnd('opus second')
-	is(audioBuffer.duration | 0, 12, 'opus duration')
-});
-
-t('qoa buffer', async function (t) {
-	const qoa = b64.decode(`cW9hZgAAmgcBALuAFAAIGAAAAAAAAAAAAAAAAOAAQADAT9u4g6Em4roTLwpSDCDQkU5+FDxcWHyYgVOEaUL47KClxa6XUMonkJwLChleRxC1TvCZWqxcyqALA5XNs7zQ1wtEBw2kJTHO6adFgTcyiKXz7MFkrmXotUOnplWgpVOFuU0dkSljYqkCLRWaS1JqdTKo5d2jH/zyAQCASxfo//2F5TVGIXJc9aVRglIxsuz7GdAqES4eddrYBSbr366B7c5pWFZI8YvgQlrdVGnYwu4gDR5jL9bN6gLVhoqcYpvR1ii0HS6Ju+DiUKwT4BTTzyWssSfug8jigj4miC0K67yUQCy8jySs6LIZJMtw0kjBlUWrTWmf8ccRNl7dVApEvF4ME35HJY68UBvVexK8hLSFAd9Xsba1u6t0PopGZzbiyeUgtjyybMxRAph0IQTAxpUBgg8H0O21KyY+IvUu35khezisTVjcovZCQ8OhAEmiHYKA/S2hQLDoIDpPJDMLmQlbBEYCRGSSUHImUQCwHJA5laPaFoZjg00C8z3J1YiE3okw4uoXs4qjGNcCTa1Gp0x8muMsIo2CKde4PF7oSZDSqFGzOT2tkINMyFSlQ2OuI60Ci0GAeZTsPETYYgqFpJN4jRtIFVyEAmdG8/pfRZEvRCJ4nIvcksijFsuI9xicyZDF3BC2cqaAGRBDCrLShvzXPsy8WhCQWFm6Cly1DJBgUBLhI4WjiLZDhsF2hLWOhrT0rey4GpJSXrIJ7ggCkRVPgwVMZJqkkWyWAyBCjagD5JXZIQTAloH1NVgYOMSQm1xiupMGJKIbCJKLwQqamd1om2BollWFf7mz5ouFcLZYBhIEQLSBitjUg66Vdpif00qXJ02aLZPARpAwrMLXgEY5PaatzXmHlg8IjOTcfYu13eU/XBb7pqAkII8AjpmcZCjMyaor4pgSeTlLabXemTuWG3iktsCVrVEeOdyzDKRQagdRSLeQmOISgcIhgPSOzgb63SuYEpB83faadiURhJNa94IVTbyScaWK8aHEhYYTv6PJFeXXpkq8tCsIBBiUWjWImnMAGJKHIZCTSkNah1/1LnMJTt+UbaBEzsFAQJJIqiwC2NhYgOvFZBRRfmWeHUgzC42/WJfaKgoybDoblMiZqNYOpUCWElESkyPUj4KczQAavF6VjjQQ1Zl0NK6Q9ITAc6UgEZkgwqQLFeVBiQSudi/g1S2JgHS1euc45Ie1rKYfSSROhAAc6t0CTpGMLaPRe4Agypjb4FNBeFQQgb9EFl5KJHSaC2UOmMURGpHpdYNSQQaTgd17uBLarNGW6iUysjAwF4ZtjVEOHRNZusBgApAEkCmXSY3kIgWmR4YQEJ2VhoDtkg5iGJLpNluWk0AkGHQR3IqiR2KXRYa4jRrAZHgUihOYkLhU3yHw2qAABQNB4Lbgh4OACnudosaUSk46WU0xiIzNU7PYDLQidiX6/3d7iTGSGhSazG0gMYICLHSqjS0+c8IXttCxGa2SDweSFURA04rB9jajKUKNlNp0qM4mINiKQ2CcCZC9eIJvXMaTEQ4Hcy9xJYjFT0iF0utAJHE2WIRYiG1GApfCfxuTAY3D8CugWEUCAC06gYYhGBQILpLMc/YoS3Xn0sWEmsWE2R6i0YKUKnMdJFkamBJEgsCuEpCGtUKSXQ7I1HhWfI7XYUGXjRoF2PptJFKCoeBWm3E8rIKbHstABkpRhgdtlqvA4iiVWKwSwDEWi4BvYblaEAXSft2vGxCYUCqCe5VCBI4OgYdVOJEQypAZlUoIIPIolhV6KJBYhle10X9eRzeSdPG5klHFoop1hgmGcRGBFy+iHYjWLITQ7ALVgRIgPKmknWx3pF4ij6YzKoWTReKtVkZAiDDokscIAgqMCGQF2vihYoGbZDLriDTEkKsWGmgCFwCUxSmGyIUSEoXD+ofxWoIRgnlNlsRJhHGaOCVTCo1UmHvJjDsWdlOLi+cTojGFxEuLQgyQsSPCF4C+LDkcdTTrmgBkNQikVGmGdY3iFXQna4cgBcQXTurdjA6iDFmgNtuJAnEc6Kl13Hsnh2ofKTdGhQONah3cDhKMSnERaUiGgpzAcLHIsdRkd62QP2kJtPaWmE0eGFUTEIVKCrraTKGKddB71XJ7raF2WUbS8CisdY8qHHMCVSUIlsAsgwouBTiG42eMcwnE3YJDZqSjEMFHc6r9CYhnI12CCa4YqiMxeJDTIORTABbZgE0I4A1Tr0N8mmsgGyF/QYQaOyTsaFdehpGKJlgm0kSASchKw9WegHQMWFZZF9egdMYYc0zt+GZvNM7/Qv+8looQ1b6ZFKUBdIYP1gt8wYeE4mn5U7AsAYKSbpIBoEhAhwAdpygCYFl0Af2FC0NBqXxVoY1BGiVJcI/sIAE5BeFyvXciWMMXSGV/fyA+ylo6cdt4otLYVkhm/1hE8pub9XroSwsGRPbRdmxKMIYd8ih30tiikjfwy3bQioKzd5IXegxAUIi2gFNwphZUifxUaHK0hYBb7aQqcaIC4I9l4ol5omyQX2UmAX2grTR7ohTMdICso1sqAg5pF0XLfYhCJGwtqZ9p0QqkdGuiU0oxNDJlb2RbzspcZnddVJpUiKMRZ+tKuxTKoZNj6GrQtAAEh3vBBLC0BARLfkoEhSIMCF1qwpSpolUgL2JgIc2VJIL/ZlJgLKPpq+1ikC5pCaYT6GOSR0irJJt6XYNDaX0kv0hokTlC3wH7YGyBCwXbYbrkZApKG2gl1iZkGIk7aQ3SlAEAu4AUAAgY9CEQSwnE8RD0BAs22n4EymQJid9ZTbE0ZFEJ3sEigaBiQg33UmWosWLCFfLALC2Cdgg20ogkJQliUxe3AwZoi1JR/dQzcmhPYhj1hJxyZMtiC7wYmgoU6FIftEyDmxd7Yk8kQIBQL1lSe/NkYZAfxVT7KwjOStvaVvkbYp5K+ipmS5EmAEbaEVNCmQYhlt4TYs5RFFKvughWRtgwSv/9QFqUxDaFv5OYVzDNtg2+p4tUtqKwTfWkAWQiNbTL4KTAUZB2kr1lKEpZgHWKP29AgFyXtLdtAyQSXAPkEdg5JFZFv70H+tsY9FI/dBYY0QcMUW0gllLKBwJH/7m7dpm04Vt7BDJ2ioABXvlNMxbMMRtf2UQ1JEQwrVvRSaiyYZDHW1JIqbAloNtanE0FgrSCe1aSQSkJdBL7UDAISBVllutRIAFIXaGH00mWIyh/7FvMWRBGIHtkOl5NI5BLf226RliBEQfNAoYxXIopN2ggsDRUCAU66gVVFkZBjt9ZjRW2UMlCvkkBwSFJWmP6YiHltVDYbPIGaCwBTgl+upROLahO1R+jkM5hL0PT94y1imCfQUjmnJK7Sc1Gm7UZhnMN6E8tPmOajxr7RVdoaFPArjtUwbDkQRmbQ0K6eyxKervQVihHEpoNdspGWcpHHFzePlDRWMZRB5qLWNBQgNEnhmNSjjFSWKbQAEcG3jK8/lEOTjHHup8eoT5UYkam123HFU2O+/jbpujRYIKtUMmhOABTgV2Gei4gTlalbaqfiEMZXUlno0MRbpNYXfB9QTipQkI5vx7Oe3ViZq1NAhrNAopT1SAqgci7iVnoe6ViEab1W1h4VHIaueNmao4SlC0QGWoJgBMMVZM6Z2EJoDMFgo9VclKs82PDZ2aGZTiBoBTZV56eOTz/VXxXNYRFHywCemghKeYVAc4NXQDxKe0pp2FYjudZ+vl1VmCbTQL5ITJOYgWAjh2MmwRc6ziP00WrNWjKudPCa4AiZmpkVsxg3BBumdzWqlQVAmrBTbcTTCObYVJrlHBgwFViyKHY8Wno22caPREMYARraxs8BSlPArhS9+3ol5IOa2TTYMjVOO/VaCipCEAIk8B0KScUWiFS2mKPiiYajNasZtVRatWCnyNkzBmg0EeKcWFeEVRMqvTSYhzEcoT02IxrE8GfAV2hmGByBYolPceFXHbrvcOr6FVglra8TegdUGeYXLM7pyBaYRU1ix9fJqps5aCjUzBmC2xF6aXIGsDgYKiuEPoYUNJnOTYyOkNyFlvfkY4Rwh6eZc1RqvBGwiVhaDBRZEukZWJsInQWLPyLiggEgooEMAh+UEajEwymG2PiQqC1DMrfZExo3BHlqWtRmmcUHOZ96WenXkCrFTZoYqEtYn9MHohc4qrtb7mP8XhYMDVLabPSdSgGNlqgsFJhG4o+2pSxDmBTIK/L1LGhYdALl9WLpzFi3CX0UWiIsGp8TPeOpzxKZgWMtxIeLKhmYy6qI4zAn2jjrahBCcQXYo7snBh5EUFmmHQJKKsT6lqPlUODhy96bUcJYpFEym14Q3EhQEqWw2AYqw1CGdFhahqHABxAegZuWMADG1U6nmFK2JZxFYaBaNFYsOFvpFVghilSVK+0g1ukXgC6fTmcarJWgJ0sAppg4Aegh6BmiVySa/TX4GnQaRmuUUmlCNhji3YS6kUUjGKFdEbryQMAZMFmosuRCqJlabG00Bkg0mL5IVJWcJDCZj1GNoaMBJhmyyCqlMyxm1vRKsQiU6sHX1YhvLFqktNe3ow9oO0D62YYRJGCfTT4YiNBQJMtpj1VMWjo1Q+qT1Ek4kj9sddIUQY1KHuie8ZgiUACKyU23liFkC5FDIqKXJs6G9onhjFoEGkXWiHYMFQKTDfqQNU0VkCW9htNNSRTyYPekWRBE2TBItLxDEgTYkls0lIgrEVWmb6ijEYMi16BfaWZiwC4TsP/zaUbb19Q26GMIzFn6VA75ggUcAFpUr1jSEyBU1lSBSpimMj6WVNBUWDTgd91VchZCFAjvspS3NMwBK7yylKI0AqMf7KYVqKQLok3swtQdISQwbaSo1AmBdRd5oRSVKSVsJvtCApRkE22K61EmlkzbYpdZUSBXKHmo90JYJBUifS1axlEJFSpdBJoUwKOUi8stgjLIoxRXyAa0pAigVFtqINkyIAjS/ihNCbQ1ANbaUwRFkEwC1/NxBGiRIJrW8NAozAtpi9WwhAooi6DX1YEYSkAbdDtSqTObau8f3hWoIUlD3SeekSykWBP7q/DXJIxBVumgspViiMR62XQQlURRQb7LNaWUJFEnv0glqRMQgO/zy1DNkxYe//KacymRSl1/0IAraBCnR3+2sUts0NT/7qKkymjV8lvtOARRGFHa3fRpBltTVZ4LDEUBiArRq/kCabGCD9XZWTgoFCGz1bJZOiBgAdDSu5iLZgye/pAeFItjuE7+kaHm0cBDtvrVAFLZkAungtQhDIFaAfWUlBWSQTbofIUVxzIslttlmRQAohejXwQgFxSSbtSfKUQZCEgsMkmiIBXBnWzS2AZIVeCNrS7JiSUQvJ/2wfzYqxYC2eiSGJp01Sd5LJBUCzLWK3+AUpSEBVWD6wgvJkWTk/t7GYR215IU3tJpGLAK1BTezkyokm03VFrSgJmDPJFXktKFJSOsBlfVE1CoA3bG1bSwayTHJNLRvaQXbfm0X1UgoAEAfQDS1OgCScpdJTYWLBWQu10NppVIQGlb0yWUliCYDFfcJYiAQC7gBQACBj8A/3pAlYDx/DjDmfdtxiXXIoItuioAmZRGSA+6mAEhlCLTJ7aRKUiVElimsmAhZBC2KfxUhjFsk7o7/aSOiyQSvg/uxYnZJhOb3Wzks5MPVFDbcKiSSKfUs1kjBJQoddHyPcNMVpXbUb7jW2eVx/6VtURIRNBtvlUy4Jg4CWex1AAehhJQ7NBVMYDIMCkehFTCNCEKBaWzlbiig8FbPCJaACJg0E9piFgInBSSyKYgFgGVZPR7BSxW5BG8TssyJ5Q4h2ela8li1iVD7TJDW1RUCP0slU4TAVYm77A2BNA4VaN7ZUpmyBsVV89IgobKlpQb3DAAskDSFDvYyZU0LYFUWsqJMaJ2tFb2REEFFLywVvYyKMUJbpJWtrYE6I3hh1S1FEQMD6yH1DygQhQt5BLWyZNGBut1MNQpNQFLeyKWlEgQJAftRDKXKBpqt3lwsFdEWAH6SWEUlWIrAd7SDSkVQgst3sJMrRU1U26XUInFlVbIt7SKOKQWOth11RAzBNSa6zy1IE9CV4ptYccSjSDX0M2gZJKJhhXy2PDM0Fm3VFpaYiyKcHfVGtrHGQItW9WgydEnEV2aF5TRmCLhL5JU1KARBVMv1FZWpg4UW2Tw1gKWjIQr9RIU4qDFsp90IlXMgnKq12zglD2BYBfZAKQWCRHtEesJOJZAARwx64tQF2DNTpqbikcUZW1B3vHOIJUE+/q65knMmTZYZDZWQbiZPlg0mn+/vt6bEkTNowASXKkyjEUFrItd0BJJCAVsh9vUSmsYwKEIWImykmS8ZdFUh6EHYu+A/tyQwQGqe2W+Vi3JWz1LcKFWaT4YO0BltFokm4o62BayGJJDLD5aVHkXEXCKp1FGx5YDZguwoDLJFyI+TvaZ/RjV2hku94q+HJeqk3WmkSZpFrGypeiRQGBUdND8HGt5IVS0mHScGbIT1KEfAySLkyLVyQtqakmNPhSE3Xlnaom7VIFosBHBE/pZBvlJEEZZvhwojzluKYt15SSZYjXDIIoe4g9OCnwhsWIEWnnqU8QXnOQBwjBeO6cfBUJ6vggs9BwuOgzz4K+mnRdlzZ+cFDwgAgwEkCFMI56WE1X4GuvFYXDQpoIVLjQdl4oUCAqoYt048WDBiYcIXqSqrInVIC4htNckkilxkVw0auEjY0oamEOdhwj+UaddJcFozglAch2GO0XVwQeuHRNlURuCSFxeBB5JIvIMK5wqEYBQmg+ZWDPOZ84lPXGZ25rB3Iom4B0Q8mgHk2ZcWNUeFZ3RvG5diqUsszthiOGYAiTAUwYCnAWlSRwZUMDZTXDlbk2ydtyBOSWF2ETK2WDnAzsomHwcLCoIo1JFDx0KDyB2WAuxXTHqbI9QLVKZHrnB+M6H4R1DYEgbkghcmHLqR7VwPc6cvuUt15hiqF2wxi3EMA8koJcRRByBAKTatPF8J43iVtvzue6pbXVP2qJ1p0UbGhncHJooZUlCClzDHWkSexK7XIlNJS7ZBnZbJJuaBUbRxp5k0poqhEnUmxj80dPinrcdCsNEeppmuJkzVkuutHQlmQ8UzPiSd+iYt2Q/1oX0uB7Wmm+0S6xCGpszdTWNckzcPCAsZIEnItqTg7Uce3HHW4jF7OJtC3HYOS1pLcPZTlhgBWsqqlha3KB4aAfBTL5Zr/8IV1pL0NkB6FiuFEHTmissmVR0hqMWG/aJWzS2/BV7Xo+Y8n7jGJqkhLWBJawV+DaNqbW/BBb7s3a4n/XnV9Bw/Oav7zXZtQhsyGsGI1ilEyYEO3iQ2aibJEbbIj5Ywo8iFulIhtosynFLQokwF0g5WBHcwrAaI1sAWkgB9JoW6UXa0BQymQ7KCrqSDaUUB8ZHtnJ1rJhWSA7UgmbElt6EdNWRqUkV8rBcLZInYFWSsqTtgwpBV4RJfOQbqCvW+A9gKC2DNdWlqOskwxkOlcEPR2Y+ML/UJttpK13N/lbDecc1ygq+mQTBmBKCQNhXIh5aNvIlsxUKQcS+nn+QVTdWCZYRNpWWhpaCmBBsqJZUMiuxB2wIVLaMvNDH/gZVspN2hrl2KdKcMfTIxxJIlY0VDMQpUiDWOIvhEN9JNtQgKXc1wDIKU2zfEMZu0CTVZOkoCtDIlxGA/8laXszwE1/p8HtyStOUC0hMghYkgJIPVMqFsNaoUbdejbWwbAUS9oFSvbANKNK/JKJJsOjAEvAwXWwINSPR1DJkTL8ttteACCQkG2E6UZmTGQhfLDvkggggAkOv3uJNstReDgyG5LBkSRIJFdJis1TIKBCusBm/kovVNw3EHTaUFROgLgLh0gwgCAqsANuCIqKkX2aRX7abLMSDSSJZdI1uBRtGHhrAFPEhWeg63aDNJaNLTLHZIRmKIBPSqpS4OVsnrkF7GhjwGTPTbvbcqkBAptAlkNcyXMavOF+DGBSGy1iAZJWYgCEJsFHlkFQPJGrGd2/nWDACXhiCRkSUHIZwrSoiWFeilSCgC7mKFYaXLc5dDRvWVNrpJNHFKhXEbCkU7nmQUCRvWpbDgfJUjjslOhABipUywEErDgwAlCZOKBgkQIiVpgKFuMOu1XwQQQXyVCIic9EeJVJaKhAlwM8BscJwLOQmDw0rZ8SmqBCqYAKqACslyMCwUVpyXOQk10HDUTGnYie/Ni6dxs8lCHyiMlpWV6Gp9xHZRhm4ZO4ICs5jc4YpFquUFoqUJmYxTGJyiiU1o6XBK6VmqJRkLpVCliWCqOU2rB0Wk1ULJHBKYdicTiii43KqpHPwvEBALuAFAAIGAgR+FgLeQk17eUNmeQxB1+GXB9fik0zh4nsY9DutQEMmuExtCMpnEqCCJ6qcWRCN4OIBNGolMJ7g0T1UAjiVTuAEyOtQmlJQpqjJKKXSaDNoOl0bQJM3gCJC+H8BtA1bqLLZIbQGJKRirtEwATOzhJ2wid7GkHxirTAD7LAKgIBik0JkkBToDCW2gQ+kQ0ylYFOgLweZIYqj3JIhSBxnN2WGoXAlTwgE4MTNVWbDKKpmGSkAEDhMlmDEwGtQQnjynZFPU+dkQabmKksFFhOGliC1bEwyTg0xIRDQWdgSBdhezuGFrzC5pKF2GVWWCRxmnQYW5niBJBijlUEOqMKpCN0blwWZF4nBXbIJPycFJy8a/BnozPwfG97gcXpJUzrVXIwLwWFBgBbfF6kLcivEuxrlzCoPRuV7nUBh2YXTn5DdRsKBNmUDgR14bEXSGnwRIBYQYPABZDgdoPFeylDkIGEykUWEC4TkLIBv7gW0LbakzC2uvGZIEGSuDaAWEJiQIDrpVU5ETC6fF9gpWMzOhSGlySGw9BG0nN47k5CxT6JhPggOW4gtER3V1CQE1rYQoapRKogQK4VbukLdpqdhoiBzKgE5GBUmoYJioTQAoTRiglEC5NFlo9lXBRTDr8PmXdwsrRQoZ1actJO4HEp4AN3mYyBuw3CHXRCrjEYoze6cKGqqUCoQVZzM01CV4ilUX06XQB4RSqBeJuxeDgwdFp1VWgn42pSZHsNQKrBxudwbe43HiyNUYt86En5bim0gnblObqherghepqMKnBcSyFqTg1xLl2ouXHOYphSoDybdoWDuCMy5EN+gXUbpSYmjYCMbARKNiZod2GgjMlpnWp0DQ7gUxii1XGdTRErgSpTeELrAppjdlpo0TBpzmS3znbHQKbFi5VTeDqGAgGMP4NwGTJ0LGTSjHdicJtgodAKfhiCwtAXwuFyBIUziY2VHXzOCLgCrTMJdrMysAOgjVJrJBzud2ViVXEaFYS4FEBYeFKgOF1qWKhpB2Oly/hHcmunri6fiSFieCx2I1pPGmhz2xNI2hWEBnPfpICwWNQVdn+UkqaIZiVvQOpXklVdKmPcDqj2bAiDekUDgZCBqM1m2nQDtQ0fP3aYbLgcpSDAcnBgBAFoGOpjGIzo0yHL12ULJRM/lTbbbMLqCUFrUgRklQglWnGB5luYQm5Xw77DZHmWUupUH4plU3jSQAD0CmbICINycqAxWonNnoiexDVg3i1wgg01qVFAC7xWqSyCZjMKpyMxxElmmBwikQ1Gx2AarTk8ZBD4UsjkHUO5MDpmh0XAQxHHY1RDZyqflT5NXXyiPd5lOkxVZRgYyhL9TlcoiErjSo+SV5jCPzpdnoNhwmBWyGyzGlFSS7nU66jQWpGCmxdGrCVgmhQ2iTYHC1IgpPQqrgzKUWLmyXNwKMhTm52IS5Dl91SrtjOdwxc5YCmtNMInOhqSQ26SRMvxwI00Y7pmgrJJdY7OkChv0tVwMolVK7TzvGqyQZaz5S8ChqIBogAlwUN0Vg0UxTSYW3iJVbQ5rJAYdxGyx40JAqprEDVE82Ju02hjLIRrDKHqcDrsEGiwEBp1DUEkqgFRTKIFbpwWiXsqhCJjttYowkCDUWOWw1GYcZZsHLAABAKDhABA0awlESx2Mqq/c2kki3Y1XqPVTOPnsEBkhgF0YpqdUWhArOd83pcbcqXXgZBKhpeeLh0hmveYGGACSJUGjHRWs13u+9SMfNXLxthIeWKPLQTeD4WLAHDKTx6ONzKjhUJxtVJEqJ6GwYyw0HOUF3IrT7sbnRCTiop2cQBhI5iFcAbCBKYpQIYBZ4DXRsTrgBtdEJloAgd5CeiVKQ8SrnawriTAuQNKhFVN4ltEB8FwuWUw7YmKmXzpazRecnBggAM5INBAskZ+AY4u0EqKE3N6QqponZqAgtoodEAptQhl4dKGtug4cX+AQbqTHqJJhsIVFoh0EI141GuMwE0oGnawAJiVuohDdQkVxo03B1V3GO1QKw4iPG3jtOLeuxTKhIMRxMuJosJhHTc+qzneJ3h4qBbsDjoGb0uyUVQalB5xy8HqVEGAI3aoUNKBj4cbZ9pudpbmdRdq4jOEFmysxn4klQCjIsCddFqOwZkdBl1ikvD8h6CAOXRhZEAQ6RVRc5MERE2MQ0qAADY2+ckE7XRZSct7RgZCZwOpcsdYppRs2CwLRCI24mc4cNPoR4IecslNOtgg1RFkmVOWwcwjEm7SKVaieaUhWU5Pkua9KONuGAz0gEWsqVNBXquQrhmHZ4JquJFERElq4LwSgekEW4IIf6SCTAbKZ4qu1QhTkyxcE42rCOVy9WEQaITFRKpaYGAWElqpktNsEgKiGIYUTFeJT3lNcYMBVVdB7ru1MlJLLPiz9cLvilnTRRDGMJV1VOq6okAO0B52Kz32ztIQb2LSyJ55TyWMYlBp10NwxZRwES6fS2VoY4LbrM2ADbAGaYO8skpplbRkmyeeSIVEkVv9pXNVBYeCWNJIwJ7huHRRCGfy48oommZNVDZBLLZDQU2rjkDWRZ5KTik1wPPpkUjVV4UCRl3HWhht1l1gIxg/R3RvnPdg40TA7pTQx2yuUDsllRQx2PtRhSaSBUoGSUOX7lJNagrCTHAvYEZDBt5IgjCl2ZHGHkhdRDrZkFD3SPtxc8tFNyZGGGpe3qmQpEdZQMpW1DgAStiF0tOPo5tHSEK3AGS1FUoMqvgyqCQASjLfOKLsqVtGjDahGBVEuQEAu4AUAAgYAY/6yv7RA6b3ExQV37sM40KBdbgdKMKvSPVkqJNyANFBguAkS3Bu7EaZfiA6YjPYSF0EIuvONj5AnTECy1G6kkgLeEdhwVbwQloLU8gFsiJD6Uw2XiXSjEoqkroAjZWCRtHANrEOgqdAxCq2IH6Ai05MbNSE5YwLOrbfpZF/TLhWkA2AhSzCqUiyNqSHYWpvTKDorM1pIdhBgK8oWLkDXEGbDmB4gxbeQI0CImvJWhpJXRAjQJA6IEDdORbSUrbwQ2hDOtZNUiJHaoA2Xt7YnHLZN9WyRfqYdDEvsKQoEFBqQ2WWcAHoA2ZoPBCQHAAbUIAW1ZhVLLhUM27QVXsomVMFpqDDaMvQUwn2FlsAIkJcKi0k6gYSDEUFeLgZmPVcQEVCL+dkXnFGvS0W7I6mxkVKBjbIkFGYVFsRoXrRApBP3Vl6yXK4BUbcTZpQfRYHSlABGQZFzBhDZEFlIWIci0OJQcibLeZIQhOtEw1gMltMgmDEymIGwkClaCQJWMTCPOs/ZtsGXlNELSTS+ECWXDPFsR7SGXEkNCnZQXbCqvI+6EN+HEO1kjX8Rt7uvfOKPhCa8KBHiYQ28sWvMqClNzaGTfQSfuRNN9R11IDlnL0yAE+cIzUIGT+1VDGnCGCdNGR1ZKGvRlU4Ee2c6SDB/DABdSRbeTjBOa2KbIDKKlI0JWsLGUlaGDnbYMfMZL9ARttpkslCkMAw/EkmlBBTIzCJkFAKVLYKP9MtXsP32is3WgeDUjagUTaEUBWASakLLCbNEbD/do86ky3S3b2T2y/kvcaV7oR5LZ7D7Kl1YoMxIDA1DQC0yTRSbSZI5QZQMwFklMuFSCY4ii4EEpolAC0/RZhe0QICK0/wvgMZtokjfb/f1E4mIC775daEyKhZI/g9tkQkcF8vf6P0yw6y2StTDSexCQGDJBKIyJZNQMImlCkNIUqIaSQajSjBZBJLK4MIBRsFokgk8kNjECI2GSSAQKjYbqvJJstkNm9jtmkomkBCAAYnpCWiGzgKiSiWLPIpRmIxFKEkGU63akTAIiDBZbqIEKmAHHpDtPZHQaImVWa2AyWVRSdpvr7ZbJrvK2220FkMBEgg0CAEkhklCiEAQCgQKMYBHovnURkxp1skSiUkBCkiiiCQkUUMUKAKGFOCZhcm/08mKWXXXTW6yRvo7nNZ5fRaFlrJ5k4NlsIahYQ3HU+QmxDMQB5JrDuBERR5mAQgbLYUNkYUshgoghUYn4b9vq7/Jstt1lsksmkm262Wy2wWGR4PdtNbRaHAEun9AgsoEi8Q+yWYzIoiliARCSUSUSSSJIRKKDLDBBIXiJNJhMAoyBFcKCYSJPotGv8luMk2190f0SAalTb+fRt7Nodr/49fH1mm9muv0OgUQkBAEaAgkRGw0CUAhCgkGSYrQINhAQgVEkWA6qGmBhaBoZZtcIhIFBk2u1t0Wssa//X7fzW37Rft/v/LZNJTEGtqwgyRaKQQlBEltNoNMhwCik0202GUESSaLbbZbaYcttttNpttsh222k2mgChREEJpBFMkUO0WCQ2QwzSywBaQSiSDQQQKGKSBRJIhBCIZEllIglFIlhm0y0kykim2HbLaaJSTTLYZplIkkIEUkBTYYZdppbdNF19+/vu3110b/77/7bXa+x7vf/77vtddG+223u112v0bXXeWyzWWSxbJJBCICARBFAIkgIBkEksW22GS22237Rddvddd79tvF22uu+9+3/0e/fba/ff/fRvvffv99v/tG2+211891tgW2QUwwAE0UBiSUCQSCKSUEpJJAlBIBJIVBAigEEUlEhASSACKCAQQFFENhgMNFAEWGGK22WGmWRLDbZYJZACYEggAoBCCJJIYoAkpFFJJEhgiikikmkSiGSKSaaSaaSQYpJNJJppFFBkSUUSSQQQCEgAIAkAAskkNzUNowr/eFw/023AW27Q2FFBBBBAAIJAQhFAgkkEklBUUUUUiSkmUGTTSSSZZaTIdJEookhBIkhEEAAAAARBAC5+/oT+x5/8SSWW222zW2xLdbbNdbbddF1112uls1uka7XSzWyyyyw/7q//b1/7RA/9tH+/+/+8WWSW2WGWyyxNNLLbbrrbrGttuutt2ut0XXXXXX3a67RrprrpprrbbFtttsttssNgONBfwBa04JhCKKCCKKSQQGCBBBBBBBJIYkgkkAgkEEBSSCQQQSCCSFBFBAAgBEAoPmU3ySkzWBAv9eBrLEIZdBcWMcHZUPTQCGFshFtlJAQR2SOW2lT20BxbbbabbbSIQEEUUgiiggAyi2UyQKGbrBTIAhYDvtc8DX3SL/3Rb/wcD9pDv//fFA+vi738BU0AJokRJBFFFNgyU22uumwQGDZKKaTaIabYEAttKntklFA0kCEEmhR2xA1gJt+sGu1sLxT/2m/7wzQ/7Xf945o77Btc+sRCmxRoLHosottttJBCCKCSSCCQQFBJJJIIJBBIUkggkggggggm2202m22aGDaBSbTJKZJIEAJIK6mL76Qa59Dt/v9otD91Bj3givgwGimCgkAUppARW0RQmWgRyCAAIKbJPLYQAptI08kggkAiQYce87oAtD0t+++1+//8SSWWSy2WWWxbZZZZZZZbLEtttlltssssP/+7//b//+Qb//Jd/9rr/D+21+/hj30EBVw0gmw0yWQrYTHFTVf/bC3/uv///2/8SwwyyyWWyyQ///v///9t/FhhllkklllkWWWWWWWSSSQ/VH94rfPbaAQC7gBQACBgAAAAFAAQAA+3RDv3eIxoxBiktOAByaBAFoogEtIplpg2UO2yik2yRDTZZaabSYbYNJFttAttssg220k2220m2DIKbbabbbLYQggggkkggghCCCSQSSSSQIAAAAAAAAAAUEkkkkkkkkhSSSCSSSSSSFBBIIIIJBBAUEggEEAAAAAy022yym2ykCbZJbbbLTbQMstNpEttpJg22SGmmUUGWBIYaKFBaZJYNIIEFFCigkATFQCpbBZtvB2/++3v//38WWWWW2yyyyxLLLZZZZbLLIkkkkkkkkkkSyyyyy2222xbbLLZZZZZZFllsssstllkWWGGGGGGWWQ/P//f//9vvD/u3///u//0Db/7W37aaOQrtNdvbFFdoBqnssNjhgJoGAEgiAtIEpAkQQSigWGUiAJLSKSbbRbYNpNNttpNttAi02iU22mWmDTKSTSZTTaIBJtMoppEhhAUUCUkQSi0iBSaQIJRQQJIMEghIoUIsEAik0SUUkWGWDZQabTKLTKIJNNplNtlFJgmkU22EkmWUBRZJNOPOVPAIAQAEQSAgQwDBQYoAAYYKANdVMtmmhisKWW3XwxXSQwVXFTVVRQCIBoQJowYYwRQBDBBIM4MskASkUCGWSUEGBIAIQwopKEEAggAAEo448wzTDjlVTjTDAgJqpgIAMAAAxRU1TSwS2wdFFFBQDVTQBNdEJphoxpoDBAgAEkAUEgBDAADYqZLHBWENtmrrihgK+e7bb627bQtNNtZDNFYoDnuljm192/8KaXXa3b/a2wrrrDLbDTVFANEssMElhogGKGnGGQESGAaADVRRBJBTBVeONMWOAAAEkigAgg04YQRAKCIYQRAAAJIgoIIBopAAQEEkAIlAkgSkSUk0SUUkBRSaZRSaaSYJtpJJJhDhlAUU02mW20y0CbSLTbbbbbYItNtttNtpJgm2UWmmGWmmBSTTRYZaaLQNpEotMscMoAgSSiSEUjjQAQJxwJEBppgGWCiCKnGGWAYbdrdHbrrrD20cd20123sG6+/bbffXaw7vHfv9fvv/Cv3+9+/+930P3z337ae/XwHdttNPdbZrB1sUVmhks0MFV11ZVQwAiAIACJFTQaaIBABoKCJRSSIEpJFFJNMotAmky0mUSyykBKLRRSSRQRYJIpJNMsNJEggiUQg0ygSEARBKRQJBJQQAkokAkkkY8QgABCCIIQQAAOONMAIpqy4GmmiACWQCWAqqYopJFHXFAU10tut1tu0LTT3X333/ew9/trtvtbrtB00cd1t121sHb3W6662zXQdbbddNHddNAU1kgsUMElsGGqGWWmKGAABBDjTJaaYYBgAANXNEgowCiEEEAAkkgASSCKcCRQSSCBBJRIJKLCIFlkklhhAlFAUSSigQUUSSAZaKLLLCJRQIIMssspNMIgkWGEUkiUWWBRKLSRZaTCIJJIopJIlJMgykWkiUkyyiDLLGHDKRRZYIpJplhhlhAgUUUCUUCCSSBBBKCGGCCBAIIgE4YEABAgIaaADTQAIYBpzzyxhhlhgKKGGKKWCWWAqopbLFNLFVAU0MNttlt10GKOKWy2622wrbLLNHlTJYBgMUVMMsUMEGWGmGWWGKKgaYYqaADTjTAFhpiihhltkCmqiAAASAEwVjjTVDRAacBwogBIJxpCAAjBCmmCgAUASCKKAQIIQQAABBAIQJIIQBAgnAkAAhAgASCAIIAIJBBNMMNEEEONMAwwWW2Sy22QJbbLJZbFVDBmhhuut111sGa622W26KXQNbbddddd77Cu222v29110LXTbba6+++QprrrbddZbdBuiimlkUUtkC22WCGGGiiAKCCQQSiQSUBRJKKJJLDKIFJJIspJlFpAyykk0y022mCabTSbbaabYNtNNtptNtpg2222m22m02DbTbbaabbbQNNttNtttttg202222m22mDTbbSbbTSaYNJJMtJFlpIAiiSSSUQRQgCBIJJIooIpoGnGmCU1V1UwDLLDDLYqpbAsstuls01ugO7XXbfe6++wtdr77r79tdC222v3199+8Lbb/7fff/7wv/979/vvv9Dvv3+9+++20L77a/fb37ew7rttrrtvbbC088c910110G6Oa2y222KgpbDDNHDYppBhhlkNVUMkgGGGimmAUQwwRRIaaKaaAQAAgBFNOOFFEIEgAAgAQAEQVTRQAASQAIAoAAgAAggIIAAAgAQUEAAAQgCKCAAAQgAIoJAAIJIAIEkEUgkAAEIAQQSSCEUGeCCKRJRRQQYZQIossopJMspAkkkWWki02kDLLTLLTaTLQJtMtNtNNNtA0022002002DbaabbaaaaYJNNpJlptMtA2kk000mk0kCSSSRRZSKJQIsIYIkghBjAKCCCAQgjjhBAAghFNNFAECGmqKWyKuKAYo66qopoorB001uutt11sKee663z3W7Qtdddfdb77tA2vuuvvuuu0Ha2666y3a2wdbrrbrrrrrCutt11stt0sC3W22222WOArZbrbbJbbZBmttlt0thigKKmGxVQxxVQVDLDTDLVlVANNMMMAhksEAQw00SSQQRQVjAYYIBDBBABqooEEAoqoKmmmGiA1U0QQIKKIYYcaYAgAANNAAgAAEAQEAAAAgAQACAAAQQQCEAIIoJAAIIIAEIEggoIEEIAhQECQQCggSAJRQJKKJJRQFAkolBEopBAEiiSUiiUUiCKDDKKKSSRIIsoklFEklFAiSUiiEEiSSBKKCCKJJJKIBALuAFAAIGAACAAMABQAF8fkSz+MTHu8IIFFEEkokhACiSCCQQCCSAIIJRIJJJBAEkkEEkkEEkgCCEECCEECCAJIIBIQooJAEUUgggEIEAACCKaKABABRAAgAIggAAEEAAGqmmmGCAQBBABDTTRDBAEAhpppqppoGCCAAwQCCSQABDBBBDBBBAMEEEMEEEMMA0ww00ww00wDDTTDIaaqqBpphgNUNhkMAySGGGQ0wywDDDJIYZbFFAUVUNmiiimgKGW2yzTSyywbZbNHHVHFNAttttlt0000G26Ka22222wbdNbbbbbZpClsUVtssttkGKaaKKaaKug4oZLFDDDLDBMMMBypggAgCGiiGigAAAgCKaKARTQQAAAJBBAJBBGEIEAgkggkIEAAQgQQQiSCEAQIIQQJCCJIAkkkEkkoEIAgSEESSQiiSBJJJBJRJJJIEkkIMoEookgSUUCQgSSQSCCBJJQJCJQQBBEkhFEkklAUCSUECQiSQBJJJIJJJBJQBAklBAkIIEAQQgQQgiSSUBJCCJIIJJJAEkoIYEkggkgSCSSSQCQhhBBJIBBIJBBIEAAEgiiggAAAAABBQTTTRBNNNFAhogNMAQAGmiCGqmgYYYYLFDIYoCqhhksMMsloKGwwWKKKKKQoooopbHHFFAUUtijikttsG22222y22zQNbbbbbbLNbBlmjiksUdUMCx1VQyWGCSQIIYYYBDDDTAMMNNMNNEEMEUU00UQHLCgAIAABBAAAIAoAAAFEEFOMI00UAAUUAQQAABDRAIIAAABpogggAAEEAAAGnGiAQAABDTjTTjjRBABFNFAAAAIwCgEEEAEIY4QQCKIRhQAQQBBAIIABBBAIAggAEEEAgggRQSQgSSSQSBJCBJKCBJJIEEIkkgkkgkAgiEOCQggiiBIRKCBJKJJIEkkkookkokgSSSSQSSSSSBIIJCCBCCIQAkhBAkkkgggSSCCSQQSSSAIJIIIIIBFAAggAggAAAEQRRQCaaAIIBBEENVMMMNNMCw0wxVVVQ2AYZZZYopZLLBssMttlimlkGWaKSy2WWWQbZYoooopppBltssUUUVUMGKGW2WWWWywDFFFVFFFDFAUMMUUVUUVUAwyySSyWGGAoYJYqoYYqqBphhgglhppgGGmiCAU000wTRBAABBAABAEAAAgBEAAAAAAAEAAAAAAAARRRQQRQCAoAAIIAABAIAgkEEEIEAggCCMMCCASSCAIJAIIJBAIIAgEEEEAgggAAQQCCCCAAQBAABBAABBAAAEEAAAggAEAQAAQRQQQhQAIBBABBBFAIAEEEEAAEEEQQCAAACCAACAIABBBFBBBAAgkEEEkAEEAQThQCKAQAAABBAAAAAAAIAAAAAigEUUwRQAAAAAAACAAAIoAAAIooCgE0QjHGiEwjRAARRQCAAAAIoooBEAIAAACnGmnHGmgccaIBAAIKKBppogNWWNMEAQCGmmmmmmgaYaaIaaaYYBppqppppgkEAQ00wSGmmGAYIJJDTBJDTAMMMEhgggkME0www0wSGCAJJBBDDDTBJANMMMEEMNNEAQGiAwwCmmgaaYIKaIIAAAggAAEEAAEEAAAQQiAU44wTTjjTTjjRBBFNNEAAAAAACCAAAAAAAAQTjRAKKIIAAAggAAEFAAgoCimmiAQQAAAIIAAIIAABBBFEAggANONME00QGmiAQQAAAIIAAIIABAEAAAgooAEAAAAQUUAAAigIAAAAAAAAAAAAAAAAAAIoAEUAiggggAgCCKCCCAQQQAIIJBBBBBAIAggAEEEEEEAQCCCCCCAQABBAAIIIoBAAAAEEAAAAAAAARQCKKaKAAAAAAAAAAAAAAAAAAAAU44wRAAAAAAAAAAAAAAAAAAAAAAAAAUUU0UQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACnHGmigACmgIAAAAAKaKaBppoggpogkAAQ00QCCAU0wBBDVTTTBIIAhhhqyqpgkkCSGqmCSWGCQDDDDDDDDDDAMMMMMMMMMMAwwwwwwwwwwDDDDDDDDDDAMMMMMMNNMMACCCGCA1U0wTTBBDDAIDTBNNEEAAAApwHGiAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEUAiiiAEAAAAQACAAAAAAAAAAIABBAAAAAAAAAAAAAAAAAAAAACAABBAAABAAIAEY44UEAAEARQQQCKCCAQBBAAAIIBGFAEEEEEEEEEggECQQQSCCCCAIIIIIIJBBAEEEEEEEEEEAQQSCQQSCCCAIIIIIIIBBAEAAggAAEAAARQAAAAAAAAAAAAAAAAAEEEUQCCCmmmiAJBAIJDTTDDANVMEkkkkkMAwQwwww1UwQJDDDVVVVTBAsNMMEMMMMMAwwww1UwSSQJJIYYaqqYYAhhhhgkNNVUEww1UwGmA0wTTTAIIIaaaBppppggggggCCCGmmmCCGgaaaaaaIDTRAAggFNEEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAu4AOBwW4AAEAAQABAAH0shPQ5kAgKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKaIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU0QCAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAACigKKKKKKKKKKAopxoggAAAEE0QGmiA00QAIIAAAKaIAAAAAFNEAppooCCAAACAACmgaIAIKKIBBAAAgAAgEAoooCiiiAAACmiAIBTRBAAABBBFFEAAAEAAEE40QAQUUUUQRRTjRAAAKaAgFNEApogEAAAUQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACmiAAIAAIBAKIBTBNNNNNNNNNME000000000wRBBAaaaaIIAggggggAFNEAAQQACCnGiAAAAAKaIAKaAgAAAAApogAAAAAAAAAU0QAABTRAIAAKAgAAAgoopogAQQCmiCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAU0QAU0QBBAaaaaIBBAAgggggNNNME000000000wTTTTTRBBAKBpppogAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==`)
-
-	console.time('qoa first')
-	let audioBuffer = await decodeAudio(qoa)
-	console.timeEnd('qoa first')
-
-	console.time('qoa second')
-	audioBuffer = await decodeAudio(qoa)
-	console.timeEnd('qoa second')
-	is(Math.floor(audioBuffer.duration * 100) / 100, 0.82, 'qoa duration')
-})
-
-t('malformed data', async t => {
-	let log = []
-	try {
-		let x = await decodeAudio(new Float32Array(10))
-	} catch (e) { log.push('arr') }
-
-	try {
-		let x = await decodeAudio(null)
-	} catch (e) { log.push('null') }
-
-	try {
-		let x = await decodeAudio(Promise.resolve())
-	} catch (e) { log.push('nonbuf') }
-
-	is(log, ['arr', 'null', 'nonbuf'])
-})
-
-t.skip('sequence #38', async t => {
-	let flacBuffer = await decoders.flac(new Uint8Array(flac))
-	is(flacBuffer.duration | 0, 12, 'flac duration')
-
-	let mp3Buffer = await decoders.mp3(new Uint8Array(mp3))
-	is(mp3Buffer.duration | 0, 12, 'mp3 duration')
+import t, { is } from 'tst';
+import { readFileSync } from 'fs';
+
+const qoa = readFileSync(new URL('./fixtures/qoa-sample.qoa', import.meta.url))
+const m4a = readFileSync(new URL('../audio-lena/lena.m4a', import.meta.url))
+
+const dur = r => r.channelData[0].length / r.sampleRate
+const rms = f32 => { let s = 0; for (let i = 0; i < f32.length; i++) s += f32[i] * f32[i]; return Math.sqrt(s / f32.length) }
+const near = (a, b, tol = 0.02) => Math.abs(a - b) < tol
+
+// -- whole-file decode with content verification --
+
+t('wav', async () => {
+	let r = await decode(wav)
+	is(r.channelData.length, 1)
+	is(r.sampleRate, 44100)
+	is(near(dur(r), 12.27), true, 'duration')
+	is(near(rms(r.channelData[0]), 0.13, 0.01), true, 'rms')
+})
+
+t('mp3', async () => {
+	let r = await decode(mp3)
+	is(r.channelData.length, 2)
+	is(r.sampleRate, 44100)
+	is(near(dur(r), 12.27), true, 'duration')
+	is(near(rms(r.channelData[0]), 0.13, 0.01), true, 'rms')
+})
+
+t('ogg vorbis', async () => {
+	let r = await decode(ogg)
+	is(r.sampleRate, 44100)
+	is(near(dur(r), 12.27), true, 'duration')
+	is(near(rms(r.channelData[0]), 0.13, 0.01), true, 'rms')
+})
+
+t('flac', async () => {
+	let r = await decode(flac)
+	is(r.sampleRate, 44100)
+	is(near(dur(r), 12.27), true, 'duration')
+	// flac is lossless, must match wav exactly
+	is(near(rms(r.channelData[0]), 0.1298, 0.001), true, 'rms lossless')
+})
+
+t('opus', async () => {
+	let r = await decode(opus)
+	is(r.sampleRate, 48000)
+	is(near(dur(r), 12.27), true, 'duration')
+	is(near(rms(r.channelData[0]), 0.12, 0.02), true, 'rms')
+})
+
+t('m4a', async () => {
+	let r = await decode(m4a)
+	is(r.channelData.length, 2)
+	is(r.sampleRate, 44100)
+	is(near(dur(r), 12.27), true, 'duration')
+	is(rms(r.channelData[0]) > 0.05, true, 'has audio content')
+})
+
+t('qoa', async () => {
+	let r = await decode(qoa)
+	is(near(dur(r), 0.82, 0.05), true, 'duration')
+	is(r.channelData.length >= 1, true, 'channels')
+})
+
+t('uint8array input', async () => {
+	let r = await decode(new Uint8Array(wav))
+	is(near(dur(r), 12.27), true)
+})
+
+t('buffer input', async () => {
+	let r = await decode(Buffer.from(wav))
+	is(near(dur(r), 12.27), true)
+})
+
+// -- streaming via decoders --
+
+t('stream mp3', async () => {
+	let dec = await decoders.mp3()
+	let r = await dec.decode(new Uint8Array(mp3))
+	is(r.channelData.length > 0, true)
+	is(r.channelData[0].length > 0, true)
+	is(r.sampleRate, 44100)
+	await dec.decode()
+})
+
+t('stream wav', async () => {
+	let dec = await decoders.wav()
+	let r = await dec.decode(new Uint8Array(wav))
+	is(r.channelData[0].length > 0, true)
+	is(r.sampleRate, 44100)
+})
+
+t('stream flac', async () => {
+	let dec = await decoders.flac()
+	let r = await dec.decode(new Uint8Array(flac))
+	is(r.channelData[0].length > 0, true)
+	await dec.decode()
+})
+
+t('stream opus', async () => {
+	let dec = await decoders.opus()
+	let r = await dec.decode(new Uint8Array(opus))
+	is(r.channelData[0].length > 0, true)
+	await dec.decode()
+})
+
+t('stream oga', async () => {
+	let dec = await decoders.oga()
+	let r = await dec.decode(new Uint8Array(ogg))
+	is(r.channelData[0].length > 0, true)
+	await dec.decode()
+})
+
+t('stream m4a', async () => {
+	let dec = await decoders.m4a()
+	let r = await dec.decode(new Uint8Array(m4a))
+	is(r.channelData.length > 0, true)
+	is(r.channelData[0].length > 0, true)
+	is(r.sampleRate, 44100)
+	await dec.decode()
+})
+
+// -- flush / free lifecycle --
+
+t('double flush', async () => {
+	let dec = await decoders.mp3()
+	await dec.decode(new Uint8Array(mp3))
+	await dec.decode()
+	let r = await dec.decode()
+	is(r.channelData.length, 0)
+	is(r.sampleRate, 0)
+})
+
+t('free without flush', async () => {
+	let dec = await decoders.mp3()
+	await dec.decode(new Uint8Array(mp3))
+	dec.free()
+	let r = await dec.decode()
+	is(r.channelData.length, 0)
+})
+
+t('decode after free throws', async () => {
+	let dec = await decoders.mp3()
+	dec.free()
+	let threw = false
+	try { await dec.decode(new Uint8Array(mp3)) } catch { threw = true }
+	is(threw, true)
+})
+
+t('double free is safe', async () => {
+	let dec = await decoders.flac()
+	dec.free()
+	dec.free()
+})
+
+// -- EMPTY immutability --
+
+t('empty result is immutable', async () => {
+	let dec = await decoders.mp3()
+	await dec.decode()
+	let r = await dec.decode()
+	let threw = false
+	try { r.sampleRate = 999 } catch { threw = true }
+	is(threw, true)
+	try { r.channelData.push(new Float32Array(1)) } catch { threw = true }
+	is(threw, true)
+})
+
+// -- input validation --
+
+t('rejects string', async () => {
+	let threw = false
+	try { await decode('hello') } catch (e) { threw = e instanceof TypeError }
+	is(threw, true)
+})
+
+t('rejects null', async () => {
+	let threw = false
+	try { await decode(null) } catch { threw = true }
+	is(threw, true)
+})
+
+t('rejects number', async () => {
+	let threw = false
+	try { await decode(42) } catch { threw = true }
+	is(threw, true)
+})
+
+t('rejects non-audio buffer', async () => {
+	let threw = false
+	try { await decode(new Uint8Array(100)) } catch (e) { threw = e.message.includes('Unknown audio') }
+	is(threw, true)
+})
+
+// -- concurrent decoders --
+
+t('concurrent decoding', async () => {
+	let [r1, r2, r3] = await Promise.all([
+		decode(mp3),
+		decode(flac),
+		decode(ogg),
+	])
+	is(near(dur(r1), 12.27), true, 'mp3 concurrent')
+	is(near(dur(r2), 12.27), true, 'flac concurrent')
+	is(near(dur(r3), 12.27), true, 'ogg concurrent')
+})
+
+t('concurrent stream decoders', async () => {
+	let [d1, d2] = await Promise.all([decoders.mp3(), decoders.flac()])
+	let [r1, r2] = await Promise.all([
+		d1.decode(new Uint8Array(mp3)),
+		d2.decode(new Uint8Array(flac)),
+	])
+	is(r1.channelData[0].length > 0, true)
+	is(r2.channelData[0].length > 0, true)
+	await Promise.all([d1.decode(), d2.decode()])
+})
+
+// -- zero-length / edge cases --
+
+t('zero-length buffer', async () => {
+	let threw = false
+	try { await decode(new ArrayBuffer(0)) } catch { threw = true }
+	is(threw, true)
+})
+
+t('minimal invalid buffer', async () => {
+	let threw = false
+	try { await decode(new Uint8Array([0])) } catch { threw = true }
+	is(threw, true)
+})
+
+// -- decodeStream --
+
+t('decodeStream mp3', async () => {
+	let chunks = [new Uint8Array(mp3)]
+	async function* gen() { for (let c of chunks) yield c }
+	let total = 0
+	for await (let r of decodeStream(gen(), 'mp3')) {
+		is(r.sampleRate > 0, true)
+		total += r.channelData[0].length
+	}
+	is(total > 0, true, 'decoded samples')
+})
+
+t('decodeStream ReadableStream', async () => {
+	let data = new Uint8Array(wav)
+	let stream = new ReadableStream({
+		start(ctrl) { ctrl.enqueue(data); ctrl.close() }
+	})
+	let total = 0
+	for await (let r of decodeStream(stream, 'wav')) {
+		is(r.sampleRate, 44100)
+		total += r.channelData[0].length
+	}
+	is(total > 0, true)
+})
+
+t('decodeStream m4a', async () => {
+	async function* gen() { yield new Uint8Array(m4a) }
+	let total = 0
+	for await (let r of decodeStream(gen(), 'm4a')) {
+		is(r.sampleRate, 44100)
+		total += r.channelData[0].length
+	}
+	is(total > 0, true)
+})
+
+t('decodeStream unknown format', async () => {
+	let threw = false
+	try { for await (let _ of decodeStream([], 'xyz')) {} } catch { threw = true }
+	is(threw, true)
+})
+
+// -- decoders extensibility --
+
+t('custom decoder registration', async () => {
+	decoders.test = async () => ({
+		decode: async (chunk) => ({ channelData: [new Float32Array(chunk.length)], sampleRate: 8000 }),
+		free() {}
+	})
+	let dec = await decoders.test()
+	let r = await dec.decode(new Uint8Array(10))
+	is(r.sampleRate, 8000)
+	is(r.channelData[0].length, 10)
+	delete decoders.test
 })

package/.eslintrc.json

@@ -1,43 +0,0 @@
-{
-    "env": {
-        "browser": true,
-        "node": true,
-        "commonjs": true,
-        "es6": true
-    },
-    "extends": "eslint:recommended",
-    "rules": {
-        "strict": 2,
-        "indent": 0,
-        "linebreak-style": 0,
-        "quotes": 0,
-        "semi": 0,
-        "no-cond-assign": 1,
-        "no-constant-condition": 1,
-        "no-duplicate-case": 1,
-        "no-empty": 1,
-        "no-ex-assign": 1,
-        "no-extra-boolean-cast": 1,
-        "no-extra-semi": 1,
-        "no-fallthrough": 1,
-        "no-func-assign": 1,
-        "no-global-assign": 1,
-        "no-implicit-globals": 2,
-        "no-inner-declarations": ["error", "functions"],
-        "no-irregular-whitespace": 2,
-        "no-loop-func": 1,
-        "no-multi-str": 1,
-        "no-mixed-spaces-and-tabs": 1,
-        "no-proto": 1,
-        "no-sequences": 1,
-        "no-throw-literal": 1,
-        "no-unmodified-loop-condition": 1,
-        "no-useless-call": 1,
-        "no-void": 1,
-        "no-with": 2,
-        "wrap-iife": 1,
-        "no-redeclare": 1,
-        "no-unused-vars": ["error", { "vars": "all", "args": "none" }],
-        "no-sparse-arrays": 1
-    }
-}

package/.travis.yml

@@ -1,13 +0,0 @@
-sudo: false
-language: node_js
-node_js:
-  - 'node'
-  - '6'
-  - '5'
-  - '4'
-matrix:
-  fast_finish: true
-  allow_failures:
-    - node_js: "4"
-    - node_js: "5"
-