tone 15.2.0 → 15.2.2

package/Tone/signal/SyncedSignal.test.ts

@@ -16,8 +16,8 @@ describe("SyncedSignal", () => {
 			sched.dispose();
 		});
 
-		it("can schedule setValueAtTime relative to the Transport", () => {
-			return Offline(
+		it("can schedule setValueAtTime relative to the Transport", async () => {
+			const buffer = await Offline(
 				({ transport }) => {
 					const sched = new SyncedSignal(1).toDestination();
 					sched.setValueAtTime(2, 0.1);
@@ -26,16 +26,15 @@ describe("SyncedSignal", () => {
 				},
 				0.4,
 				1
-			).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.07);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.07);
-				expect(buffer.getValueAtTime(0.201)).to.be.closeTo(2, 0.07);
-				expect(buffer.getValueAtTime(0.301)).to.be.closeTo(3, 0.07);
-			});
+			);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.07);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.07);
+			expect(buffer.getValueAtTime(0.201)).to.be.closeTo(2, 0.07);
+			expect(buffer.getValueAtTime(0.301)).to.be.closeTo(3, 0.07);
 		});
 
-		it("can schedule linearRampToValueAtTime relative to the Transport", () => {
-			return Offline(
+		it("can schedule linearRampToValueAtTime relative to the Transport", async () => {
+			const buffer = await Offline(
 				({ transport }) => {
 					const sched = new SyncedSignal(1).toDestination();
 					sched.setValueAtTime(1, 0.1);
@@ -44,17 +43,16 @@ describe("SyncedSignal", () => {
 				},
 				0.4,
 				1
-			).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.07);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.07);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(1, 0.07);
-				expect(buffer.getValueAtTime(0.25)).to.be.closeTo(1.5, 0.07);
-				expect(buffer.getValueAtTime(0.301)).to.be.closeTo(2, 0.07);
-			});
+			);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.07);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.07);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(1, 0.07);
+			expect(buffer.getValueAtTime(0.25)).to.be.closeTo(1.5, 0.07);
+			expect(buffer.getValueAtTime(0.301)).to.be.closeTo(2, 0.07);
 		});
 
-		it("can schedule exponentialRampToValueAtTime relative to the Transport", () => {
-			return Offline(
+		it("can schedule exponentialRampToValueAtTime relative to the Transport", async () => {
+			const buffer = await Offline(
 				({ transport }) => {
 					const sched = new SyncedSignal(1).toDestination();
 					sched.setValueAtTime(1, 0.1);
@@ -63,180 +61,169 @@ describe("SyncedSignal", () => {
 				},
 				0.4,
 				1
-			).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.07);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.07);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(1, 0.07);
-				expect(buffer.getValueAtTime(0.25)).to.be.closeTo(1.4, 0.07);
-				expect(buffer.getValueAtTime(0.301)).to.be.closeTo(2, 0.07);
-			});
+			);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.07);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.07);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(1, 0.07);
+			expect(buffer.getValueAtTime(0.25)).to.be.closeTo(1.4, 0.07);
+			expect(buffer.getValueAtTime(0.301)).to.be.closeTo(2, 0.07);
 		});
 
-		it("can get exponential ramp value in the future", () => {
+		it("can get exponential ramp value in the future", async () => {
 			let sched;
-			return Offline(({ transport }) => {
+			const buffer = await Offline(({ transport }) => {
 				sched = new SyncedSignal(0.5).toDestination();
 				sched.setValueAtTime(0.5, 0);
 				sched.exponentialRampToValueAtTime(1, 0.2);
 				sched.exponentialRampToValueAtTime(0.5, 0.4);
 				transport.start(0.1);
-			}, 0.6).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					expect(sample).to.be.closeTo(
-						sched.getValueAtTime(time - 0.1),
-						0.07
-					);
-				});
+			}, 0.6);
+			buffer.forEach((sample, time) => {
+				expect(sample).to.be.closeTo(
+					sched.getValueAtTime(time - 0.1),
+					0.07
+				);
 			});
 		});
 
-		it("can get exponential approach in the future", () => {
+		it("can get exponential approach in the future", async () => {
 			let sched;
-			return Offline(({ transport }) => {
+			const buffer = await Offline(({ transport }) => {
 				sched = new SyncedSignal(0.5).toDestination();
 				sched.setValueAtTime(0.5, 0);
 				sched.setTargetAtTime(1, 0.2, 0.2);
 				transport.start(0.1);
-			}, 0.6).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					expect(sample).to.be.closeTo(
-						sched.getValueAtTime(time - 0.1),
-						0.07
-					);
-				});
+			}, 0.6);
+			buffer.forEach((sample, time) => {
+				expect(sample).to.be.closeTo(
+					sched.getValueAtTime(time - 0.1),
+					0.07
+				);
 			});
 		});
 
-		it("can loop the signal when the Transport loops", () => {
+		it("can loop the signal when the Transport loops", async () => {
 			let sched;
-			return Offline(({ transport }) => {
+			const buffer = await Offline(({ transport }) => {
 				sched = new SyncedSignal(1).toDestination();
 				transport.setLoopPoints(0, 1);
 				transport.loop = true;
 				sched.setValueAtTime(1, 0);
 				sched.setValueAtTime(2, 0.5);
 				transport.start(0);
-			}, 2).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.5)).to.be.closeTo(2, 0.01);
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(1.5)).to.be.closeTo(2, 0.01);
-			});
+			}, 2);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(2, 0.01);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(1.5)).to.be.closeTo(2, 0.01);
 		});
 
-		it("can get set a curve in the future", () => {
+		it("can get set a curve in the future", async () => {
 			let sched;
-			return Offline(({ transport }) => {
+			const buffer = await Offline(({ transport }) => {
 				sched = new SyncedSignal(0).toDestination();
 				sched.setValueCurveAtTime([0, 1, 0.2, 0.8, 0], 0, 1);
 				transport.start(0.2);
-			}, 1).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					expect(sample).to.be.closeTo(
-						sched.getValueAtTime(time - 0.2),
-						0.07
-					);
-				});
+			}, 1);
+			buffer.forEach((sample, time) => {
+				expect(sample).to.be.closeTo(
+					sched.getValueAtTime(time - 0.2),
+					0.07
+				);
 			});
 		});
 
-		it("can scale a curve value", () => {
+		it("can scale a curve value", async () => {
 			let sched;
-			return Offline(({ transport }) => {
+			const buffer = await Offline(({ transport }) => {
 				sched = new SyncedSignal(1).toDestination();
 				sched.setValueCurveAtTime([0, 1, 0], 0, 1, 0.5);
 				transport.start(0);
-			}, 1).then((buffer) => {
-				buffer.forEach((sample) => {
-					expect(sample).to.be.at.most(0.51);
-				});
+			}, 1);
+			buffer.forEach((sample) => {
+				expect(sample).to.be.at.most(0.51);
 			});
 		});
 
-		it("can schedule a linear ramp between two times", () => {
+		it("can schedule a linear ramp between two times", async () => {
 			let sched;
-			return Offline(({ transport }) => {
+			const buffer = await Offline(({ transport }) => {
 				sched = new SyncedSignal(0).toDestination();
 				sched.linearRampTo(1, 1, 1);
 				transport.start(0);
-			}, 3).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.closeTo(0, 0.1);
-				expect(buffer.getValueAtTime(0.5)).to.closeTo(0, 0.1);
-				expect(buffer.getValueAtTime(1)).to.closeTo(0, 0.1);
-				expect(buffer.getValueAtTime(1.5)).to.closeTo(0.5, 0.1);
-				expect(buffer.getValueAtTime(2)).to.closeTo(1, 0.1);
-			});
+			}, 3);
+			expect(buffer.getValueAtTime(0)).to.closeTo(0, 0.1);
+			expect(buffer.getValueAtTime(0.5)).to.closeTo(0, 0.1);
+			expect(buffer.getValueAtTime(1)).to.closeTo(0, 0.1);
+			expect(buffer.getValueAtTime(1.5)).to.closeTo(0.5, 0.1);
+			expect(buffer.getValueAtTime(2)).to.closeTo(1, 0.1);
 		});
 
-		it("can get exponential ramp value between two times", () => {
+		it("can get exponential ramp value between two times", async () => {
 			let sched;
-			return Offline(({ transport }) => {
+			const buffer = await Offline(({ transport }) => {
 				sched = new SyncedSignal(1).toDestination();
 				sched.exponentialRampTo(3, 1, 1);
 				transport.start(0);
-			}, 3).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.closeTo(1, 0.1);
-				expect(buffer.getValueAtTime(0.5)).to.closeTo(1, 0.1);
-				expect(buffer.getValueAtTime(1)).to.closeTo(1, 0.1);
-				expect(buffer.getValueAtTime(1.5)).to.closeTo(1.75, 0.1);
-				expect(buffer.getValueAtTime(2)).to.closeTo(3, 0.1);
-			});
+			}, 3);
+			expect(buffer.getValueAtTime(0)).to.closeTo(1, 0.1);
+			expect(buffer.getValueAtTime(0.5)).to.closeTo(1, 0.1);
+			expect(buffer.getValueAtTime(1)).to.closeTo(1, 0.1);
+			expect(buffer.getValueAtTime(1.5)).to.closeTo(1.75, 0.1);
+			expect(buffer.getValueAtTime(2)).to.closeTo(3, 0.1);
 		});
 
-		it("can cancel and hold a scheduled value", () => {
+		it("can cancel and hold a scheduled value", async () => {
 			let sched;
-			return Offline(({ transport }) => {
+			const buffer = await Offline(({ transport }) => {
 				sched = new SyncedSignal(0).toDestination();
 				sched.setValueAtTime(0, 0);
 				sched.linearRampToValueAtTime(1, 1);
 				sched.cancelAndHoldAtTime(0.5);
 				transport.start(0);
-			}, 1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.1);
-				expect(buffer.getValueAtTime(0.25)).to.be.closeTo(0.25, 0.1);
-				expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0.5, 0.1);
-				expect(buffer.getValueAtTime(0.75)).to.be.closeTo(0.5, 0.1);
-			});
+			}, 1);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.1);
+			expect(buffer.getValueAtTime(0.25)).to.be.closeTo(0.25, 0.1);
+			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0.5, 0.1);
+			expect(buffer.getValueAtTime(0.75)).to.be.closeTo(0.5, 0.1);
 		});
 
-		it("can cancel a scheduled value", () => {
+		it("can cancel a scheduled value", async () => {
 			let sched;
-			return Offline(({ transport }) => {
+			const buffer = await Offline(({ transport }) => {
 				sched = new SyncedSignal(0).toDestination();
 				sched.setValueAtTime(0, 0);
 				sched.linearRampToValueAtTime(1, 0.5);
 				sched.linearRampToValueAtTime(0, 1);
 				sched.cancelScheduledValues(0.6);
 				transport.start(0);
-			}, 1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.1);
-				expect(buffer.getValueAtTime(0.25)).to.be.closeTo(0.5, 0.1);
-				expect(buffer.getValueAtTime(0.5)).to.be.closeTo(1, 0.1);
-				expect(buffer.getValueAtTime(0.75)).to.be.closeTo(1, 0.1);
-			});
+			}, 1);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.1);
+			expect(buffer.getValueAtTime(0.25)).to.be.closeTo(0.5, 0.1);
+			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(1, 0.1);
+			expect(buffer.getValueAtTime(0.75)).to.be.closeTo(1, 0.1);
 		});
 
-		it("can automate values with different units", () => {
+		it("can automate values with different units", async () => {
 			let sched;
-			return Offline(({ transport }) => {
+			const buffer = await Offline(({ transport }) => {
 				sched = new SyncedSignal(-10, "decibels").toDestination();
 				sched.setValueAtTime(-5, 0);
 				sched.linearRampToValueAtTime(-12, 0.5);
 				sched.exponentialRampTo(-6, 0.1, 1);
 				transport.start(0);
-			}, 1.2).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time < 0.5) {
-						expect(sample).to.be.within(
-							dbToGain(-12.01),
-							dbToGain(-4.99)
-						);
-					} else if (time < 1) {
-						expect(sample).to.be.closeTo(dbToGain(-12), 0.1);
-					} else if (time > 1.1) {
-						expect(sample).to.be.closeTo(dbToGain(-6), 0.1);
-					}
-				});
+			}, 1.2);
+			buffer.forEach((sample, time) => {
+				if (time < 0.5) {
+					expect(sample).to.be.within(
+						dbToGain(-12.01),
+						dbToGain(-4.99)
+					);
+				} else if (time < 1) {
+					expect(sample).to.be.closeTo(dbToGain(-12), 0.1);
+				} else if (time > 1.1) {
+					expect(sample).to.be.closeTo(dbToGain(-6), 0.1);
+				}
 			});
 		});
 
@@ -254,15 +241,14 @@ describe("SyncedSignal", () => {
 			expect(buffer.getValueAtTime(1)).to.be.closeTo(0, 0.1);
 		});
 
-		it("can set a exponential approach ramp from the current time", () => {
-			return Offline(({ transport }) => {
+		it("can set a exponential approach ramp from the current time", async () => {
+			const buffer = await Offline(({ transport }) => {
 				const sig = new SyncedSignal(0).toDestination();
 				sig.targetRampTo(1, 0.3);
 				transport.start(0);
-			}, 0.5).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.below(0.07);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.1);
-			});
+			}, 0.5);
+			expect(buffer.getValueAtTime(0)).to.be.below(0.07);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.1);
 		});
 	});
 });

package/Tone/signal/ToneConstantSource.test.ts

@@ -56,9 +56,9 @@ describe("ToneConstantSource", () => {
 			};
 		});
 
-		it("invokes the onended callback in the offline context", () => {
+		it("invokes the onended callback in the offline context", async () => {
 			let wasInvoked = false;
-			return Offline(() => {
+			await Offline(() => {
 				const source = new ToneConstantSource();
 				source.start(0);
 				source.stop(0.2);
@@ -67,14 +67,13 @@ describe("ToneConstantSource", () => {
 					source.dispose();
 					wasInvoked = true;
 				};
-			}, 0.3).then(() => {
-				expect(wasInvoked).to.equal(true);
-			});
+			}, 0.3);
+			expect(wasInvoked).to.equal(true);
 		});
 
-		it("invokes the onended callback only once in offline context", () => {
+		it("invokes the onended callback only once in offline context", async () => {
 			let wasInvoked = false;
-			return Offline(() => {
+			await Offline(() => {
 				const source = new ToneConstantSource();
 				source.start(0);
 				source.stop(0.1);
@@ -86,9 +85,8 @@ describe("ToneConstantSource", () => {
 					expect(wasInvoked).to.equal(false);
 					wasInvoked = true;
 				};
-			}, 0.4).then(() => {
-				expect(wasInvoked).to.equal(true);
-			});
+			}, 0.4);
+			expect(wasInvoked).to.equal(true);
 		});
 	});
 
@@ -102,27 +100,25 @@ describe("ToneConstantSource", () => {
 			source.dispose();
 		});
 
-		it("can play for a specific duration", () => {
-			return Offline(() => {
+		it("can play for a specific duration", async () => {
+			const buffer = await Offline(() => {
 				const source = new ToneConstantSource().toDestination();
 				source.start(0).stop(0.1);
-			}, 0.4).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.above(0);
-				expect(buffer.getValueAtTime(0.09)).to.be.above(0);
-				expect(buffer.getValueAtTime(0.1)).to.equal(0);
-			});
+			}, 0.4);
+			expect(buffer.getValueAtTime(0)).to.be.above(0);
+			expect(buffer.getValueAtTime(0.09)).to.be.above(0);
+			expect(buffer.getValueAtTime(0.1)).to.equal(0);
 		});
 
-		it("can call stop multiple times and takes the last value", () => {
-			return Offline(() => {
+		it("can call stop multiple times and takes the last value", async () => {
+			const buffer = await Offline(() => {
 				const source = new ToneConstantSource().toDestination();
 				source.start(0).stop(0.1).stop(0.2);
-			}, 0.4).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.above(0);
-				expect(buffer.getValueAtTime(0.1)).to.be.above(0);
-				expect(buffer.getValueAtTime(0.19)).to.be.above(0);
-				expect(buffer.getValueAtTime(0.2)).to.equal(0);
-			});
+			}, 0.4);
+			expect(buffer.getValueAtTime(0)).to.be.above(0);
+			expect(buffer.getValueAtTime(0.1)).to.be.above(0);
+			expect(buffer.getValueAtTime(0.19)).to.be.above(0);
+			expect(buffer.getValueAtTime(0.2)).to.equal(0);
 		});
 
 		it("clamps start time to the currentTime", () => {

package/Tone/signal/WaveShaper.test.ts

@@ -70,8 +70,8 @@ describe("WaveShaper", () => {
 			}, -20);
 		});
 
-		it("maps the input through the waveshaping curve", () => {
-			return Offline(() => {
+		it("maps the input through the waveshaping curve", async () => {
+			const buffer = await Offline(() => {
 				const signal = new Signal(-1);
 				const waveshaper = new WaveShaper((input) => {
 					return input * 2;
@@ -80,10 +80,9 @@ describe("WaveShaper", () => {
 				waveshaper.toDestination();
 				signal.setValueAtTime(-1, 0);
 				signal.linearRampToValueAtTime(1, 1);
-			}, 1).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					expect(sample).to.be.closeTo(2 * (time * 2 - 1), 0.005);
-				});
+			}, 1);
+			buffer.forEach((sample, time) => {
+				expect(sample).to.be.closeTo(2 * (time * 2 - 1), 0.005);
 			});
 		});
 	});

package/Tone/source/Source.test.ts

@@ -318,71 +318,66 @@ describe("Source", () => {
 			}, 0.1);
 		});
 
-		it("gives the correct offset on time on start/stop events", () => {
-			return Offline(({ transport }) => {
+		it("gives the correct offset on time on start/stop events", async () => {
+			const output = await Offline(({ transport }) => {
 				const source = new Player(rampBuffer).toDestination();
 				source.sync().start(0.2, 0.1).stop(0.3);
 				transport.start(0.2);
-			}, 0.7).then((output) => {
-				expect(output.getValueAtTime(0.41)).to.be.closeTo(0.1, 0.01);
-				expect(output.getValueAtTime(0.45)).to.be.closeTo(0.15, 0.001);
-				expect(output.getValueAtTime(0.5)).to.be.equal(0);
-			});
+			}, 0.7);
+			expect(output.getValueAtTime(0.41)).to.be.closeTo(0.1, 0.01);
+			expect(output.getValueAtTime(0.45)).to.be.closeTo(0.15, 0.001);
+			expect(output.getValueAtTime(0.5)).to.be.equal(0);
 		});
 
-		it("gives the correct offset on time on start/stop events when started with an offset", () => {
-			return Offline(({ transport }) => {
+		it("gives the correct offset on time on start/stop events when started with an offset", async () => {
+			const output = await Offline(({ transport }) => {
 				const source = new Player(rampBuffer).toDestination();
 				source.sync().start(0.2, 0.1).stop(0.4);
 				transport.start(0.2, 0.1);
-			}, 0.7).then((output) => {
-				expect(output.getValueAtTime(0.21)).to.be.closeTo(0.0, 0.01);
-				expect(output.getValueAtTime(0.31)).to.be.closeTo(0.1, 0.01);
-				expect(output.getValueAtTime(0.41)).to.be.closeTo(0.2, 0.01);
-				expect(output.getValueAtTime(0.45)).to.be.closeTo(0.25, 0.01);
-				expect(output.getValueAtTime(0.51)).to.be.equal(0);
-			});
+			}, 0.7);
+			expect(output.getValueAtTime(0.21)).to.be.closeTo(0.0, 0.01);
+			expect(output.getValueAtTime(0.31)).to.be.closeTo(0.1, 0.01);
+			expect(output.getValueAtTime(0.41)).to.be.closeTo(0.2, 0.01);
+			expect(output.getValueAtTime(0.45)).to.be.closeTo(0.25, 0.01);
+			expect(output.getValueAtTime(0.51)).to.be.equal(0);
 		});
 
-		it("gives the correct offset on time on start/stop events invoked with an transport offset that's in the middle of the event", () => {
-			return Offline(({ transport }) => {
+		it("gives the correct offset on time on start/stop events invoked with a transport offset that's in the middle of the event", async () => {
+			const output = await Offline(({ transport }) => {
 				const source = new Player(rampBuffer).toDestination();
 				source.sync().start(0.2, 0.1).stop(0.4);
 				transport.start(0, 0.3);
-			}, 0.7).then((output) => {
-				expect(output.getValueAtTime(0.01)).to.be.closeTo(0.2, 0.01);
-				expect(output.getValueAtTime(0.05)).to.be.closeTo(0.25, 0.01);
-				expect(output.getValueAtTime(0.11)).to.be.equal(0);
-			});
+			}, 0.7);
+			expect(output.getValueAtTime(0.01)).to.be.closeTo(0.2, 0.01);
+			expect(output.getValueAtTime(0.05)).to.be.closeTo(0.25, 0.01);
+			expect(output.getValueAtTime(0.11)).to.be.equal(0);
 		});
 
-		it("gives the correct duration when invoked with an transport offset that's in the middle of the event", () => {
-			return Offline(({ transport }) => {
+		it("gives the correct duration when invoked with a transport offset that's in the middle of the event", async () => {
+			const output = await Offline(({ transport }) => {
 				const source = new Player(rampBuffer).toDestination();
 				source.sync().start(0.2, 0.1, 0.3);
 				transport.start(0, 0.3);
-			}, 0.7).then((output) => {
-				expect(output.getValueAtTime(0.01)).to.be.closeTo(0.2, 0.01);
-				expect(output.getValueAtTime(0.1)).to.be.closeTo(0.3, 0.01);
-				expect(output.getValueAtTime(0.199)).to.be.closeTo(0.4, 0.01);
-				expect(output.getValueAtTime(0.31)).to.be.equal(0);
-			});
+			}, 0.7);
+			expect(output.getValueAtTime(0.01)).to.be.closeTo(0.2, 0.01);
+			expect(output.getValueAtTime(0.1)).to.be.closeTo(0.3, 0.01);
+			expect(output.getValueAtTime(0.199)).to.be.closeTo(0.4, 0.01);
+			expect(output.getValueAtTime(0.31)).to.be.equal(0);
 		});
 
-		it("stops at the right time when transport.stop is invoked before the scheduled stop", () => {
-			return Offline(({ transport }) => {
+		it("stops at the right time when transport.stop is invoked before the scheduled stop", async () => {
+			const output = await Offline(({ transport }) => {
 				const source = new Player(rampBuffer).toDestination();
 				source.sync().start(0.2).stop(0.4);
 				transport.start(0).stop(0.3);
-			}, 0.7).then((output) => {
-				expect(output.getValueAtTime(0.2)).to.be.closeTo(0.0, 0.01);
-				expect(output.getValueAtTime(0.25)).to.be.closeTo(0.05, 0.01);
-				expect(output.getValueAtTime(0.31)).to.be.equal(0);
-			});
+			}, 0.7);
+			expect(output.getValueAtTime(0.2)).to.be.closeTo(0.0, 0.01);
+			expect(output.getValueAtTime(0.25)).to.be.closeTo(0.05, 0.01);
+			expect(output.getValueAtTime(0.31)).to.be.equal(0);
 		});
 
-		it("invokes the right methods and offsets when the transport is seeked", () => {
-			return Offline(({ transport }) => {
+		it("invokes the right methods and offsets when the transport is seeked", async () => {
+			const output = await Offline(({ transport }) => {
 				const source = new Player(rampBuffer).toDestination();
 				source.sync().start(0.2);
 				transport.start(0, 0.3);
@@ -391,14 +386,13 @@ describe("Source", () => {
 					// seek forward in time
 					transport.seconds = 0.1;
 				});
-			}, 0.7).then((output) => {
-				expect(output.getValueAtTime(0.01)).to.be.closeTo(0.1, 0.01);
-				expect(output.getValueAtTime(0.05)).to.be.closeTo(0.15, 0.01);
-				expect(output.getValueAtTime(0.11)).to.be.closeTo(0.0, 0.01);
-				expect(output.getValueAtTime(0.21)).to.be.closeTo(0.0, 0.01);
-				expect(output.getValueAtTime(0.25)).to.be.closeTo(0.05, 0.01);
-				expect(output.getValueAtTime(0.3)).to.be.closeTo(0.1, 0.01);
-			});
+			}, 0.7);
+			expect(output.getValueAtTime(0.01)).to.be.closeTo(0.1, 0.01);
+			expect(output.getValueAtTime(0.05)).to.be.closeTo(0.15, 0.01);
+			expect(output.getValueAtTime(0.11)).to.be.closeTo(0.0, 0.01);
+			expect(output.getValueAtTime(0.21)).to.be.closeTo(0.0, 0.01);
+			expect(output.getValueAtTime(0.25)).to.be.closeTo(0.05, 0.01);
+			expect(output.getValueAtTime(0.3)).to.be.closeTo(0.1, 0.01);
 		});
 	});
 });