tone 15.2.1 → 15.2.3

package/Tone/component/analysis/Analyser.ts

@@ -33,7 +33,7 @@ export class Analyser extends ToneAudioNode<AnalyserOptions> {
 	/**
 	 * The analyser node.
 	 */
-	private _analysers: AnalyserNode[] = [];
+	private _analyzers: AnalyserNode[] = [];
 
 	/**
 	 * Input and output are a gain node
@@ -81,10 +81,10 @@ export class Analyser extends ToneAudioNode<AnalyserOptions> {
 
 		assertRange(options.channels, 1);
 
-		// create the analysers
+		// create the analyzers
 		for (let channel = 0; channel < options.channels; channel++) {
-			this._analysers[channel] = this.context.createAnalyser();
-			this._split.connect(this._analysers[channel], channel, 0);
+			this._analyzers[channel] = this.context.createAnalyser();
+			this._split.connect(this._analyzers[channel], channel, 0);
 		}
 
 		// set the values initially
@@ -109,7 +109,7 @@ export class Analyser extends ToneAudioNode<AnalyserOptions> {
 	 * represents the analysis done on a channel.
 	 */
 	getValue(): Float32Array | Float32Array[] {
-		this._analysers.forEach((analyser, index) => {
+		this._analyzers.forEach((analyser, index) => {
 			const buffer = this._buffers[index];
 			if (this._type === "fft") {
 				analyser.getFloatFrequencyData(buffer);
@@ -128,10 +128,10 @@ export class Analyser extends ToneAudioNode<AnalyserOptions> {
 	 * The size of analysis. This must be a power of two in the range 16 to 16384.
 	 */
 	get size(): PowerOfTwo {
-		return this._analysers[0].frequencyBinCount;
+		return this._analyzers[0].frequencyBinCount;
 	}
 	set size(size: PowerOfTwo) {
-		this._analysers.forEach((analyser, index) => {
+		this._analyzers.forEach((analyser, index) => {
 			analyser.fftSize = size * 2;
 			this._buffers[index] = new Float32Array(size);
 		});
@@ -142,7 +142,7 @@ export class Analyser extends ToneAudioNode<AnalyserOptions> {
 	 * separation is done using {@link Split}
 	 */
 	get channels(): number {
-		return this._analysers.length;
+		return this._analyzers.length;
 	}
 
 	/**
@@ -163,10 +163,10 @@ export class Analyser extends ToneAudioNode<AnalyserOptions> {
 	 * 0 represents no time averaging with the last analysis frame.
 	 */
 	get smoothing(): NormalRange {
-		return this._analysers[0].smoothingTimeConstant;
+		return this._analyzers[0].smoothingTimeConstant;
 	}
 	set smoothing(val: NormalRange) {
-		this._analysers.forEach((a) => (a.smoothingTimeConstant = val));
+		this._analyzers.forEach((a) => (a.smoothingTimeConstant = val));
 	}
 
 	/**
@@ -174,7 +174,7 @@ export class Analyser extends ToneAudioNode<AnalyserOptions> {
 	 */
 	dispose(): this {
 		super.dispose();
-		this._analysers.forEach((a) => a.disconnect());
+		this._analyzers.forEach((a) => a.disconnect());
 		this._split.dispose();
 		this._gain.dispose();
 		return this;

package/Tone/component/analysis/Follower.test.ts

@@ -28,74 +28,70 @@ describe("Follower", () => {
 			follower.dispose();
 		});
 
-		it("smooths the incoming signal at 0.1", () => {
-			return Offline(() => {
+		it("smooths the incoming signal at 0.1", async () => {
+			const buffer = await Offline(() => {
 				const foll = new Follower(0.1).toDestination();
 				const sig = new Signal(0);
 				sig.connect(foll);
 				sig.setValueAtTime(1, 0.1);
 				sig.setValueAtTime(0, 0.3);
-			}, 0.41).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
-				expect(buffer.getValueAtTime(0.15)).to.be.closeTo(0.95, 0.05);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0.05, 0.05);
-				expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0, 0.01);
-			});
+			}, 0.41);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
+			expect(buffer.getValueAtTime(0.15)).to.be.closeTo(0.95, 0.05);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0.05, 0.05);
+			expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0, 0.01);
 		});
 
-		it("smooths the incoming signal at 0.05", () => {
-			return Offline(() => {
+		it("smooths the incoming signal at 0.05", async () => {
+			const buffer = await Offline(() => {
 				const foll = new Follower(0.05).toDestination();
 				const sig = new Signal(0);
 				sig.connect(foll);
 				sig.setValueAtTime(1, 0.1);
 				sig.setValueAtTime(0, 0.3);
-			}, 0.41).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
-				expect(buffer.getValueAtTime(0.125)).to.be.closeTo(0.95, 0.05);
-				expect(buffer.getValueAtTime(0.15)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.325)).to.be.closeTo(0.05, 0.05);
-				expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0, 0.01);
-			});
+			}, 0.41);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
+			expect(buffer.getValueAtTime(0.125)).to.be.closeTo(0.95, 0.05);
+			expect(buffer.getValueAtTime(0.15)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.325)).to.be.closeTo(0.05, 0.05);
+			expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0, 0.01);
 		});
 
-		it("smooths the incoming signal at 0.2", () => {
-			return Offline(() => {
+		it("smooths the incoming signal at 0.2", async () => {
+			const buffer = await Offline(() => {
 				const foll = new Follower(0.2).toDestination();
 				const sig = new Signal(0);
 				sig.connect(foll);
 				sig.setValueAtTime(1, 0.1);
 				sig.setValueAtTime(0, 0.3);
-			}, 0.51).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
-				expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.95, 0.05);
-				expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.05, 0.05);
-				expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0, 0.01);
-			});
+			}, 0.51);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
+			expect(buffer.getValueAtTime(0.2)).to.be.closeTo(0.95, 0.05);
+			expect(buffer.getValueAtTime(0.3)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.4)).to.be.closeTo(0.05, 0.05);
+			expect(buffer.getValueAtTime(0.5)).to.be.closeTo(0, 0.01);
 		});
 
-		it("smooths the incoming signal at 0.5", () => {
-			return Offline(() => {
+		it("smooths the incoming signal at 0.5", async () => {
+			const buffer = await Offline(() => {
 				const foll = new Follower(0.5).toDestination();
 				const sig = new Signal(0);
 				sig.connect(foll);
 				sig.setValueAtTime(1, 0.1);
 				sig.setValueAtTime(0, 0.6);
-			}, 1.11).then((buffer) => {
-				expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
-				expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
-				expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0.95, 0.05);
-				expect(buffer.getValueAtTime(0.6)).to.be.closeTo(1, 0.01);
-				expect(buffer.getValueAtTime(0.85)).to.be.closeTo(0.05, 0.05);
-				expect(buffer.getValueAtTime(1.1)).to.be.closeTo(0, 0.01);
-			});
+			}, 1.11);
+			expect(buffer.getValueAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(buffer.getValueAtTime(0.1)).to.be.closeTo(0.0, 0.01);
+			expect(buffer.getValueAtTime(0.35)).to.be.closeTo(0.95, 0.05);
+			expect(buffer.getValueAtTime(0.6)).to.be.closeTo(1, 0.01);
+			expect(buffer.getValueAtTime(0.85)).to.be.closeTo(0.05, 0.05);
+			expect(buffer.getValueAtTime(1.1)).to.be.closeTo(0, 0.01);
 		});
 
 		it("passes the incoming signal through", () => {

package/Tone/component/analysis/MeterBase.ts

@@ -18,7 +18,7 @@ export class MeterBase<
 	readonly name: string = "MeterBase";
 
 	/**
-	 * The signal to be analysed
+	 * The signal to be analyzed
 	 */
 	input: InputNode;
 

package/Tone/component/channel/Channel.test.ts

@@ -37,14 +37,13 @@ describe("Channel", () => {
 			});
 		});
 
-		it("can mute the input", () => {
-			return Offline(() => {
+		it("can mute the input", async () => {
+			const buffer = await Offline(() => {
 				const channel = new Channel(0).toDestination();
 				new Signal(1).connect(channel);
 				channel.mute = true;
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
 			});
+			expect(buffer.isSilent()).to.be.true;
 		});
 
 		it("reports itself as muted when either muted or another channel is soloed", () => {

package/Tone/component/channel/Merge.test.ts

@@ -40,8 +40,8 @@ describe("Merge", () => {
 			});
 		});
 
-		it("merge two signal into one stereo signal", () => {
-			return Offline(
+		it("merge two signal into one stereo signal", async () => {
+			const buffer = await Offline(
 				() => {
 					const sigL = new Signal(1);
 					const sigR = new Signal(2);
@@ -52,10 +52,9 @@ describe("Merge", () => {
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				expect(buffer.toArray()[0][0]).to.be.closeTo(1, 0.001);
-				expect(buffer.toArray()[1][0]).to.be.closeTo(2, 0.001);
-			});
+			);
+			expect(buffer.toArray()[0][0]).to.be.closeTo(1, 0.001);
+			expect(buffer.toArray()[1][0]).to.be.closeTo(2, 0.001);
 		});
 	});
 });

package/Tone/component/channel/MidSideSplit.test.ts

@@ -19,47 +19,44 @@ describe("MidSideSplit", () => {
 			split.dispose();
 		});
 
-		it("mid is if both L and R are the same", () => {
-			return Offline(() => {
+		it("mid is if both L and R are the same", async () => {
+			const buffer = await Offline(() => {
 				const split = new MidSideSplit();
 				split.mid.toDestination();
 				const merge = new Merge().connect(split);
 				new Signal(0.5).connect(merge, 0, 0);
 				new Signal(0.5).connect(merge, 0, 1);
-			}).then((buffer) => {
-				expect(buffer.min()).to.be.closeTo(0.707, 0.01);
-				expect(buffer.max()).to.be.closeTo(0.707, 0.01);
 			});
+			expect(buffer.min()).to.be.closeTo(0.707, 0.01);
+			expect(buffer.max()).to.be.closeTo(0.707, 0.01);
 		});
 
-		it("side is 0 if both L and R are the same", () => {
-			return Offline(() => {
+		it("side is 0 if both L and R are the same", async () => {
+			const buffer = await Offline(() => {
 				const split = new MidSideSplit();
 				split.side.toDestination();
 				const merge = new Merge().connect(split);
 				new Signal(0.5).connect(merge, 0, 0);
 				new Signal(0.5).connect(merge, 0, 1);
-			}).then((buffer) => {
-				expect(buffer.min()).to.be.closeTo(0, 0.01);
-				expect(buffer.max()).to.be.closeTo(0, 0.01);
 			});
+			expect(buffer.min()).to.be.closeTo(0, 0.01);
+			expect(buffer.max()).to.be.closeTo(0, 0.01);
 		});
 
-		it("mid is 0 if both L and R opposites", () => {
-			return Offline(() => {
+		it("mid is 0 if both L and R opposites", async () => {
+			const buffer = await Offline(() => {
 				const split = new MidSideSplit();
 				split.mid.toDestination();
 				const merge = new Merge().connect(split);
 				new Signal(-1).connect(merge, 0, 0);
 				new Signal(1).connect(merge, 0, 1);
-			}).then((buffer) => {
-				expect(buffer.min()).to.be.closeTo(0, 0.01);
-				expect(buffer.max()).to.be.closeTo(0, 0.01);
 			});
+			expect(buffer.min()).to.be.closeTo(0, 0.01);
+			expect(buffer.max()).to.be.closeTo(0, 0.01);
 		});
 
-		it("can decompose and reconstruct a signal", () => {
-			return Offline(
+		it("can decompose and reconstruct a signal", async () => {
+			const buffer = await Offline(
 				() => {
 					const midSideMerge = new MidSideMerge().toDestination();
 					const split = new MidSideSplit();
@@ -71,14 +68,13 @@ describe("MidSideSplit", () => {
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				buffer
-					.toArray()[0]
-					.forEach((l) => expect(l).to.be.closeTo(0.2, 0.01));
-				buffer
-					.toArray()[1]
-					.forEach((r) => expect(r).to.be.closeTo(0.4, 0.01));
-			});
+			);
+			buffer
+				.toArray()[0]
+				.forEach((l) => expect(l).to.be.closeTo(0.2, 0.01));
+			buffer
+				.toArray()[1]
+				.forEach((r) => expect(r).to.be.closeTo(0.4, 0.01));
 		});
 	});
 });

package/Tone/component/channel/Mono.test.ts

@@ -9,40 +9,38 @@ describe("Mono", () => {
 	BasicTests(Mono);
 
 	context("Mono", () => {
-		it("Makes a mono signal in both channels", () => {
-			return Offline(
+		it("Makes a mono signal in both channels", async () => {
+			const buffer = await Offline(
 				() => {
 					const mono = new Mono().toDestination();
 					const signal = new Signal(2).connect(mono);
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				expect(buffer.toArray()[0][0]).to.equal(2);
-				expect(buffer.toArray()[1][0]).to.equal(2);
-				expect(buffer.toArray()[0][100]).to.equal(2);
-				expect(buffer.toArray()[1][100]).to.equal(2);
-				expect(buffer.toArray()[0][1000]).to.equal(2);
-				expect(buffer.toArray()[1][1000]).to.equal(2);
-			});
+			);
+			expect(buffer.toArray()[0][0]).to.equal(2);
+			expect(buffer.toArray()[1][0]).to.equal(2);
+			expect(buffer.toArray()[0][100]).to.equal(2);
+			expect(buffer.toArray()[1][100]).to.equal(2);
+			expect(buffer.toArray()[0][1000]).to.equal(2);
+			expect(buffer.toArray()[1][1000]).to.equal(2);
 		});
 
-		it("Sums a stereo signal into a mono signal", () => {
-			return Offline(
+		it("Sums a stereo signal into a mono signal", async () => {
+			const buffer = await Offline(
 				() => {
 					const mono = new Mono().toDestination();
 					const signal = StereoSignal(2, 2).connect(mono);
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				expect(buffer.toArray()[0][0]).to.equal(2);
-				expect(buffer.toArray()[1][0]).to.equal(2);
-				expect(buffer.toArray()[0][100]).to.equal(2);
-				expect(buffer.toArray()[1][100]).to.equal(2);
-				expect(buffer.toArray()[0][1000]).to.equal(2);
-				expect(buffer.toArray()[1][1000]).to.equal(2);
-			});
+			);
+			expect(buffer.toArray()[0][0]).to.equal(2);
+			expect(buffer.toArray()[1][0]).to.equal(2);
+			expect(buffer.toArray()[0][100]).to.equal(2);
+			expect(buffer.toArray()[1][100]).to.equal(2);
+			expect(buffer.toArray()[0][1000]).to.equal(2);
+			expect(buffer.toArray()[1][1000]).to.equal(2);
 		});
 	});
 });

package/Tone/component/channel/PanVol.test.ts

@@ -42,14 +42,13 @@ describe("PanVol", () => {
 			});
 		});
 
-		it("can mute the volume", () => {
-			return Offline(() => {
+		it("can mute the volume", async () => {
+			const buffer = await Offline(() => {
 				const vol = new PanVol(0).toDestination();
 				new Signal(1).connect(vol);
 				vol.mute = true;
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
 			});
+			expect(buffer.isSilent()).to.be.true;
 		});
 	});
 });

package/Tone/component/channel/Panner.test.ts

@@ -30,56 +30,53 @@ describe("Panner", () => {
 			});
 		});
 
-		it("pans hard left when the pan is set to -1", () => {
-			return Offline(
+		it("pans hard left when the pan is set to -1", async () => {
+			const buffer = await Offline(
 				() => {
 					const panner = new Panner(-1).toDestination();
 					new Signal(1).connect(panner);
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				const l = buffer.toArray()[0];
-				const r = buffer.toArray()[1];
-				expect(l[0]).to.be.closeTo(1, 0.01);
-				expect(r[0]).to.be.closeTo(0, 0.01);
-			});
+			);
+			const l = buffer.toArray()[0];
+			const r = buffer.toArray()[1];
+			expect(l[0]).to.be.closeTo(1, 0.01);
+			expect(r[0]).to.be.closeTo(0, 0.01);
 		});
 
-		it("pans hard right when the pan is set to 1", () => {
-			return Offline(
+		it("pans hard right when the pan is set to 1", async () => {
+			const buffer = await Offline(
 				() => {
 					const panner = new Panner(1).toDestination();
 					new Signal(1).connect(panner);
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				const l = buffer.toArray()[0];
-				const r = buffer.toArray()[1];
-				expect(l[0]).to.be.closeTo(0, 0.01);
-				expect(r[0]).to.be.closeTo(1, 0.01);
-			});
+			);
+			const l = buffer.toArray()[0];
+			const r = buffer.toArray()[1];
+			expect(l[0]).to.be.closeTo(0, 0.01);
+			expect(r[0]).to.be.closeTo(1, 0.01);
 		});
 
-		it("mixes the signal in equal power when panned center", () => {
-			return Offline(
+		it("mixes the signal in equal power when panned center", async () => {
+			const buffer = await Offline(
 				() => {
 					const panner = new Panner(0).toDestination();
 					new Signal(1).connect(panner);
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				const l = buffer.toArray()[0];
-				const r = buffer.toArray()[1];
-				expect(l[0]).to.be.closeTo(0.707, 0.01);
-				expect(r[0]).to.be.closeTo(0.707, 0.01);
-			});
+			);
+			const l = buffer.toArray()[0];
+			const r = buffer.toArray()[1];
+			expect(l[0]).to.be.closeTo(0.707, 0.01);
+			expect(r[0]).to.be.closeTo(0.707, 0.01);
 		});
 
-		it("can chain two panners when channelCount is 2", () => {
-			return Offline(
+		it("can chain two panners when channelCount is 2", async () => {
+			const buffer = await Offline(
 				() => {
 					const panner1 = new Panner({
 						channelCount: 2,
@@ -89,12 +86,11 @@ describe("Panner", () => {
 				},
 				0.1,
 				2
-			).then((buffer) => {
-				const l = buffer.toArray()[0];
-				const r = buffer.toArray()[1];
-				expect(l[0]).to.be.closeTo(1, 0.01);
-				expect(r[0]).to.be.closeTo(0, 0.01);
-			});
+			);
+			const l = buffer.toArray()[0];
+			const r = buffer.toArray()[1];
+			expect(l[0]).to.be.closeTo(1, 0.01);
+			expect(r[0]).to.be.closeTo(0, 0.01);
 		});
 	});
 });

package/Tone/component/channel/Recorder.ts

@@ -121,7 +121,7 @@ export class Recorder extends ToneAudioNode<RecorderOptions> {
 
 			this._recorder.addEventListener("start", handleStart, false);
 		});
-		if(this.state === "stopped") {
+		if (this.state === "stopped") {
 			this._recorder.start();
 		} else {
 			this._recorder.resume();

package/Tone/component/channel/Volume.test.ts

@@ -74,33 +74,30 @@ describe("Volume", () => {
 			// });
 		});
 
-		it("can lower the volume", () => {
-			return Offline(() => {
+		it("can lower the volume", async () => {
+			const buffer = await Offline(() => {
 				const vol = new Volume(-10).toDestination();
 				new Signal(1).connect(vol);
-			}).then((buffer) => {
-				expect(buffer.value()).to.be.closeTo(0.315, 0.01);
 			});
+			expect(buffer.value()).to.be.closeTo(0.315, 0.01);
 		});
 
-		it("can mute the volume", () => {
-			return Offline(() => {
+		it("can mute the volume", async () => {
+			const buffer = await Offline(() => {
 				const vol = new Volume(0).toDestination();
 				new Signal(1).connect(vol);
 				vol.mute = true;
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.equal(true);
 			});
+			expect(buffer.isSilent()).to.equal(true);
 		});
 
-		it("muted when volume is set to -Infinity", () => {
-			return Offline(() => {
+		it("muted when volume is set to -Infinity", async () => {
+			const buffer = await Offline(() => {
 				const vol = new Volume(-Infinity).toDestination();
 				new Signal(1).connect(vol);
 				expect(vol.mute).to.equal(true);
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.equal(true);
 			});
+			expect(buffer.isSilent()).to.equal(true);
 		});
 
 		it("setting the volume unmutes it and reports itself as unmuted", () => {

package/Tone/component/dynamics/Gate.test.ts

@@ -46,28 +46,24 @@ describe("Gate", () => {
 			gate.dispose();
 		});
 
-		it("gates the incoming signal when below the threshold", () => {
-			return Offline(() => {
+		it("gates the incoming signal when below the threshold", async () => {
+			const buffer = await Offline(() => {
 				const gate = new Gate(-9);
 				const sig = new Signal(-12, "decibels");
 				sig.connect(gate);
 				gate.toDestination();
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
 			});
+			expect(buffer.isSilent()).to.be.true;
 		});
 
-		it("passes the incoming signal when above the threshold", () => {
-			it("gates the incoming signal when below the threshold", () => {
-				return Offline(() => {
-					const gate = new Gate(-11);
-					const sig = new Signal(-10, "decibels");
-					sig.connect(gate);
-					gate.toDestination();
-				}).then((buffer) => {
-					expect(buffer.min()).to.be.above(0);
-				});
+		it("passes the incoming signal when above the threshold", async () => {
+			const buffer = await Offline(() => {
+				const gate = new Gate(-11);
+				const sig = new Signal(-10, "decibels");
+				sig.connect(gate);
+				gate.toDestination();
 			});
+			expect(buffer.min()).to.be.above(0);
 		});
 	});
 });

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

@@ -74,23 +74,21 @@ describe("AmplitudeEnvelope", () => {
 			ampEnv.dispose();
 		});
 
-		it("passes no signal before being triggered", () => {
-			return Offline(() => {
+		it("passes no signal before being triggered", async () => {
+			const buffer = await Offline(() => {
 				const ampEnv = new AmplitudeEnvelope().toDestination();
 				new Signal(1).connect(ampEnv);
-			}).then((buffer) => {
-				expect(buffer.isSilent()).to.be.true;
 			});
+			expect(buffer.isSilent()).to.be.true;
 		});
 
-		it("passes signal once triggered", () => {
-			return Offline(() => {
+		it("passes signal once triggered", async () => {
+			const buffer = await Offline(() => {
 				const ampEnv = new AmplitudeEnvelope().toDestination();
 				new Signal(1).connect(ampEnv);
 				ampEnv.triggerAttack(0.1);
-			}, 0.2).then((buffer) => {
-				expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.1, 0.001);
-			});
+			}, 0.2);
+			expect(buffer.getTimeOfFirstSound()).to.be.closeTo(0.1, 0.001);
 		});
 	});
 });