tone 15.2.0 → 15.2.2

package/Tone/component/envelope/Envelope.test.ts

@@ -27,21 +27,19 @@ describe("Envelope", () => {
 			env.dispose();
 		});
 
-		it("passes no signal before being triggered", () => {
-			return Offline(() => {
+		it("passes no signal before being triggered", async () => {
+			const buffer = await Offline(() => {
 				new Envelope().toDestination();
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.equal(true);
 			});
+			expect(buffer.isSilent()).to.equal(true);
 		});
 
-		it("passes signal once triggered", () => {
-			return Offline(() => {
+		it("passes signal once triggered", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope().toDestination();
 				env.triggerAttack(0.05);
-			}, 0.1).then((buffer) => {
-				expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.05, 0.001);
-			});
+			}, 0.1);
+			expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.05, 0.001);
 		});
 
 		it("can take parameters as both an object and as arguments", () => {
@@ -138,21 +136,20 @@ describe("Envelope", () => {
 			env2.dispose();
 		});
 
-		it("can set release to exponential or linear", () => {
-			return Offline(() => {
+		it("can set release to exponential or linear", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope({
 					release: 0,
 				});
 				env.toDestination();
 				env.triggerAttackRelease(0.4, 0);
-			}, 0.7).then((buffer) => {
-				expect(buffer.getValueAtTime(0.3)).to.be.above(0);
-				expect(buffer.getValueAtTime(0.401)).to.equal(0);
-			});
+			}, 0.7);
+			expect(buffer.getValueAtTime(0.3)).to.be.above(0);
+			expect(buffer.getValueAtTime(0.401)).to.equal(0);
 		});
 
-		it("schedule a release at the moment when the attack portion is done", () => {
-			return Offline(() => {
+		it("schedule a release at the moment when the attack portion is done", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope({
 					attack: 0.5,
 					decay: 0.0,
@@ -160,24 +157,23 @@ describe("Envelope", () => {
 					release: 0.5,
 				}).toDestination();
 				env.triggerAttackRelease(0.5);
-			}, 0.7).then((buffer) => {
-				// make sure that it's got the rising edge
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.2, 0.01);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.4, 0.01);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.6, 0.01);
-				expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.8, 0.01);
-				expect(buffer.getValueAtTime(0.5)).to.be.be.closeTo(1, 0.001);
-			});
+			}, 0.7);
+			// make sure that it's got the rising edge
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.2, 0.01);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.4, 0.01);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.6, 0.01);
+			expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.8, 0.01);
+			expect(buffer.getValueAtTime(0.5)).to.be.be.closeTo(1, 0.001);
 		});
 
-		it("correctly schedules an exponential attack", () => {
+		it("correctly schedules an exponential attack", async () => {
 			const e = {
 				attack: 0.01,
 				decay: 0.4,
 				release: 0.1,
 				sustain: 0.5,
 			};
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(
 					e.attack,
 					e.decay,
@@ -187,35 +183,34 @@ describe("Envelope", () => {
 				env.attackCurve = "exponential";
 				env.toDestination();
 				env.triggerAttack(0);
-			}, 0.7).then((buffer) => {
-				buffer.forEachBetween(
-					(sample) => {
-						expect(sample).to.be.within(0, 1);
-					},
-					0,
-					e.attack
-				);
-				buffer.forEachBetween(
-					(sample) => {
-						expect(sample).to.be.within(e.sustain - 0.001, 1);
-					},
-					e.attack,
-					e.attack + e.decay
-				);
-				buffer.forEachBetween((sample) => {
-					expect(sample).to.be.closeTo(e.sustain, 0.01);
-				}, e.attack + e.decay);
-			});
-		});
-
-		it("correctly schedules a linear release", () => {
+			}, 0.7);
+			buffer.forEachBetween(
+				(sample) => {
+					expect(sample).to.be.within(0, 1);
+				},
+				0,
+				e.attack
+			);
+			buffer.forEachBetween(
+				(sample) => {
+					expect(sample).to.be.within(e.sustain - 0.001, 1);
+				},
+				e.attack,
+				e.attack + e.decay
+			);
+			buffer.forEachBetween((sample) => {
+				expect(sample).to.be.closeTo(e.sustain, 0.01);
+			}, e.attack + e.decay);
+		});
+
+		it("correctly schedules a linear release", async () => {
 			const e = {
 				attack: 0.01,
 				decay: 0.4,
 				release: 0.1,
 				sustain: 0.5,
 			};
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(
 					e.attack,
 					e.decay,
@@ -225,26 +220,25 @@ describe("Envelope", () => {
 				env.attackCurve = "exponential";
 				env.toDestination();
 				env.triggerAttack(0);
-			}, 0.7).then((buffer) => {
-				buffer.forEachBetween(
-					(sample, time) => {
-						const target = 1 - (time - 0.2) * 10;
-						expect(sample).to.be.closeTo(target, 0.01);
-					},
-					0.2,
-					0.2
-				);
-			});
-		});
-
-		it("correctly schedules a linear decay", () => {
+			}, 0.7);
+			buffer.forEachBetween(
+				(sample, time) => {
+					const target = 1 - (time - 0.2) * 10;
+					expect(sample).to.be.closeTo(target, 0.01);
+				},
+				0.2,
+				0.2
+			);
+		});
+
+		it("correctly schedules a linear decay", async () => {
 			const e = {
 				attack: 0.1,
 				decay: 0.5,
 				release: 0.1,
 				sustain: 0,
 			};
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(
 					e.attack,
 					e.decay,
@@ -254,25 +248,24 @@ describe("Envelope", () => {
 				env.decayCurve = "linear";
 				env.toDestination();
 				env.triggerAttack(0);
-			}, 0.7).then((buffer) => {
-				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(0.5, 0.01);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.8, 0.01);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.6, 0.01);
-				expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.4, 0.01);
-				expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0.2, 0.01);
-				expect(buffer.getValueAtTime(0.6)).to.be.closeTo(0, 0.01);
-			});
+			}, 0.7);
+			expect(buffer.getValueAtTime(0.05)).to.be.closeTo(0.5, 0.01);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.8, 0.01);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.6, 0.01);
+			expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.4, 0.01);
+			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0.2, 0.01);
+			expect(buffer.getValueAtTime(0.6)).to.be.closeTo(0, 0.01);
 		});
 
-		it("correctly schedules an exponential decay", () => {
+		it("correctly schedules an exponential decay", async () => {
 			const e = {
 				attack: 0.1,
 				decay: 0.5,
 				release: 0.1,
 				sustain: 0,
 			};
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(
 					e.attack,
 					e.decay,
@@ -282,24 +275,23 @@ describe("Envelope", () => {
 				env.decayCurve = "exponential";
 				env.toDestination();
 				env.triggerAttack(0);
-			}, 0.7).then((buffer) => {
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.27, 0.01);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.07, 0.01);
-				expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.02, 0.01);
-				expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0.005, 0.01);
-				expect(buffer.getValueAtTime(0.6)).to.be.closeTo(0, 0.01);
-			});
+			}, 0.7);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.27, 0.01);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.07, 0.01);
+			expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.02, 0.01);
+			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0.005, 0.01);
+			expect(buffer.getValueAtTime(0.6)).to.be.closeTo(0, 0.01);
 		});
 
-		it("can schedule a very short attack", () => {
+		it("can schedule a very short attack", async () => {
 			const e = {
 				attack: 0.001,
 				decay: 0.01,
 				release: 0.1,
 				sustain: 0.1,
 			};
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(
 					e.attack,
 					e.decay,
@@ -309,40 +301,38 @@ describe("Envelope", () => {
 				env.attackCurve = "exponential";
 				env.toDestination();
 				env.triggerAttack(0);
-			}, 0.2).then((buffer) => {
-				buffer.forEachBetween(
-					(sample) => {
-						expect(sample).to.be.within(0, 1);
-					},
-					0,
-					e.attack
-				);
-				buffer.forEachBetween(
-					(sample) => {
-						expect(sample).to.be.within(e.sustain - 0.001, 1);
-					},
-					e.attack,
-					e.attack + e.decay
-				);
-				buffer.forEachBetween((sample) => {
-					expect(sample).to.be.closeTo(e.sustain, 0.01);
-				}, e.attack + e.decay);
-			});
-		});
-
-		it("can schedule an attack of time 0", () => {
-			return Offline(() => {
+			}, 0.2);
+			buffer.forEachBetween(
+				(sample) => {
+					expect(sample).to.be.within(0, 1);
+				},
+				0,
+				e.attack
+			);
+			buffer.forEachBetween(
+				(sample) => {
+					expect(sample).to.be.within(e.sustain - 0.001, 1);
+				},
+				e.attack,
+				e.attack + e.decay
+			);
+			buffer.forEachBetween((sample) => {
+				expect(sample).to.be.closeTo(e.sustain, 0.01);
+			}, e.attack + e.decay);
+		});
+
+		it("can schedule an attack of time 0", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(0, 0.1);
 				env.toDestination();
 				env.triggerAttack(0.1);
-			}, 0.2).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.001);
-				expect(buffer.getValueAtTime(0.0999)).to.be.closeTo(0, 0.001);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.001);
-			});
+			}, 0.2);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.001);
+			expect(buffer.getValueAtTime(0.0999)).to.be.closeTo(0, 0.001);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.001);
 		});
 
-		it("correctly schedule a release", () => {
+		it("correctly schedule a release", async () => {
 			const e = {
 				attack: 0.001,
 				decay: 0.01,
@@ -350,7 +340,7 @@ describe("Envelope", () => {
 				sustain: 0.5,
 			};
 			const releaseTime = 0.2;
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(
 					e.attack,
 					e.decay,
@@ -360,38 +350,36 @@ describe("Envelope", () => {
 				env.attackCurve = "exponential";
 				env.toDestination();
 				env.triggerAttackRelease(releaseTime);
-			}, 0.6).then((buffer) => {
-				const sustainStart = e.attack + e.decay;
-				const sustainEnd = sustainStart + releaseTime;
-				buffer.forEachBetween(
-					(sample) => {
-						expect(sample).to.be.below(e.sustain + 0.01);
-					},
-					sustainStart,
-					sustainEnd
-				);
-				buffer.forEachBetween((sample) => {
-					expect(sample).to.be.closeTo(0, 0.01);
-				}, releaseTime + e.release);
-			});
-		});
-
-		it("can retrigger a short attack at the same time as previous release", () => {
-			return Offline(() => {
+			}, 0.6);
+			const sustainStart = e.attack + e.decay;
+			const sustainEnd = sustainStart + releaseTime;
+			buffer.forEachBetween(
+				(sample) => {
+					expect(sample).to.be.below(e.sustain + 0.01);
+				},
+				sustainStart,
+				sustainEnd
+			);
+			buffer.forEachBetween((sample) => {
+				expect(sample).to.be.closeTo(0, 0.01);
+			}, releaseTime + e.release);
+		});
+
+		it("can retrigger a short attack at the same time as previous release", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(0.001, 0.1, 0.5);
 				env.attackCurve = "linear";
 				env.toDestination();
 				env.triggerAttack(0);
 				env.triggerRelease(0.4);
 				env.triggerAttack(0.4);
-			}, 0.6).then((buffer) => {
-				expect(buffer.getValueAtTime(0.4)).be.closeTo(0.5, 0.01);
-				expect(buffer.getValueAtTime(0.40025)).be.closeTo(0.75, 0.01);
-				expect(buffer.getValueAtTime(0.4005)).be.closeTo(1, 0.01);
-			});
+			}, 0.6);
+			expect(buffer.getValueAtTime(0.4)).be.closeTo(0.5, 0.01);
+			expect(buffer.getValueAtTime(0.40025)).be.closeTo(0.75, 0.01);
+			expect(buffer.getValueAtTime(0.4005)).be.closeTo(1, 0.01);
 		});
 
-		it("is silent before and after triggering", () => {
+		it("is silent before and after triggering", async () => {
 			const e = {
 				attack: 0.001,
 				decay: 0.01,
@@ -400,7 +388,7 @@ describe("Envelope", () => {
 			};
 			const releaseTime = 0.2;
 			const attackTime = 0.1;
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(
 					e.attack,
 					e.decay,
@@ -411,40 +399,36 @@ describe("Envelope", () => {
 				env.toDestination();
 				env.triggerAttack(attackTime);
 				env.triggerRelease(releaseTime);
-			}, 0.6).then((buffer) => {
-				expect(buffer.getValueAtTime(attackTime - 0.001)).to.equal(0);
-				expect(
-					buffer.getValueAtTime(
-						e.attack + e.decay + releaseTime + e.release
-					)
-				).to.be.below(0.01);
-			});
+			}, 0.6);
+			expect(buffer.getValueAtTime(attackTime - 0.001)).to.equal(0);
+			expect(
+				buffer.getValueAtTime(
+					e.attack + e.decay + releaseTime + e.release
+				)
+			).to.be.below(0.01);
 		});
 
-		it("is silent after decay if sustain is 0", () => {
+		it("is silent after decay if sustain is 0", async () => {
 			const e = {
 				attack: 0.01,
 				decay: 0.04,
 				sustain: 0,
 			};
 			const attackTime = 0.1;
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(e.attack, e.decay, e.sustain);
 				env.toDestination();
 				env.triggerAttack(attackTime);
-			}, 0.4).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					expect(buffer.getValueAtTime(attackTime - 0.001)).to.equal(
-						0
-					);
-					expect(
-						buffer.getValueAtTime(attackTime + e.attack + e.decay)
-					).to.be.below(0.01);
-				});
+			}, 0.4);
+			buffer.forEach((sample, time) => {
+				expect(buffer.getValueAtTime(attackTime - 0.001)).to.equal(0);
+				expect(
+					buffer.getValueAtTime(attackTime + e.attack + e.decay)
+				).to.be.below(0.01);
 			});
 		});
 
-		it("correctly schedule an attack release envelope", () => {
+		it("correctly schedule an attack release envelope", async () => {
 			const e = {
 				attack: 0.08,
 				decay: 0.2,
@@ -452,7 +436,7 @@ describe("Envelope", () => {
 				sustain: 0.1,
 			};
 			const releaseTime = 0.4;
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(
 					e.attack,
 					e.decay,
@@ -462,24 +446,23 @@ describe("Envelope", () => {
 				env.toDestination();
 				env.triggerAttack(0);
 				env.triggerRelease(releaseTime);
-			}).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time < e.attack) {
-						expect(sample).to.be.within(0, 1);
-					} else if (time < e.attack + e.decay) {
-						expect(sample).to.be.within(e.sustain, 1);
-					} else if (time < releaseTime) {
-						expect(sample).to.be.closeTo(e.sustain, 0.1);
-					} else if (time < releaseTime + e.release) {
-						expect(sample).to.be.within(0, e.sustain + 0.01);
-					} else {
-						expect(sample).to.be.below(0.0001);
-					}
-				});
+			});
+			buffer.forEach((sample, time) => {
+				if (time < e.attack) {
+					expect(sample).to.be.within(0, 1);
+				} else if (time < e.attack + e.decay) {
+					expect(sample).to.be.within(e.sustain, 1);
+				} else if (time < releaseTime) {
+					expect(sample).to.be.closeTo(e.sustain, 0.1);
+				} else if (time < releaseTime + e.release) {
+					expect(sample).to.be.within(0, e.sustain + 0.01);
+				} else {
+					expect(sample).to.be.below(0.0001);
+				}
 			});
 		});
 
-		it("can schedule a combined AttackRelease", () => {
+		it("can schedule a combined AttackRelease", async () => {
 			const e = {
 				attack: 0.1,
 				decay: 0.2,
@@ -488,7 +471,7 @@ describe("Envelope", () => {
 			};
 			const releaseTime = 0.4;
 			const duration = 0.4;
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(
 					e.attack,
 					e.decay,
@@ -498,24 +481,23 @@ describe("Envelope", () => {
 				env.toDestination();
 				env.triggerAttack(0);
 				env.triggerRelease(releaseTime);
-			}, 0.7).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time < e.attack) {
-						expect(sample).to.be.within(0, 1);
-					} else if (time < e.attack + e.decay) {
-						expect(sample).to.be.within(e.sustain - 0.001, 1);
-					} else if (time < duration) {
-						expect(sample).to.be.closeTo(e.sustain, 0.1);
-					} else if (time < duration + e.release) {
-						expect(sample).to.be.within(0, e.sustain + 0.01);
-					} else {
-						expect(sample).to.be.below(0.0015);
-					}
-				});
-			});
-		});
-
-		it("can schedule a combined AttackRelease with velocity", () => {
+			}, 0.7);
+			buffer.forEach((sample, time) => {
+				if (time < e.attack) {
+					expect(sample).to.be.within(0, 1);
+				} else if (time < e.attack + e.decay) {
+					expect(sample).to.be.within(e.sustain - 0.001, 1);
+				} else if (time < duration) {
+					expect(sample).to.be.closeTo(e.sustain, 0.1);
+				} else if (time < duration + e.release) {
+					expect(sample).to.be.within(0, e.sustain + 0.01);
+				} else {
+					expect(sample).to.be.below(0.0015);
+				}
+			});
+		});
+
+		it("can schedule a combined AttackRelease with velocity", async () => {
 			const e = {
 				attack: 0.1,
 				decay: 0.2,
@@ -525,7 +507,7 @@ describe("Envelope", () => {
 			const releaseTime = 0.4;
 			const duration = 0.4;
 			const velocity = 0.4;
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(
 					e.attack,
 					e.decay,
@@ -535,37 +517,33 @@ describe("Envelope", () => {
 				env.toDestination();
 				env.triggerAttack(0, velocity);
 				env.triggerRelease(releaseTime);
-			}, 0.7).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time < e.attack) {
-						expect(sample).to.be.within(0, velocity + 0.01);
-					} else if (time < e.attack + e.decay) {
-						expect(sample).to.be.within(
-							e.sustain * velocity - 0.01,
-							velocity + 0.01
-						);
-					} else if (time < duration) {
-						expect(sample).to.be.closeTo(e.sustain * velocity, 0.1);
-					} else if (time < duration + e.release) {
-						expect(sample).to.be.within(
-							0,
-							e.sustain * velocity + 0.01
-						);
-					} else {
-						expect(sample).to.be.below(0.01);
-					}
-				});
+			}, 0.7);
+			buffer.forEach((sample, time) => {
+				if (time < e.attack) {
+					expect(sample).to.be.within(0, velocity + 0.01);
+				} else if (time < e.attack + e.decay) {
+					expect(sample).to.be.within(
+						e.sustain * velocity - 0.01,
+						velocity + 0.01
+					);
+				} else if (time < duration) {
+					expect(sample).to.be.closeTo(e.sustain * velocity, 0.1);
+				} else if (time < duration + e.release) {
+					expect(sample).to.be.within(0, e.sustain * velocity + 0.01);
+				} else {
+					expect(sample).to.be.below(0.01);
+				}
 			});
 		});
 
-		it("can schedule multiple envelopes", () => {
+		it("can schedule multiple envelopes", async () => {
 			const e = {
 				attack: 0.1,
 				decay: 0.2,
 				release: 0.1,
 				sustain: 0.0,
 			};
-			return Offline(() => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(
 					e.attack,
 					e.decay,
@@ -575,20 +553,19 @@ describe("Envelope", () => {
 				env.toDestination();
 				env.triggerAttack(0);
 				env.triggerAttack(0.5);
-			}, 0.85).then((buffer) => {
-				// first trigger
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0, 0.01);
-				// second trigger
-				expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0, 0.01);
-				expect(buffer.getValueAtTime(0.6)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.8)).to.be.closeTo(0, 0.01);
-			});
-		});
-
-		it("can schedule multiple attack/releases with no discontinuities", () => {
-			return Offline(() => {
+			}, 0.85);
+			// first trigger
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0, 0.01);
+			// second trigger
+			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0, 0.01);
+			expect(buffer.getValueAtTime(0.6)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.8)).to.be.closeTo(0, 0.01);
+		});
+
+		it("can schedule multiple attack/releases with no discontinuities", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(0.1, 0.2, 0.2, 0.4).toDestination();
 				env.triggerAttackRelease(0, 0.4);
 				env.triggerAttackRelease(0.4, 0.11);
@@ -596,20 +573,19 @@ describe("Envelope", () => {
 				env.triggerAttackRelease(1.1, 0.09);
 				env.triggerAttackRelease(1.5, 0.3);
 				env.triggerAttackRelease(1.8, 0.29);
-			}, 2).then((buffer) => {
-				// test for discontinuities
-				let lastSample = 0;
-				buffer.forEach((sample, time) => {
-					expect(sample).to.be.at.most(1);
-					const diff = Math.abs(lastSample - sample);
-					expect(diff).to.be.lessThan(0.001);
-					lastSample = sample;
-				});
+			}, 2);
+			// test for discontinuities
+			let lastSample = 0;
+			buffer.forEach((sample, time) => {
+				expect(sample).to.be.at.most(1);
+				const diff = Math.abs(lastSample - sample);
+				expect(diff).to.be.lessThan(0.001);
+				lastSample = sample;
 			});
 		});
 
-		it("can schedule multiple 'linear' attack/releases with no discontinuities", () => {
-			return Offline(() => {
+		it("can schedule multiple 'linear' attack/releases with no discontinuities", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(0.1, 0.2, 0.2, 0.4).toDestination();
 				env.attackCurve = "linear";
 				env.releaseCurve = "linear";
@@ -619,20 +595,19 @@ describe("Envelope", () => {
 				env.triggerAttackRelease(1.1, 0.09);
 				env.triggerAttackRelease(1.5, 0.3);
 				env.triggerAttackRelease(1.8, 0.29);
-			}, 2).then((buffer) => {
-				// test for discontinuities
-				let lastSample = 0;
-				buffer.forEach((sample, time) => {
-					expect(sample).to.be.at.most(1);
-					const diff = Math.abs(lastSample - sample);
-					expect(diff).to.be.lessThan(0.001);
-					lastSample = sample;
-				});
+			}, 2);
+			// test for discontinuities
+			let lastSample = 0;
+			buffer.forEach((sample, time) => {
+				expect(sample).to.be.at.most(1);
+				const diff = Math.abs(lastSample - sample);
+				expect(diff).to.be.lessThan(0.001);
+				lastSample = sample;
 			});
 		});
 
-		it("can schedule multiple 'exponential' attack/releases with no discontinuities", () => {
-			return Offline(() => {
+		it("can schedule multiple 'exponential' attack/releases with no discontinuities", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(0.1, 0.2, 0.2, 0.4).toDestination();
 				env.attackCurve = "exponential";
 				env.releaseCurve = "exponential";
@@ -642,20 +617,19 @@ describe("Envelope", () => {
 				env.triggerAttackRelease(1.1, 0.09);
 				env.triggerAttackRelease(1.5, 0.3);
 				env.triggerAttackRelease(1.8, 0.29);
-			}, 2).then((buffer) => {
-				// test for discontinuities
-				let lastSample = 0;
-				buffer.forEach((sample, time) => {
-					expect(sample).to.be.at.most(1);
-					const diff = Math.abs(lastSample - sample);
-					expect(diff).to.be.lessThan(0.0035);
-					lastSample = sample;
-				});
+			}, 2);
+			// test for discontinuities
+			let lastSample = 0;
+			buffer.forEach((sample, time) => {
+				expect(sample).to.be.at.most(1);
+				const diff = Math.abs(lastSample - sample);
+				expect(diff).to.be.lessThan(0.0035);
+				lastSample = sample;
 			});
 		});
 
-		it("can schedule multiple 'sine' attack/releases with no discontinuities", () => {
-			return Offline(() => {
+		it("can schedule multiple 'sine' attack/releases with no discontinuities", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(0.1, 0.2, 0.2, 0.4).toDestination();
 				env.attackCurve = "sine";
 				env.releaseCurve = "sine";
@@ -665,20 +639,19 @@ describe("Envelope", () => {
 				env.triggerAttackRelease(1.1, 0.09);
 				env.triggerAttackRelease(1.5, 0.3);
 				env.triggerAttackRelease(1.8, 0.29);
-			}, 2).then((buffer) => {
-				// test for discontinuities
-				let lastSample = 0;
-				buffer.forEach((sample, time) => {
-					expect(sample).to.be.at.most(1);
-					const diff = Math.abs(lastSample - sample);
-					expect(diff).to.be.lessThan(0.0035);
-					lastSample = sample;
-				});
+			}, 2);
+			// test for discontinuities
+			let lastSample = 0;
+			buffer.forEach((sample, time) => {
+				expect(sample).to.be.at.most(1);
+				const diff = Math.abs(lastSample - sample);
+				expect(diff).to.be.lessThan(0.0035);
+				lastSample = sample;
 			});
 		});
 
-		it("can schedule multiple 'cosine' attack/releases with no discontinuities", () => {
-			return Offline(() => {
+		it("can schedule multiple 'cosine' attack/releases with no discontinuities", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(0.1, 0.2, 0.2, 0.4).toDestination();
 				env.attackCurve = "cosine";
 				env.releaseCurve = "cosine";
@@ -688,20 +661,19 @@ describe("Envelope", () => {
 				env.triggerAttackRelease(1.1, 0.09);
 				env.triggerAttackRelease(1.5, 0.3);
 				env.triggerAttackRelease(1.8, 0.29);
-			}, 2).then((buffer) => {
-				// test for discontinuities
-				let lastSample = 0;
-				buffer.forEach((sample, time) => {
-					expect(sample).to.be.at.most(1);
-					const diff = Math.abs(lastSample - sample);
-					expect(diff).to.be.lessThan(0.002);
-					lastSample = sample;
-				});
+			}, 2);
+			// test for discontinuities
+			let lastSample = 0;
+			buffer.forEach((sample, time) => {
+				expect(sample).to.be.at.most(1);
+				const diff = Math.abs(lastSample - sample);
+				expect(diff).to.be.lessThan(0.002);
+				lastSample = sample;
 			});
 		});
 
-		it("reports its current envelope value (.value)", () => {
-			return Offline(() => {
+		it("reports its current envelope value (.value)", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(1, 0.2, 1).toDestination();
 				expect(env.value).to.be.closeTo(0, 0.01);
 				env.triggerAttack();
@@ -711,14 +683,13 @@ describe("Envelope", () => {
 			}, 0.5);
 		});
 
-		it("can cancel a schedule envelope", () => {
-			return Offline(() => {
+		it("can cancel a schedule envelope", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope(0.1, 0.2, 1).toDestination();
 				env.triggerAttack(0.2);
 				env.cancel(0.2);
-			}, 0.3).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
-			});
+			}, 0.3);
+			expect(buffer.isSilent()).to.be.true;
 		});
 	});
 
@@ -751,8 +722,8 @@ describe("Envelope", () => {
 			env.dispose();
 		});
 
-		it("outputs a signal when the attack/release curves are set to 'bounce'", () => {
-			return Offline(() => {
+		it("outputs a signal when the attack/release curves are set to 'bounce'", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope({
 					attack: 0.3,
 					attackCurve: "bounce",
@@ -762,19 +733,18 @@ describe("Envelope", () => {
 					sustain: 1,
 				}).toDestination();
 				env.triggerAttackRelease(0.3, 0.1);
-			}, 0.8).then((buffer) => {
-				buffer.forEachBetween(
-					(sample) => {
-						expect(sample).to.be.above(0);
-					},
-					0.101,
-					0.7
-				);
-			});
-		});
-
-		it("outputs a signal when the attack/release curves are set to 'ripple'", () => {
-			return Offline(() => {
+			}, 0.8);
+			buffer.forEachBetween(
+				(sample) => {
+					expect(sample).to.be.above(0);
+				},
+				0.101,
+				0.7
+			);
+		});
+
+		it("outputs a signal when the attack/release curves are set to 'ripple'", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope({
 					attack: 0.3,
 					attackCurve: "ripple",
@@ -784,19 +754,18 @@ describe("Envelope", () => {
 					sustain: 1,
 				}).toDestination();
 				env.triggerAttackRelease(0.3, 0.1);
-			}, 0.8).then((buffer) => {
-				buffer.forEachBetween(
-					(sample) => {
-						expect(sample).to.be.above(0);
-					},
-					0.101,
-					0.7
-				);
-			});
-		});
-
-		it("outputs a signal when the attack/release curves are set to 'sine'", () => {
-			return Offline(() => {
+			}, 0.8);
+			buffer.forEachBetween(
+				(sample) => {
+					expect(sample).to.be.above(0);
+				},
+				0.101,
+				0.7
+			);
+		});
+
+		it("outputs a signal when the attack/release curves are set to 'sine'", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope({
 					attack: 0.3,
 					attackCurve: "sine",
@@ -806,19 +775,18 @@ describe("Envelope", () => {
 					sustain: 1,
 				}).toDestination();
 				env.triggerAttackRelease(0.3, 0.1);
-			}, 0.8).then((buffer) => {
-				buffer.forEachBetween(
-					(sample) => {
-						expect(sample).to.be.above(0);
-					},
-					0.101,
-					0.7
-				);
-			});
-		});
-
-		it("outputs a signal when the attack/release curves are set to 'cosine'", () => {
-			return Offline(() => {
+			}, 0.8);
+			buffer.forEachBetween(
+				(sample) => {
+					expect(sample).to.be.above(0);
+				},
+				0.101,
+				0.7
+			);
+		});
+
+		it("outputs a signal when the attack/release curves are set to 'cosine'", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope({
 					attack: 0.3,
 					attackCurve: "cosine",
@@ -828,19 +796,18 @@ describe("Envelope", () => {
 					sustain: 1,
 				}).toDestination();
 				env.triggerAttackRelease(0.3, 0.1);
-			}, 0.8).then((buffer) => {
-				buffer.forEachBetween(
-					(sample) => {
-						expect(sample).to.be.above(0);
-					},
-					0.101,
-					0.7
-				);
-			});
-		});
-
-		it("outputs a signal when the attack/release curves are set to 'step'", () => {
-			return Offline(() => {
+			}, 0.8);
+			buffer.forEachBetween(
+				(sample) => {
+					expect(sample).to.be.above(0);
+				},
+				0.101,
+				0.7
+			);
+		});
+
+		it("outputs a signal when the attack/release curves are set to 'step'", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope({
 					attack: 0.3,
 					attackCurve: "step",
@@ -850,19 +817,18 @@ describe("Envelope", () => {
 					sustain: 1,
 				}).toDestination();
 				env.triggerAttackRelease(0.3, 0.1);
-			}, 0.8).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time > 0.3 && time < 0.5) {
-						expect(sample).to.be.above(0);
-					} else if (time < 0.1) {
-						expect(sample).to.equal(0);
-					}
-				});
+			}, 0.8);
+			buffer.forEach((sample, time) => {
+				if (time > 0.3 && time < 0.5) {
+					expect(sample).to.be.above(0);
+				} else if (time < 0.1) {
+					expect(sample).to.equal(0);
+				}
 			});
 		});
 
-		it("outputs a signal when the attack/release curves are set to an array", () => {
-			return Offline(() => {
+		it("outputs a signal when the attack/release curves are set to an array", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope({
 					attack: 0.3,
 					attackCurve: [0, 1, 0, 1],
@@ -873,19 +839,18 @@ describe("Envelope", () => {
 				}).toDestination();
 				expect(env.attackCurve).to.deep.equal([0, 1, 0, 1]);
 				env.triggerAttackRelease(0.3, 0.1);
-			}, 0.8).then((buffer) => {
-				buffer.forEach((sample, time) => {
-					if (time > 0.4 && time < 0.5) {
-						expect(sample).to.be.above(0);
-					} else if (time < 0.1) {
-						expect(sample).to.equal(0);
-					}
-				});
+			}, 0.8);
+			buffer.forEach((sample, time) => {
+				if (time > 0.4 && time < 0.5) {
+					expect(sample).to.be.above(0);
+				} else if (time < 0.1) {
+					expect(sample).to.equal(0);
+				}
 			});
 		});
 
-		it("can scale a velocity with a custom curve", () => {
-			return Offline(() => {
+		it("can scale a velocity with a custom curve", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope({
 					attack: 0.3,
 					attackCurve: [0, 1, 0, 1],
@@ -895,10 +860,9 @@ describe("Envelope", () => {
 					sustain: 1,
 				}).toDestination();
 				env.triggerAttackRelease(0.4, 0.1, 0.5);
-			}, 0.8).then((buffer) => {
-				buffer.forEach((sample) => {
-					expect(sample).to.be.at.most(0.51);
-				});
+			}, 0.8);
+			buffer.forEach((sample) => {
+				expect(sample).to.be.at.most(0.51);
 			});
 		});
 
@@ -917,8 +881,8 @@ describe("Envelope", () => {
 			env.dispose();
 		});
 
-		it("can retrigger partial envelope with custom type", () => {
-			return Offline(() => {
+		it("can retrigger partial envelope with custom type", async () => {
+			const buffer = await Offline(() => {
 				const env = new Envelope({
 					attack: 0.5,
 					attackCurve: "cosine",
@@ -930,18 +894,17 @@ describe("Envelope", () => {
 				env.triggerAttack(0);
 				env.triggerRelease(0.2);
 				env.triggerAttack(0.5);
-			}, 1).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.equal(0);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.32, 0.01);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.6, 0.01);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.53, 0.01);
-				expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.38, 0.01);
-				expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0.2, 0.01);
-				expect(buffer.getValueAtTime(0.6)).to.be.closeTo(0.52, 0.01);
-				expect(buffer.getValueAtTime(0.7)).to.be.closeTo(0.78, 0.01);
-				expect(buffer.getValueAtTime(0.8)).to.be.closeTo(0.95, 0.01);
-				expect(buffer.getValueAtTime(0.9)).to.be.closeTo(1, 0.01);
-			});
+			}, 1);
+			expect(buffer.getValueAtTime(0)).to.equal(0);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.32, 0.01);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.6, 0.01);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(0.53, 0.01);
+			expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.38, 0.01);
+			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0.2, 0.01);
+			expect(buffer.getValueAtTime(0.6)).to.be.closeTo(0.52, 0.01);
+			expect(buffer.getValueAtTime(0.7)).to.be.closeTo(0.78, 0.01);
+			expect(buffer.getValueAtTime(0.8)).to.be.closeTo(0.95, 0.01);
+			expect(buffer.getValueAtTime(0.9)).to.be.closeTo(1, 0.01);
 		});
 	});
 });