tone 14.9.16 → 15.0.0

package/Tone/component/envelope/AmplitudeEnvelope.ts

@@ -1,7 +1,7 @@
-import { Gain } from "../../core/context/Gain";
-import { NormalRange, Time } from "../../core/type/Units";
-import { optionsFromArguments } from "../../core/util/Defaults";
-import { Envelope, EnvelopeOptions } from "./Envelope";
+import { Gain } from "../../core/context/Gain.js";
+import { NormalRange, Time } from "../../core/type/Units.js";
+import { optionsFromArguments } from "../../core/util/Defaults.js";
+import { Envelope, EnvelopeOptions } from "./Envelope.js";
 
 /**
  * AmplitudeEnvelope is a Tone.Envelope connected to a gain node.
@@ -26,7 +26,6 @@ import { Envelope, EnvelopeOptions } from "./Envelope";
  * @category Component
  */
 export class AmplitudeEnvelope extends Envelope {
-
 	readonly name: string = "AmplitudeEnvelope";
 
 	private _gainNode: Gain = new Gain({
@@ -45,10 +44,22 @@ export class AmplitudeEnvelope extends Envelope {
 	 * @param release	The amount of time after the release is triggered it takes to reach 0.
 	 *                        	Value must be greater than 0.
 	 */
-	constructor(attack?: Time, decay?: Time, sustain?: NormalRange, release?: Time);
-	constructor(options?: Partial<EnvelopeOptions>)
+	constructor(
+		attack?: Time,
+		decay?: Time,
+		sustain?: NormalRange,
+		release?: Time
+	);
+	constructor(options?: Partial<EnvelopeOptions>);
 	constructor() {
-		super(optionsFromArguments(AmplitudeEnvelope.getDefaults(), arguments, ["attack", "decay", "sustain", "release"]));
+		super(
+			optionsFromArguments(AmplitudeEnvelope.getDefaults(), arguments, [
+				"attack",
+				"decay",
+				"sustain",
+				"release",
+			])
+		);
 		this._sig.connect(this._gainNode.gain);
 		this.output = this._gainNode;
 		this.input = this._gainNode;

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

@@ -1,15 +1,13 @@
 import { expect } from "chai";
-import { BasicTests } from "test/helper/Basic";
-import { connectTo } from "test/helper/Connect";
-import { Offline } from "test/helper/Offline";
-import { Envelope, EnvelopeCurve } from "./Envelope";
+import { BasicTests } from "../../../test/helper/Basic.js";
+import { connectTo } from "../../../test/helper/Connect.js";
+import { Offline } from "../../../test/helper/Offline.js";
+import { Envelope, EnvelopeCurve } from "./Envelope.js";
 
 describe("Envelope", () => {
-
 	BasicTests(Envelope);
 
 	context("Envelope", () => {
-
 		it("has an output connections", () => {
 			const env = new Envelope();
 			env.connect(connectTo());
@@ -143,7 +141,7 @@ describe("Envelope", () => {
 		it("can set release to exponential or linear", () => {
 			return Offline(() => {
 				const env = new Envelope({
-					release: 0
+					release: 0,
 				});
 				env.toDestination();
 				env.triggerAttackRelease(0.4, 0);
@@ -159,7 +157,7 @@ describe("Envelope", () => {
 					attack: 0.5,
 					decay: 0.0,
 					sustain: 1,
-					release: 0.5
+					release: 0.5,
 				}).toDestination();
 				env.triggerAttackRelease(0.5);
 			}, 0.7).then((buffer) => {
@@ -180,17 +178,30 @@ describe("Envelope", () => {
 				sustain: 0.5,
 			};
 			return Offline(() => {
-				const env = new Envelope(e.attack, e.decay, e.sustain, e.release);
+				const env = new Envelope(
+					e.attack,
+					e.decay,
+					e.sustain,
+					e.release
+				);
 				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.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);
@@ -205,15 +216,24 @@ describe("Envelope", () => {
 				sustain: 0.5,
 			};
 			return Offline(() => {
-				const env = new Envelope(e.attack, e.decay, e.sustain, e.release);
+				const env = new Envelope(
+					e.attack,
+					e.decay,
+					e.sustain,
+					e.release
+				);
 				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);
+				buffer.forEachBetween(
+					(sample, time) => {
+						const target = 1 - (time - 0.2) * 10;
+						expect(sample).to.be.closeTo(target, 0.01);
+					},
+					0.2,
+					0.2
+				);
 			});
 		});
 
@@ -225,7 +245,12 @@ describe("Envelope", () => {
 				sustain: 0,
 			};
 			return Offline(() => {
-				const env = new Envelope(e.attack, e.decay, e.sustain, e.release);
+				const env = new Envelope(
+					e.attack,
+					e.decay,
+					e.sustain,
+					e.release
+				);
 				env.decayCurve = "linear";
 				env.toDestination();
 				env.triggerAttack(0);
@@ -248,7 +273,12 @@ describe("Envelope", () => {
 				sustain: 0,
 			};
 			return Offline(() => {
-				const env = new Envelope(e.attack, e.decay, e.sustain, e.release);
+				const env = new Envelope(
+					e.attack,
+					e.decay,
+					e.sustain,
+					e.release
+				);
 				env.decayCurve = "exponential";
 				env.toDestination();
 				env.triggerAttack(0);
@@ -270,17 +300,30 @@ describe("Envelope", () => {
 				sustain: 0.1,
 			};
 			return Offline(() => {
-				const env = new Envelope(e.attack, e.decay, e.sustain, e.release);
+				const env = new Envelope(
+					e.attack,
+					e.decay,
+					e.sustain,
+					e.release
+				);
 				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.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);
@@ -308,16 +351,25 @@ describe("Envelope", () => {
 			};
 			const releaseTime = 0.2;
 			return Offline(() => {
-				const env = new Envelope(e.attack, e.decay, e.sustain, e.release);
+				const env = new Envelope(
+					e.attack,
+					e.decay,
+					e.sustain,
+					e.release
+				);
 				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.below(e.sustain + 0.01);
+					},
+					sustainStart,
+					sustainEnd
+				);
 				buffer.forEachBetween((sample) => {
 					expect(sample).to.be.closeTo(0, 0.01);
 				}, releaseTime + e.release);
@@ -332,7 +384,7 @@ describe("Envelope", () => {
 				env.triggerAttack(0);
 				env.triggerRelease(0.4);
 				env.triggerAttack(0.4);
-			}, 0.6).then(buffer => {
+			}, 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);
@@ -349,14 +401,23 @@ describe("Envelope", () => {
 			const releaseTime = 0.2;
 			const attackTime = 0.1;
 			return Offline(() => {
-				const env = new Envelope(e.attack, e.decay, e.sustain, e.release);
+				const env = new Envelope(
+					e.attack,
+					e.decay,
+					e.sustain,
+					e.release
+				);
 				env.attackCurve = "exponential";
 				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);
+				expect(
+					buffer.getValueAtTime(
+						e.attack + e.decay + releaseTime + e.release
+					)
+				).to.be.below(0.01);
 			});
 		});
 
@@ -373,8 +434,12 @@ describe("Envelope", () => {
 				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);
+					expect(buffer.getValueAtTime(attackTime - 0.001)).to.equal(
+						0
+					);
+					expect(
+						buffer.getValueAtTime(attackTime + e.attack + e.decay)
+					).to.be.below(0.01);
 				});
 			});
 		});
@@ -388,7 +453,12 @@ describe("Envelope", () => {
 			};
 			const releaseTime = 0.4;
 			return Offline(() => {
-				const env = new Envelope(e.attack, e.decay, e.sustain, e.release);
+				const env = new Envelope(
+					e.attack,
+					e.decay,
+					e.sustain,
+					e.release
+				);
 				env.toDestination();
 				env.triggerAttack(0);
 				env.triggerRelease(releaseTime);
@@ -419,7 +489,12 @@ describe("Envelope", () => {
 			const releaseTime = 0.4;
 			const duration = 0.4;
 			return Offline(() => {
-				const env = new Envelope(e.attack, e.decay, e.sustain, e.release);
+				const env = new Envelope(
+					e.attack,
+					e.decay,
+					e.sustain,
+					e.release
+				);
 				env.toDestination();
 				env.triggerAttack(0);
 				env.triggerRelease(releaseTime);
@@ -451,7 +526,12 @@ describe("Envelope", () => {
 			const duration = 0.4;
 			const velocity = 0.4;
 			return Offline(() => {
-				const env = new Envelope(e.attack, e.decay, e.sustain, e.release);
+				const env = new Envelope(
+					e.attack,
+					e.decay,
+					e.sustain,
+					e.release
+				);
 				env.toDestination();
 				env.triggerAttack(0, velocity);
 				env.triggerRelease(releaseTime);
@@ -460,11 +540,17 @@ describe("Envelope", () => {
 					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);
+						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);
+						expect(sample).to.be.within(
+							0,
+							e.sustain * velocity + 0.01
+						);
 					} else {
 						expect(sample).to.be.below(0.01);
 					}
@@ -480,7 +566,12 @@ describe("Envelope", () => {
 				sustain: 0.0,
 			};
 			return Offline(() => {
-				const env = new Envelope(e.attack, e.decay, e.sustain, e.release);
+				const env = new Envelope(
+					e.attack,
+					e.decay,
+					e.sustain,
+					e.release
+				);
 				env.toDestination();
 				env.triggerAttack(0);
 				env.triggerAttack(0.5);
@@ -632,13 +723,19 @@ describe("Envelope", () => {
 	});
 
 	context("Attack/Release Curves", () => {
-
-		const envelopeCurves: EnvelopeCurve[] = ["linear", "exponential", "bounce", "cosine", "ripple", "sine", "step"];
+		const envelopeCurves: EnvelopeCurve[] = [
+			"linear",
+			"exponential",
+			"bounce",
+			"cosine",
+			"ripple",
+			"sine",
+			"step",
+		];
 
 		it("can get set all of the types as the attackCurve", () => {
-
 			const env = new Envelope();
-			envelopeCurves.forEach(type => {
+			envelopeCurves.forEach((type) => {
 				env.attackCurve = type;
 				expect(env.attackCurve).to.equal(type);
 			});
@@ -647,7 +744,7 @@ describe("Envelope", () => {
 
 		it("can get set all of the types as the releaseCurve", () => {
 			const env = new Envelope();
-			envelopeCurves.forEach(type => {
+			envelopeCurves.forEach((type) => {
 				env.releaseCurve = type;
 				expect(env.releaseCurve).to.equal(type);
 			});
@@ -666,9 +763,13 @@ describe("Envelope", () => {
 				}).toDestination();
 				env.triggerAttackRelease(0.3, 0.1);
 			}, 0.8).then((buffer) => {
-				buffer.forEachBetween((sample) => {
-					expect(sample).to.be.above(0);
-				}, 0.101, 0.7);
+				buffer.forEachBetween(
+					(sample) => {
+						expect(sample).to.be.above(0);
+					},
+					0.101,
+					0.7
+				);
 			});
 		});
 
@@ -684,9 +785,13 @@ describe("Envelope", () => {
 				}).toDestination();
 				env.triggerAttackRelease(0.3, 0.1);
 			}, 0.8).then((buffer) => {
-				buffer.forEachBetween((sample) => {
-					expect(sample).to.be.above(0);
-				}, 0.101, 0.7);
+				buffer.forEachBetween(
+					(sample) => {
+						expect(sample).to.be.above(0);
+					},
+					0.101,
+					0.7
+				);
 			});
 		});
 
@@ -702,9 +807,13 @@ describe("Envelope", () => {
 				}).toDestination();
 				env.triggerAttackRelease(0.3, 0.1);
 			}, 0.8).then((buffer) => {
-				buffer.forEachBetween((sample) => {
-					expect(sample).to.be.above(0);
-				}, 0.101, 0.7);
+				buffer.forEachBetween(
+					(sample) => {
+						expect(sample).to.be.above(0);
+					},
+					0.101,
+					0.7
+				);
 			});
 		});
 
@@ -720,9 +829,13 @@ describe("Envelope", () => {
 				}).toDestination();
 				env.triggerAttackRelease(0.3, 0.1);
 			}, 0.8).then((buffer) => {
-				buffer.forEachBetween((sample) => {
-					expect(sample).to.be.above(0);
-				}, 0.101, 0.7);
+				buffer.forEachBetween(
+					(sample) => {
+						expect(sample).to.be.above(0);
+					},
+					0.101,
+					0.7
+				);
 			});
 		});
 
@@ -792,8 +905,8 @@ describe("Envelope", () => {
 		it("can render the envelope to a curve", async () => {
 			const env = new Envelope();
 			const curve = await env.asArray();
-			expect(curve.some(v => v > 0)).to.be.true;
-			curve.forEach(v => expect(v).to.be.within(0, 1));
+			expect(curve.some((v) => v > 0)).to.be.true;
+			curve.forEach((v) => expect(v).to.be.within(0, 1));
 			env.dispose();
 		});
 

package/Tone/component/envelope/Envelope.ts

@@ -1,12 +1,15 @@
-import { InputNode, OutputNode } from "../../core/context/ToneAudioNode";
-import { ToneAudioNode, ToneAudioNodeOptions } from "../../core/context/ToneAudioNode";
-import { NormalRange, Time } from "../../core/type/Units";
-import { optionsFromArguments } from "../../core/util/Defaults";
-import { isArray, isObject, isString } from "../../core/util/TypeCheck";
-import { connectSignal, Signal } from "../../signal/Signal";
-import { OfflineContext } from "../../core/context/OfflineContext";
-import { assert } from "../../core/util/Debug";
-import { range, timeRange } from "../../core/util/Decorator";
+import { InputNode, OutputNode } from "../../core/context/ToneAudioNode.js";
+import {
+	ToneAudioNode,
+	ToneAudioNodeOptions,
+} from "../../core/context/ToneAudioNode.js";
+import { NormalRange, Time } from "../../core/type/Units.js";
+import { optionsFromArguments } from "../../core/util/Defaults.js";
+import { isArray, isObject, isString } from "../../core/util/TypeCheck.js";
+import { connectSignal, Signal } from "../../signal/Signal.js";
+import { OfflineContext } from "../../core/context/OfflineContext.js";
+import { assert } from "../../core/util/Debug.js";
+import { range, timeRange } from "../../core/util/Decorator.js";
 
 type BasicEnvelopeCurve = "linear" | "exponential";
 type InternalEnvelopeCurve = BasicEnvelopeCurve | number[];
@@ -50,7 +53,6 @@ export interface EnvelopeOptions extends ToneAudioNodeOptions {
  * @category Component
  */
 export class Envelope extends ToneAudioNode<EnvelopeOptions> {
-
 	readonly name: string = "Envelope";
 
 	/**
@@ -176,12 +178,27 @@ export class Envelope extends ToneAudioNode<EnvelopeOptions> {
 	 * @param release	The amount of time after the release is triggered it takes to reach 0.
 	 *                        	Value must be greater than 0.
 	 */
-	constructor(attack?: Time, decay?: Time, sustain?: NormalRange, release?: Time);
-	constructor(options?: Partial<EnvelopeOptions>)
+	constructor(
+		attack?: Time,
+		decay?: Time,
+		sustain?: NormalRange,
+		release?: Time
+	);
+	constructor(options?: Partial<EnvelopeOptions>);
 	constructor() {
-
-		super(optionsFromArguments(Envelope.getDefaults(), arguments, ["attack", "decay", "sustain", "release"]));
-		const options = optionsFromArguments(Envelope.getDefaults(), arguments, ["attack", "decay", "sustain", "release"]);
+		super(
+			optionsFromArguments(Envelope.getDefaults(), arguments, [
+				"attack",
+				"decay",
+				"sustain",
+				"release",
+			])
+		);
+		const options = optionsFromArguments(
+			Envelope.getDefaults(),
+			arguments,
+			["attack", "decay", "sustain", "release"]
+		);
 
 		this.attack = options.attack;
 		this.decay = options.decay;
@@ -218,7 +235,10 @@ export class Envelope extends ToneAudioNode<EnvelopeOptions> {
 	 * @param  direction  In/Out
 	 * @return The curve name
 	 */
-	private _getCurve(curve: InternalEnvelopeCurve, direction: EnvelopeDirection): EnvelopeCurve {
+	private _getCurve(
+		curve: InternalEnvelopeCurve,
+		direction: EnvelopeDirection
+	): EnvelopeCurve {
 		if (isString(curve)) {
 			return curve;
 		} else {
@@ -243,7 +263,7 @@ export class Envelope extends ToneAudioNode<EnvelopeOptions> {
 	private _setCurve(
 		name: "_attackCurve" | "_decayCurve" | "_releaseCurve",
 		direction: EnvelopeDirection,
-		curve: EnvelopeCurve,
+		curve: EnvelopeCurve
 	): void {
 		// check if it's a valid type
 		if (isString(curve) && Reflect.has(EnvelopeCurves, curve)) {
@@ -385,9 +405,16 @@ export class Envelope extends ToneAudioNode<EnvelopeOptions> {
 			const decayStart = time + attack;
 			this.log("decay", decayStart);
 			if (this._decayCurve === "linear") {
-				this._sig.linearRampToValueAtTime(decayValue, decay + decayStart);
+				this._sig.linearRampToValueAtTime(
+					decayValue,
+					decay + decayStart
+				);
 			} else {
-				this._sig.exponentialApproachValueAtTime(decayValue, decayStart, decay);
+				this._sig.exponentialApproachValueAtTime(
+					decayValue,
+					decayStart,
+					decay
+				);
 			}
 		}
 		return this;
@@ -418,9 +445,17 @@ export class Envelope extends ToneAudioNode<EnvelopeOptions> {
 			} else if (this._releaseCurve === "exponential") {
 				this._sig.targetRampTo(0, release, time);
 			} else {
-				assert(isArray(this._releaseCurve), "releaseCurve must be either 'linear', 'exponential' or an array");
+				assert(
+					isArray(this._releaseCurve),
+					"releaseCurve must be either 'linear', 'exponential' or an array"
+				);
 				this._sig.cancelAndHoldAtTime(time);
-				this._sig.setValueCurveAtTime(this._releaseCurve, time, release, currentValue);
+				this._sig.setValueCurveAtTime(
+					this._releaseCurve,
+					time,
+					release,
+					currentValue
+				);
 			}
 		}
 		return this;
@@ -450,7 +485,11 @@ export class Envelope extends ToneAudioNode<EnvelopeOptions> {
 	 * // trigger the release 0.5 seconds after the attack
 	 * env.triggerAttackRelease(0.5);
 	 */
-	triggerAttackRelease(duration: Time, time?: Time, velocity: NormalRange = 1): this {
+	triggerAttackRelease(
+		duration: Time,
+		time?: Time,
+		velocity: NormalRange = 1
+	): this {
 		time = this.toSeconds(time);
 		this.triggerAttack(time, velocity);
 		this.triggerRelease(time + this.toSeconds(duration));
@@ -480,21 +519,33 @@ export class Envelope extends ToneAudioNode<EnvelopeOptions> {
 	 */
 	async asArray(length = 1024): Promise<Float32Array> {
 		const duration = length / this.context.sampleRate;
-		const context = new OfflineContext(1, duration, this.context.sampleRate);
+		const context = new OfflineContext(
+			1,
+			duration,
+			this.context.sampleRate
+		);
 		// normalize the ADSR for the given duration with 20% sustain time
-		const attackPortion = this.toSeconds(this.attack) + this.toSeconds(this.decay);
+		const attackPortion =
+			this.toSeconds(this.attack) + this.toSeconds(this.decay);
 		const envelopeDuration = attackPortion + this.toSeconds(this.release);
 		const sustainTime = envelopeDuration * 0.1;
 		const totalDuration = envelopeDuration + sustainTime;
 		// @ts-ignore
-		const clone = new this.constructor(Object.assign(this.get(), {
-			attack: duration * this.toSeconds(this.attack) / totalDuration,
-			decay: duration * this.toSeconds(this.decay) / totalDuration,
-			release: duration * this.toSeconds(this.release) / totalDuration,
-			context
-		})) as Envelope;
+		const clone = new this.constructor(
+			Object.assign(this.get(), {
+				attack:
+					(duration * this.toSeconds(this.attack)) / totalDuration,
+				decay: (duration * this.toSeconds(this.decay)) / totalDuration,
+				release:
+					(duration * this.toSeconds(this.release)) / totalDuration,
+				context,
+			})
+		) as Envelope;
 		clone._sig.toDestination();
-		clone.triggerAttackRelease(duration * (attackPortion + sustainTime) / totalDuration, 0);
+		clone.triggerAttackRelease(
+			(duration * (attackPortion + sustainTime)) / totalDuration,
+			0
+		);
 		const buffer = await context.render();
 		return buffer.getChannelData(0);
 	}
@@ -529,7 +580,6 @@ type EnvelopeCurveName = keyof EnvelopeCurveMap;
  * Generate some complex envelope curves.
  */
 const EnvelopeCurves: EnvelopeCurveMap = (() => {
-
 	const curveLen = 128;
 
 	let i: number;
@@ -545,8 +595,9 @@ const EnvelopeCurves: EnvelopeCurveMap = (() => {
 	const rippleCurve: number[] = [];
 	const rippleCurveFreq = 6.4;
 	for (i = 0; i < curveLen - 1; i++) {
-		k = (i / (curveLen - 1));
-		const sineWave = Math.sin(k * (Math.PI * 2) * rippleCurveFreq - Math.PI / 2) + 1;
+		k = i / (curveLen - 1);
+		const sineWave =
+			Math.sin(k * (Math.PI * 2) * rippleCurveFreq - Math.PI / 2) + 1;
 		rippleCurve[i] = sineWave / 10 + k * 0.83;
 	}
 	rippleCurve[curveLen - 1] = 1;