tone 15.2.0 → 15.2.2

package/Tone/core/clock/TransportRepeatEvent.test.ts

@@ -4,8 +4,8 @@ import { TransportClass } from "./Transport.js";
 import { TransportRepeatEvent } from "./TransportRepeatEvent.js";
 
 describe("TransportRepeatEvent", () => {
-	it("can be created and disposed", () => {
-		return Offline((context) => {
+	it("can be created and disposed", async () => {
+		await Offline((context) => {
 			const transport = new TransportClass({ context });
 			const event = new TransportRepeatEvent(transport, {
 				duration: 100,
@@ -16,8 +16,8 @@ describe("TransportRepeatEvent", () => {
 		});
 	});
 
-	it("generates a unique event ID", () => {
-		return Offline((context) => {
+	it("generates a unique event ID", async () => {
+		await Offline((context) => {
 			const transport = new TransportClass({ context });
 			const event = new TransportRepeatEvent(transport, {
 				time: 0,
@@ -27,8 +27,8 @@ describe("TransportRepeatEvent", () => {
 		});
 	});
 
-	it("is removed from the Transport when disposed", () => {
-		return Offline((context) => {
+	it("is removed from the Transport when disposed", async () => {
+		await Offline((context) => {
 			const transport = new TransportClass({ context });
 			const event = new TransportRepeatEvent(transport, {
 				time: 0,

package/Tone/core/context/Context.test.ts

@@ -279,20 +279,19 @@ describe("Context", () => {
 			}, 0.01);
 		});
 
-		it("is invoked in the offline context", () => {
+		it("is invoked in the offline context", async () => {
 			let invocationCount = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				context.setInterval(() => {
 					invocationCount++;
 				}, 0.01);
-			}, 0.051).then(() => {
-				expect(invocationCount).to.equal(4);
-			});
+			}, 0.051);
+			expect(invocationCount).to.equal(4);
 		});
 
-		it("is invoked in with the right interval", () => {
+		it("is invoked with the right interval", async () => {
 			let numberOfInvocations = 0;
-			return Offline((context) => {
+			await Offline((context) => {
 				let intervalTime = context.now();
 				context.setInterval(() => {
 					expect(context.now() - intervalTime).to.be.closeTo(
@@ -302,9 +301,8 @@ describe("Context", () => {
 					intervalTime = context.now();
 					numberOfInvocations++;
 				}, 0.01);
-			}, 0.051).then(() => {
-				expect(numberOfInvocations).to.equal(4);
-			});
+			}, 0.051);
+			expect(numberOfInvocations).to.equal(4);
 		});
 	});
 

package/Tone/core/context/Context.ts

@@ -373,7 +373,9 @@ export class Context extends BaseContext {
 		const workletPromise = this.rawContext.audioWorklet.addModule(url);
 
 		this._workletPromises.add(workletPromise);
-		workletPromise.finally(() => this._workletPromises.delete(workletPromise));
+		workletPromise.finally(() =>
+			this._workletPromises.delete(workletPromise)
+		);
 
 		return workletPromise;
 	}
@@ -561,9 +563,11 @@ export class Context extends BaseContext {
 	private _timeoutLoop(): void {
 		const now = this.now();
 		this._timeouts.forEachBefore(now, (event) => {
-			// invoke the callback
-			event.callback();
-			this._timeouts.remove(event);
+			try {
+				event.callback();
+			} finally {
+				this._timeouts.remove(event);
+			}
 		});
 	}
 

package/Tone/core/context/Destination.test.ts

@@ -26,13 +26,12 @@ describe("Destination", () => {
 		});
 	});
 
-	it("passes no audio when muted", () => {
-		return Offline((context) => {
+	it("passes no audio when muted", async () => {
+		const buffer = await Offline((context) => {
 			new Oscillator().toDestination().start(0);
 			context.destination.mute = true;
-		}).then((buffer) => {
-			expect(buffer.isSilent()).to.equal(true);
 		});
+		expect(buffer.isSilent()).to.equal(true);
 	});
 
 	it("has a master volume control", () => {

package/Tone/core/context/Offline.test.ts

@@ -16,63 +16,45 @@ describe("Offline", () => {
 		return ret;
 	});
 
-	it("generates a buffer", () => {
-		return Offline(noOp, 0.01).then((buffer) => {
-			expect(buffer).to.be.instanceOf(ToneAudioBuffer);
-		});
+	it("generates a buffer", async () => {
+		const buffer = await Offline(noOp, 0.01);
+		expect(buffer).to.be.instanceOf(ToneAudioBuffer);
 	});
 
-	it("silent by default", () => {
-		return Offline(noOp, 0.01, 1).then((buffer) => {
-			const isSilent = buffer.toArray().every((sample) => sample === 0);
-			expect(isSilent).to.equal(true);
-		});
+	it("silent by default", async () => {
+		const buffer = await Offline(noOp, 0.01, 1);
+		const isSilent = buffer.toArray().every((sample) => sample === 0);
+		expect(isSilent).to.equal(true);
 	});
 
-	it("records the master output", () => {
-		return Offline(() => {
+	it("records the master output", async () => {
+		const buffer = await Offline(() => {
 			new ToneOscillatorNode().toDestination().start();
-		}, 0.01).then((buffer) => {
-			const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
-			expect(testBuff.isSilent()).is.equal(false);
-		});
+		}, 0.01);
+		const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
+		expect(testBuff.isSilent()).is.equal(false);
 	});
 
-	it("returning a promise defers the rendering till the promise resolves", () => {
+	it("returning a promise defers the rendering till the promise resolves", async () => {
 		let wasInvoked = false;
-		return Offline(() => {
+		const buffer = await Offline(() => {
 			new ToneOscillatorNode().toDestination().start();
 			return new Promise((done) => {
 				setTimeout(done, 100);
 			}).then(() => {
 				wasInvoked = true;
 			});
-		}, 0.01).then((buffer) => {
-			const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
-			expect(wasInvoked).is.equal(true);
-			expect(testBuff.isSilent()).to.equal(false);
-		});
+		}, 0.01);
+		const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
+		expect(wasInvoked).is.equal(true);
+		expect(testBuff.isSilent()).to.equal(false);
 	});
 
-	it("can schedule specific timing outputs", () => {
-		return Offline(() => {
+	it("can schedule specific timing outputs", async () => {
+		const buffer = await Offline(() => {
 			new ToneOscillatorNode().toDestination().start(0.05);
-		}, 0.1).then((buffer) => {
-			const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
-			expect(testBuff.getTimeOfFirstSound()).to.be.closeTo(0.05, 0.0001);
-		});
+		}, 0.1);
+		const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
+		expect(testBuff.getTimeOfFirstSound()).to.be.closeTo(0.05, 0.0001);
 	});
-
-	// it("can schedule Transport events", () => {
-	// 	return Offline(function (Transport) {
-	// 		var osc = new Oscillator().toDestination();
-	// 		Transport.schedule(function (time) {
-	// 			osc.start(time);
-	// 		}, 0.05);
-	// 		Transport.start(0);
-	// 	}, 0.1).then((buffer) => {
-	// 		BufferTest(buffer);
-	// 		expect(buffer.getFirstSoundTime()).to.be.closeTo(0.05, 0.001);
-	// 	});
-	// });
 });

package/Tone/core/context/OfflineContext.test.ts

@@ -25,39 +25,37 @@ context("OfflineContext", () => {
 		return ctx.close();
 	});
 
-	it("can render audio", () => {
+	it("can render audio", async () => {
 		const ctx = new OfflineContext(1, 0.2, 44100);
 		const osc = ctx.createOscillator();
 		osc.connect(ctx.rawContext.destination);
 		osc.start(0.1);
-		return ctx.render().then((buffer) => {
-			expect(buffer).to.have.property("length");
-			expect(buffer).to.have.property("sampleRate");
-			const array = buffer.getChannelData(0);
-			for (let i = 0; i < array.length; i++) {
-				if (array[i] !== 0) {
-					expect(i / array.length).to.be.closeTo(0.5, 0.01);
-					break;
-				}
+		const buffer = await ctx.render();
+		expect(buffer).to.have.property("length");
+		expect(buffer).to.have.property("sampleRate");
+		const array = buffer.getChannelData(0);
+		for (let i = 0; i < array.length; i++) {
+			if (array[i] !== 0) {
+				expect(i / array.length).to.be.closeTo(0.5, 0.01);
+				break;
 			}
-		});
+		}
 	});
 
-	it("can render audio not async", () => {
+	it("can render audio not async", async () => {
 		const ctx = new OfflineContext(1, 0.2, 44100);
 		const osc = ctx.createOscillator();
 		osc.connect(ctx.rawContext.destination);
 		osc.start(0.1);
-		return ctx.render(false).then((buffer) => {
-			expect(buffer).to.have.property("length");
-			expect(buffer).to.have.property("sampleRate");
-			const array = buffer.getChannelData(0);
-			for (let i = 0; i < array.length; i++) {
-				if (array[i] !== 0) {
-					expect(i / array.length).to.be.closeTo(0.5, 0.01);
-					break;
-				}
+		const buffer = await ctx.render(false);
+		expect(buffer).to.have.property("length");
+		expect(buffer).to.have.property("sampleRate");
+		const array = buffer.getChannelData(0);
+		for (let i = 0; i < array.length; i++) {
+			if (array[i] !== 0) {
+				expect(i / array.length).to.be.closeTo(0.5, 0.01);
+				break;
 			}
-		});
+		}
 	});
 });

package/Tone/core/context/Param.test.ts

@@ -308,9 +308,9 @@ describe("Param", () => {
 	});
 
 	context("apply", () => {
-		it("can apply a scheduled curve", () => {
+		it("can apply a scheduled curve", async () => {
 			let sig;
-			return Offline((context) => {
+			const buffer = await Offline((context) => {
 				const signal = new Signal();
 				sig = signal;
 				signal.setValueAtTime(0, 0);
@@ -325,20 +325,18 @@ describe("Param", () => {
 				return atTime(0.4, () => {
 					signal.apply(source.offset);
 				});
-			}, 2).then(async (buffer) => {
-				for (let time = 0.41; time < 2; time += 0.1) {
-					expect(buffer.getValueAtTime(time)).to.be.closeTo(
-						sig.getValueAtTime(time),
-						0.01
-					);
-				}
-				document.body.appendChild(await Plot.signal(buffer));
-			});
+			}, 2);
+			for (let time = 0.41; time < 2; time += 0.1) {
+				expect(buffer.getValueAtTime(time)).to.be.closeTo(
+					sig.getValueAtTime(time),
+					0.01
+				);
+			}
 		});
 
-		it("can apply a scheduled curve that starts with a setTargetAtTime", () => {
+		it("can apply a scheduled curve that starts with a setTargetAtTime", async () => {
 			let sig;
-			return Offline((context) => {
+			const buffer = await Offline((context) => {
 				const signal = new Signal();
 				sig = signal;
 				signal.setTargetAtTime(2, 0, 0.2);
@@ -348,20 +346,18 @@ describe("Param", () => {
 				return atTime(0.4, () => {
 					signal.apply(source.offset);
 				});
-			}, 2).then(async (buffer) => {
-				for (let time = 0.41; time < 2; time += 0.1) {
-					expect(buffer.getValueAtTime(time)).to.be.closeTo(
-						sig.getValueAtTime(time),
-						0.05
-					);
-				}
-				// document.body.appendChild(await Plot.signal(buffer));
-			});
+			}, 2);
+			for (let time = 0.41; time < 2; time += 0.1) {
+				expect(buffer.getValueAtTime(time)).to.be.closeTo(
+					sig.getValueAtTime(time),
+					0.05
+				);
+			}
 		});
 
-		it("can apply a scheduled curve that starts with a setTargetAtTime and then schedules other things", () => {
+		it("can apply a scheduled curve that starts with a setTargetAtTime and then schedules other things", async () => {
 			let sig;
-			return Offline((context) => {
+			const buffer = await Offline((context) => {
 				const signal = new Signal();
 				sig = signal;
 				signal.setTargetAtTime(2, 0, 0.2);
@@ -373,19 +369,17 @@ describe("Param", () => {
 				return atTime(0.4, () => {
 					signal.apply(source.offset);
 				});
-			}, 2).then(async (buffer) => {
-				for (let time = 0.41; time < 2; time += 0.1) {
-					expect(buffer.getValueAtTime(time)).to.be.closeTo(
-						sig.getValueAtTime(time),
-						0.05
-					);
-				}
-				// document.body.appendChild(await Plot.signal(buffer));
-			});
+			}, 2);
+			for (let time = 0.41; time < 2; time += 0.1) {
+				expect(buffer.getValueAtTime(time)).to.be.closeTo(
+					sig.getValueAtTime(time),
+					0.05
+				);
+			}
 		});
 
-		it("can set the param if the Param is marked as swappable", () => {
-			return Offline((context) => {
+		it("can set the param if the Param is marked as swappable", async () => {
+			const buffer = await Offline((context) => {
 				const constSource = context.createConstantSource();
 				const param = new Param({
 					swappable: true,
@@ -398,11 +392,10 @@ describe("Param", () => {
 				constSource2.start(0);
 				param.setParam(constSource2.offset);
 				connect(constSource2, context.destination);
-			}, 0.5).then((buffer) => {
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.1, 0.001);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.2, 0.001);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.3, 0.001);
-			});
+			}, 0.5);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.1, 0.001);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.2, 0.001);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.3, 0.001);
 		});
 
 		it("throws an error if the param is not set to swappable", () => {

package/Tone/core/context/ToneAudioBuffer.test.ts

@@ -192,16 +192,9 @@ describe("ToneAudioBuffer", () => {
 			expect(hadError).to.equal(true);
 		});
 
-		it("instance .load method returns Promise", (done) => {
-			const promise = new ToneAudioBuffer().load(testFile);
-			expect(promise).to.have.property("then");
-			promise.then((buff) => {
-				expect(buff).to.be.instanceOf(ToneAudioBuffer);
-				done();
-			});
-			promise.catch(() => {
-				throw new Error("shouldn't invoke this function");
-			});
+		it("instance .load method returns Promise", async () => {
+			const buffer = await new ToneAudioBuffer().load(testFile);
+			expect(buffer).to.be.instanceOf(ToneAudioBuffer);
 		});
 
 		it("invokes the error callback if the file is corrupt", (done) => {

package/Tone/core/context/ToneAudioBuffers.test.ts

@@ -110,18 +110,16 @@ describe("ToneAudioBuffers", () => {
 		expect(buffer.loaded).to.be.false;
 	});
 
-	it("can load from a base url", (done) => {
+	it("can load from a base url", async () => {
 		const buffer = new ToneAudioBuffers(
 			{
 				hat: "hh.wav",
 			},
-			() => {
-				expect(buffer.get("hat")).to.be.instanceof(ToneAudioBuffer);
-				buffer.dispose();
-				done();
-			},
+			() => {},
 			"./test/audio/"
 		);
+		await ToneAudioBuffer.loaded();
+		expect(buffer.get("hat")).to.be.instanceof(ToneAudioBuffer);
 	});
 
 	it("can add a buffer", (done) => {
@@ -157,13 +155,11 @@ describe("ToneAudioBuffers", () => {
 		expect(buffer.get("name").get()).to.equal(buff.get());
 	});
 
-	it("can add an AudioBuffer", (done) => {
-		ToneAudioBuffer.load(testFile).then((buff) => {
-			const buffer = new ToneAudioBuffers();
-			buffer.add("name", buff);
-			expect(buffer.get("name").get()).to.equal(buff);
-			done();
-		});
+	it("can add an AudioBuffer", async () => {
+		const audioBuffer = await ToneAudioBuffer.load(testFile);
+		const buffer = new ToneAudioBuffers();
+		buffer.add("name", audioBuffer);
+		expect(buffer.get("name").get()).to.equal(audioBuffer);
 	});
 
 	it("can be constructed with ToneAudioBuffers", () => {

package/Tone/core/worklet/ToneAudioWorklet.ts

@@ -59,7 +59,9 @@ export abstract class ToneAudioWorklet<
 		this._dummyParam = this._dummyGain.gain;
 
 		// Register the processor
-		let workletPromise = ToneAudioWorklet._workletPromises.get(this.context);
+		let workletPromise = ToneAudioWorklet._workletPromises.get(
+			this.context
+		);
 
 		if (workletPromise === undefined) {
 			workletPromise = this.context.addAudioWorkletModule(blobUrl);

package/Tone/effect/AutoFilter.test.ts

@@ -86,30 +86,28 @@ describe("AutoFilter", () => {
 			autoFilter.dispose();
 		});
 
-		it("can sync the frequency to the transport", () => {
-			return Offline(({ transport }) => {
+		it("can sync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const autoFilter = new AutoFilter(2);
 				autoFilter.sync();
 				autoFilter.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
 				// transport.start(0)
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
-			});
+			}, 0.1);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
+			expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
 		});
 
-		it("can unsync the frequency to the transport", () => {
-			return Offline(({ transport }) => {
+		it("can unsync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const autoFilter = new AutoFilter(2);
 				autoFilter.sync();
 				autoFilter.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
 				autoFilter.unsync();
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
-			});
+			}, 0.1);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
+			expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
 		});
 	});
 });

package/Tone/effect/AutoPanner.test.ts

@@ -62,31 +62,29 @@ describe("AutoPanner", () => {
 			autoPanner.dispose();
 		});
 
-		it("can sync the frequency to the transport", () => {
-			return Offline(({ transport }) => {
+		it("can sync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const panner = new AutoPanner(2);
 				panner.sync();
 				panner.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
 				// transport.start(0)
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
-			});
+			}, 0.1);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
+			expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
 		});
 
-		it("can unsync the frequency to the transport", () => {
-			return Offline(({ transport }) => {
+		it("can unsync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const panner = new AutoPanner(2);
 				panner.sync();
 				panner.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
 				panner.unsync();
 				// transport.start(0)
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
-			});
+			}, 0.1);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
+			expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
 		});
 	});
 });

package/Tone/effect/Chorus.test.ts

@@ -60,31 +60,27 @@ describe("Chorus", () => {
 			chorus.dispose();
 		});
 
-		it("can sync the frequency to the transport", () => {
-			return Offline(({ transport }) => {
+		it("can sync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const chorus = new Chorus(2);
 				chorus.sync();
 				chorus.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
-				// transport.start(0)
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
-			});
+			}, 0.1);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
+			expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
 		});
 
-		it("can unsync the frequency to the transport", () => {
-			return Offline(({ transport }) => {
+		it("can unsync the frequency to the transport", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const chorus = new Chorus(2);
 				chorus.sync();
 				chorus.frequency.toDestination();
 				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
 				chorus.unsync();
-				// transport.start(0)
-			}, 0.1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
-			});
+			}, 0.1);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
+			expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
 		});
 	});
 });

package/Tone/effect/FrequencyShifter.test.ts

@@ -41,17 +41,16 @@ describe("FrequencyShifter", () => {
 			shifter.dispose();
 		});
 
-		it("passes audio from input to output", () => {
-			return Offline(() => {
+		it("passes audio from input to output", async () => {
+			const buffer = await Offline(() => {
 				const osc = new Oscillator();
 				osc.start(0).stop(0.1);
 				const shifter = new FrequencyShifter(0.2).toDestination();
 				osc.connect(shifter);
-			}, 0.3).then((buffer) => {
-				expect(buffer.getRmsAtTime(0.05)).to.be.greaterThan(0);
-				expect(buffer.getRmsAtTime(0.1)).to.be.greaterThan(0);
-				expect(buffer.getRmsAtTime(0.2)).to.be.greaterThan(0);
-			});
+			}, 0.3);
+			expect(buffer.getRmsAtTime(0.05)).to.be.greaterThan(0);
+			expect(buffer.getRmsAtTime(0.1)).to.be.greaterThan(0);
+			expect(buffer.getRmsAtTime(0.2)).to.be.greaterThan(0);
 		});
 	});
 });

package/Tone/effect/Reverb.test.ts

@@ -36,38 +36,35 @@ describe("Reverb", () => {
 			reverb.dispose();
 		});
 
-		it("can generate an IR", () => {
+		it("can generate an IR", async () => {
 			const reverb = new Reverb();
 			const promise = reverb.generate();
 			expect(promise).to.have.property("then");
-			return promise.then(() => {
-				reverb.dispose();
-			});
+			await promise;
+			reverb.dispose();
 		});
 
-		it.skip("is silent before the reverb is generated", () => {
-			return Offline(() => {
+		it.skip("is silent before the reverb is generated", async () => {
+			const buffer = await Offline(() => {
 				const osc = new Oscillator();
 				osc.start(0).stop(0.1);
 				const reverb = new Reverb(0.2).toDestination();
 				osc.connect(reverb);
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
 			});
+			expect(buffer.isSilent()).to.be.true;
 		});
 
-		it("passes audio from input to output", () => {
-			return Offline(async () => {
+		it("passes audio from input to output", async () => {
+			const buffer = await Offline(async () => {
 				const osc = new Oscillator();
 				osc.start(0).stop(0.1);
 				const reverb = new Reverb(0.2).toDestination();
 				osc.connect(reverb);
 				await reverb.ready;
-			}, 0.3).then((buffer) => {
-				expect(buffer.getRmsAtTime(0.05)).to.be.greaterThan(0);
-				expect(buffer.getRmsAtTime(0.1)).to.be.greaterThan(0);
-				expect(buffer.getRmsAtTime(0.2)).to.be.greaterThan(0);
-			});
+			}, 0.3);
+			expect(buffer.getRmsAtTime(0.05)).to.be.greaterThan(0);
+			expect(buffer.getRmsAtTime(0.1)).to.be.greaterThan(0);
+			expect(buffer.getRmsAtTime(0.2)).to.be.greaterThan(0);
 		});
 
 		it("parses number from string in input", () => {