tone 15.2.2 → 15.2.4

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/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/envelope/Envelope.ts

@@ -116,7 +116,7 @@ export class Envelope extends ToneAudioNode<EnvelopeOptions> {
 
 	/**
 	 * After triggerRelease is called, the envelope's
-	 * value will fall to it's miminum value over the
+	 * value will fall to its minimum value over the
 	 * duration of the release time.
 	 * ```
 	 *           /\

package/Tone/component/filter/LowpassCombFilter.ts

@@ -51,7 +51,7 @@ export class LowpassCombFilter extends ToneAudioNode<LowpassCombFilterOptions> {
 	/**
 	 * @param delayTime The delay time of the comb filter
 	 * @param resonance The resonance (feedback) of the comb filter
-	 * @param dampening The cutoff of the lowpass filter dampens the signal as it is fedback.
+	 * @param dampening The cutoff of the lowpass filter dampens the signal as it is fed back.
 	 */
 	constructor(
 		delayTime?: Time,

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

@@ -163,37 +163,37 @@ describe("Clock", () => {
 		});
 
 		it("can be scheduled to start in the future", async () => {
-			let invokations = 0;
+			let invocations = 0;
 			await Offline(() => {
 				const clock = new Clock((time) => {
-					invokations++;
+					invocations++;
 				}, 2).start(0.1);
 			}, 0.4);
-			expect(invokations).to.equal(1);
+			expect(invocations).to.equal(1);
 		});
 
 		it("invokes the right number of callbacks given the duration", async () => {
-			let invokations = 0;
+			let invocations = 0;
 			await Offline(() => {
 				new Clock((time) => {
-					invokations++;
+					invocations++;
 				}, 10)
 					.start(0)
 					.stop(0.45);
 			}, 0.6);
-			expect(invokations).to.equal(5);
+			expect(invocations).to.equal(5);
 		});
 
 		it("can schedule the frequency of the clock", async () => {
-			let invokations = 0;
+			let invocations = 0;
 			await Offline(() => {
 				const clock = new Clock((time, ticks) => {
-					invokations++;
+					invocations++;
 				}, 2);
 				clock.start(0).stop(1.01);
 				clock.frequency.setValueAtTime(4, 0.5);
 			}, 2);
-			expect(invokations).to.equal(4);
+			expect(invocations).to.equal(4);
 		});
 	});
 

package/Tone/core/clock/TickParam.ts

@@ -128,7 +128,7 @@ export class TickParam<
 	}
 
 	exponentialRampToValueAtTime(value: UnitMap[TypeName], time: Time): this {
-		// aproximate it with multiple linear ramps
+		// approximate it with multiple linear ramps
 		time = this.toSeconds(time);
 		const computedVal = this._fromType(value);
 

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

@@ -152,12 +152,12 @@ describe("TickSignal", () => {
 		expect(tickSignal0.getTimeOfTick(3)).to.be.closeTo(3, 0.01);
 		tickSignal0.dispose();
 
-		const tickSigna1 = new TickSignal(2);
-		expect(tickSigna1.getTimeOfTick(0)).to.be.closeTo(0, 0.01);
-		expect(tickSigna1.getTimeOfTick(1)).to.be.closeTo(0.5, 0.01);
-		expect(tickSigna1.getTimeOfTick(2)).to.be.closeTo(1, 0.01);
-		expect(tickSigna1.getTimeOfTick(3)).to.be.closeTo(1.5, 0.01);
-		tickSigna1.dispose();
+		const tickSignal = new TickSignal(2);
+		expect(tickSignal.getTimeOfTick(0)).to.be.closeTo(0, 0.01);
+		expect(tickSignal.getTimeOfTick(1)).to.be.closeTo(0.5, 0.01);
+		expect(tickSignal.getTimeOfTick(2)).to.be.closeTo(1, 0.01);
+		expect(tickSignal.getTimeOfTick(3)).to.be.closeTo(1.5, 0.01);
+		tickSignal.dispose();
 	});
 
 	it("computes the time of a given tick when setValueAtTime is scheduled", () => {

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

@@ -149,7 +149,7 @@ describe("TickSource", () => {
 			source.dispose();
 		});
 
-		it("can invoke stop multiple times, takes the last invokation", () => {
+		it("can invoke stop multiple times, takes the last invocation", () => {
 			const source = new TickSource(1);
 			source.start(0).stop(3).stop(2).stop(4);
 			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);

package/Tone/core/context/Context.ts

@@ -394,7 +394,7 @@ export class Context extends BaseContext {
 	/**
 	 * How often the interval callback is invoked.
 	 * This number corresponds to how responsive the scheduling
-	 * can be. Setting to 0 will result in the lowest practial interval
+	 * can be. Setting to 0 will result in the lowest practical interval
 	 * based on context properties. context.updateInterval + context.lookAhead
 	 * gives you the total latency between scheduling an event and hearing it.
 	 */

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

@@ -268,7 +268,7 @@ describe("ToneAudioBuffer", () => {
 			buffer.dispose();
 		});
 
-		it("can convert from a multidimentional array", () => {
+		it("can convert from a multidimensional array", () => {
 			const buffer = new ToneAudioBuffer();
 			const arr = [
 				new Float32Array(0.5 * buffer.sampleRate),

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

@@ -38,7 +38,7 @@ describe("ToneAudioBuffers", () => {
 		);
 	});
 
-	it("throws an error when it tries to get an object that doesnt exist", (done) => {
+	it("throws an error when it tries to get an object that doesn't exist", (done) => {
 		const buffer = new ToneAudioBuffers(
 			{
 				sine: testFile,

package/Tone/core/context/ToneAudioBuffers.ts

@@ -18,7 +18,7 @@ interface ToneAudioBuffersOptions {
 }
 
 /**
- * A data structure for holding multiple buffers in a Map-like datastructure.
+ * A data structure for holding multiple buffers in a Map-like data structure.
  *
  * @example
  * const pianoSamples = new Tone.ToneAudioBuffers({
@@ -141,7 +141,7 @@ export class ToneAudioBuffers extends Tone {
 	/**
 	 * Add a buffer by name and url to the Buffers
 	 * @param  name      A unique name to give the buffer
-	 * @param  url  Either the url of the bufer, or a buffer which will be added with the given name.
+	 * @param  url  Either the url of the buffer, or a buffer which will be added with the given name.
 	 * @param  callback  The callback to invoke when the url is loaded.
 	 * @param  onerror  Invoked if the buffer can't be loaded
 	 */

package/Tone/core/type/Frequency.test.ts

@@ -112,27 +112,27 @@ describe("FrequencyClass", () => {
 			});
 		});
 
-		it("evalutes hertz", () => {
+		it("evaluates hertz", () => {
 			expect(Frequency("1hz").valueOf()).to.equal(1);
 			expect(Frequency("2hz").valueOf()).to.equal(2);
 			expect(Frequency(4, "hz").valueOf()).to.equal(4);
 			expect(Frequency("0.25hz").valueOf()).to.equal(0.25);
 		});
 
-		it("evalutes ticks", () => {
+		it("evaluates ticks", () => {
 			return Offline(({ transport }) => {
 				expect(Frequency(transport.PPQ, "i").valueOf()).to.equal(2);
 				expect(Frequency(1, "i").valueOf()).to.equal(transport.PPQ * 2);
 			});
 		});
 
-		it("evalutes transport time", () => {
+		it("evaluates transport time", () => {
 			expect(Frequency("1:0").valueOf()).to.equal(0.5);
 			expect(Frequency("1:4:0").valueOf()).to.equal(0.25);
 			// expect(Frequency("2:1:0").valueOf()).to.equal(0.25);
 		});
 
-		it("evalutes midi", () => {
+		it("evaluates midi", () => {
 			expect(Frequency(48, "midi").valueOf()).to.be.closeTo(
 				TonalMidi.midiToFreq(48),
 				0.0001
@@ -143,7 +143,7 @@ describe("FrequencyClass", () => {
 			);
 		});
 
-		it("evalutes hz", () => {
+		it("evaluates hz", () => {
 			expect(Frequency(48, "hz").valueOf()).to.equal(48);
 			expect(Frequency(480, "hz").valueOf()).to.equal(480);
 		});
@@ -218,7 +218,7 @@ describe("FrequencyClass", () => {
 			);
 		});
 
-		it("can accomidate different concert tuning", () => {
+		it("can accommodate different concert tuning", () => {
 			FrequencyClass.A4 = 444;
 			expect(Frequency("C4").valueOf()).to.be.closeTo(
 				TonalMidi.midiToFreq(

package/Tone/core/type/Ticks.test.ts

@@ -133,7 +133,7 @@ describe("TicksClass", () => {
 			});
 		});
 
-		it("can get the next subdivison when the transport is started", () => {
+		it("can get the next subdivision when the transport is started", () => {
 			return Offline((context) => {
 				const transport = context.transport;
 				transport.start();

package/Tone/core/type/Time.test.ts

@@ -72,7 +72,7 @@ describe("TimeClass", () => {
 			});
 		});
 
-		it("evalutes objects", () => {
+		it("evaluates objects", () => {
 			return Offline(() => {
 				expect(Time({ "4n": 3 }).valueOf()).to.equal(1.5);
 				expect(Time({ "8t": 2, "1m": 3 }).valueOf()).to.be.closeTo(
@@ -98,7 +98,7 @@ describe("TimeClass", () => {
 			expect(Time(2).quantize(8, 0.75).valueOf()).to.equal(0.5);
 		});
 
-		it("can get the next subdivison when the transport is started", () => {
+		it("can get the next subdivision when the transport is started", () => {
 			return Offline((context) => {
 				const transport = context.transport;
 				transport.start(0.1);

package/Tone/core/type/TransportTime.test.ts

@@ -116,7 +116,7 @@ describe("TransportTimeClass", () => {
 			});
 		});
 
-		it("can get the next subdivison when the transport is started", () => {
+		it("can get the next subdivision when the transport is started", () => {
 			return Offline((context) => {
 				const transport = context.transport;
 				transport.start();

package/Tone/core/util/IntervalTimeline.test.ts

@@ -26,7 +26,7 @@ describe("IntervalTimeline", () => {
 			sched.dispose();
 		});
 
-		it("computes the lenght of the timeline correctly after adding events", () => {
+		it("computes the length of the timeline correctly after adding events", () => {
 			const sched = new IntervalTimeline();
 			sched.add({
 				duration: 0.2,

package/Tone/core/util/IntervalTimeline.ts

@@ -26,7 +26,7 @@ export class IntervalTimeline extends Tone {
 	readonly name: string = "IntervalTimeline";
 
 	/**
-	 * The root node of the inteval tree
+	 * The root node of the interval tree
 	 */
 	private _root: IntervalNode | null = null;
 

package/Tone/core/util/StateTimeline.test.ts

@@ -51,7 +51,7 @@ describe("StateTimeline", () => {
 		sched.dispose();
 	});
 
-	it("gets the last occurance of the state at or before the given time", () => {
+	it("gets the last occurrence of the state at or before the given time", () => {
 		const sched = new StateTimeline();
 		sched.setStateAtTime("started", 0);
 		sched.setStateAtTime("stopped", 1);
@@ -68,7 +68,7 @@ describe("StateTimeline", () => {
 		sched.dispose();
 	});
 
-	it("gets the next occurance of the state at or before the given time", () => {
+	it("gets the next occurrence of the state at or before the given time", () => {
 		const sched = new StateTimeline();
 		sched.setStateAtTime("started", 0);
 		sched.setStateAtTime("stopped", 1);

package/Tone/core/util/Timeline.test.ts

@@ -303,7 +303,7 @@ describe("Timeline", () => {
 		sched.dispose();
 	});
 
-	it("inforces increasing time", () => {
+	it("enforces increasing time", () => {
 		const sched = new Timeline({
 			increasing: true,
 		});

package/Tone/core/util/Timeline.ts

@@ -348,7 +348,7 @@ export class Timeline<GenericEvent extends TimelineEvent> extends Tone {
 
 	/**
 	 * Iterate over everything in the array between the startTime and endTime.
-	 * The timerange is inclusive of the startTime, but exclusive of the endTime.
+	 * The time range is inclusive of the startTime, but exclusive of the endTime.
 	 * range = [startTime, endTime).
 	 * @param  startTime The time to check if items are before
 	 * @param  endTime The end of the test interval.

package/Tone/effect/AutoWah.ts

@@ -75,7 +75,7 @@ export class AutoWah extends Effect<AutoWahOptions> {
 	private _bandpass: Filter;
 
 	/**
-	 * The peaking fitler
+	 * The peaking filter
 	 */
 	private _peaking: Filter;
 

package/Tone/effect/FrequencyShifter.ts

@@ -20,7 +20,7 @@ export interface FrequencyShifterOptions extends EffectOptions {
  * Note: Contrary to pitch shifting, all frequencies are shifted by the same amount,
  * destroying the harmonic relationship between them. This leads to the classic ring modulator timbre distortion.
  * The algorithm will produces some aliasing towards the high end, especially if your source material
- * contains a lot of high frequencies. Unfortunatelly the webaudio API does not support resampling
+ * contains a lot of high frequencies. Unfortunately the Web Audio API does not support resampling
  * buffers in real time, so it is not possible to fix it properly. Depending on the use case it might
  * be an option to low pass filter your input before frequency shifting it to get ride of the aliasing.
  * You can find a very detailed description of the algorithm here: https://larzeitlin.github.io/RMFS/

package/Tone/effect/MidSideEffect.ts

@@ -10,7 +10,7 @@ export type MidSideEffectOptions = EffectOptions;
  * (which comes out of both the left and the right channel)
  * and the 'side' (which only comes out of the the side channels)
  * and effects them separately before being recombined.
- * Applies a Mid/Side seperation and recombination.
+ * Applies a Mid/Side separation and recombination.
  * Algorithm found in [kvraudio forums](http://www.kvraudio.com/forum/viewtopic.php?t=212587).
  * This is a base-class for Mid/Side Effects.
  * @category Effect

package/Tone/effect/StereoWidener.ts

@@ -15,7 +15,7 @@ export interface StereoWidenerOptions extends MidSideEffectOptions {
 }
 
 /**
- * Applies a width factor to the mid/side seperation.
+ * Applies a width factor to the mid/side separation.
  * 0 is all mid and 1 is all side.
  * Algorithm found in [kvraudio forums](http://www.kvraudio.com/forum/viewtopic.php?t=212587).
  * ```

package/Tone/effect/Vibrato.ts

@@ -65,7 +65,7 @@ export class Vibrato extends Effect<VibratoOptions> {
 			min: 0,
 			max: options.maxDelay,
 			frequency: options.frequency,
-			phase: -90, // offse the phase so the resting position is in the center
+			phase: -90, // offset the phase so the resting position is in the center
 		})
 			.start()
 			.connect(this._delayNode.delayTime);

package/Tone/event/Part.test.ts

@@ -301,14 +301,14 @@ describe("Part", () => {
 		});
 
 		it("is invoked after it's started", async () => {
-			let invokations = 0;
+			let invocations = 0;
 			await Offline(({ transport }) => {
 				const part = new Part(() => {
-					invokations++;
+					invocations++;
 				}, [0, 0.1]).start(0);
 				transport.start();
 			}, 0.2);
-			expect(invokations).to.equal(2);
+			expect(invocations).to.equal(2);
 		});
 
 		it("passes in the scheduled time to the callback", async () => {
@@ -421,7 +421,7 @@ describe("Part", () => {
 		});
 
 		it("can schedule a subpart", async () => {
-			let invokations = 0;
+			let invocations = 0;
 			await Offline(({ transport }) => {
 				const startTime = 0.1;
 				const subPart = new Part({
@@ -431,7 +431,7 @@ describe("Part", () => {
 					],
 				});
 				const part = new Part((time, value) => {
-					invokations++;
+					invocations++;
 					if (value === 0) {
 						expect(time - startTime).to.be.closeTo(0, 0.01);
 					} else if (value === 1) {
@@ -446,7 +446,7 @@ describe("Part", () => {
 					.start(0);
 				transport.start(startTime);
 			}, 0.7);
-			expect(invokations).to.equal(3);
+			expect(invocations).to.equal(3);
 		});
 
 		it("can start with an offset", async () => {

package/Tone/event/Part.ts

@@ -384,10 +384,10 @@ export class Part<ValueType = any> extends ToneEvent<ValueType> {
 
 	/**
 	 * Determine if the event should be currently looping
-	 * given the loop boundries of this Part.
+	 * given the loop boundaries of this Part.
 	 * @param  event  The event to test
 	 */
-	private _testLoopBoundries(event: ToneEvent): void {
+	private _testLoopBoundaries(event: ToneEvent): void {
 		if (
 			this._loop &&
 			(event.startOffset < this._loopStart ||
@@ -439,7 +439,7 @@ export class Part<ValueType = any> extends ToneEvent<ValueType> {
 			event.loopStart = this.loopStart;
 			event.loopEnd = this.loopEnd;
 			event.loop = loop;
-			this._testLoopBoundries(event);
+			this._testLoopBoundaries(event);
 		});
 	}
 
@@ -455,7 +455,7 @@ export class Part<ValueType = any> extends ToneEvent<ValueType> {
 		if (this._loop) {
 			this._forEach((event) => {
 				event.loopEnd = loopEnd;
-				this._testLoopBoundries(event);
+				this._testLoopBoundaries(event);
 			});
 		}
 	}
@@ -472,7 +472,7 @@ export class Part<ValueType = any> extends ToneEvent<ValueType> {
 		if (this._loop) {
 			this._forEach((event) => {
 				event.loopStart = this.loopStart;
-				this._testLoopBoundries(event);
+				this._testLoopBoundaries(event);
 			});
 		}
 	}

package/Tone/event/Sequence.test.ts

@@ -353,7 +353,7 @@ describe("Sequence", () => {
 		});
 
 		it("can loop between loopStart and loopEnd", async () => {
-			let invokations = 0;
+			let invocations = 0;
 			await Offline(({ transport }) => {
 				const seq = new Sequence({
 					events: [0, [1, 2, 3], [4, 5]],
@@ -363,12 +363,12 @@ describe("Sequence", () => {
 					callback(time, value): void {
 						expect(value).to.be.at.least(1);
 						expect(value).to.be.at.most(3);
-						invokations++;
+						invocations++;
 					},
 				}).start(0);
 				transport.start();
 			}, 0.7);
-			expect(invokations).to.equal(9);
+			expect(invocations).to.equal(9);
 		});
 
 		it("can set the loop points after starting", async () => {

package/Tone/event/Sequence.ts

@@ -41,7 +41,7 @@ export class Sequence<ValueType = any> extends ToneEvent<ValueType> {
 	readonly name: string = "Sequence";
 
 	/**
-	 * The subdivison of each note
+	 * The subdivision of each note
 	 */
 	private _subdivision: Ticks;
 

package/Tone/instrument/Instrument.ts

@@ -20,7 +20,7 @@ export abstract class Instrument<
 	Options extends InstrumentOptions,
 > extends ToneAudioNode<Options> {
 	/**
-	 * The output and volume triming node
+	 * The output and volume trimming node
 	 */
 	private _volume: Volume;
 	output: OutputNode;

package/Tone/instrument/PolySynth.ts

@@ -187,7 +187,7 @@ export class PolySynth<
 
 	/**
 	 * Invoked when the source is done making sound, so that it can be
-	 * readded to the pool of available voices
+	 * re-added to the pool of available voices
 	 */
 	private _makeVoiceAvailable(voice: Voice): void {
 		this._availableVoices.push(voice);

package/Tone/instrument/Synth.test.ts

@@ -79,7 +79,7 @@ describe("Synth", () => {
 			simple.dispose();
 		});
 
-		it("can get does not include omited oscillator attributes", () => {
+		it("can get does not include omitted oscillator attributes", () => {
 			const simple = new Synth();
 			expect(simple.get().oscillator).to.not.have.key("frequency");
 			expect(simple.get().oscillator).to.not.have.key("detune");

package/Tone/signal/Multiply.test.ts

@@ -20,7 +20,7 @@ describe("Multiply", () => {
 			mult.dispose();
 		});
 
-		it("correctly multiplys a signal and a scalar", () => {
+		it("correctly multiplies a signal and a scalar", () => {
 			return ConstantOutput(() => {
 				const signal = new Signal(2);
 				const mult = new Multiply(10);

package/Tone/signal/Negate.test.ts

@@ -7,7 +7,7 @@ describe("Negate", () => {
 	BasicTests(Negate);
 
 	context("Negating", () => {
-		it("negateates a positive value", () => {
+		it("negates a positive value", () => {
 			return ConstantOutput(() => {
 				const signal = new Signal(1);
 				const negate = new Negate();
@@ -16,7 +16,7 @@ describe("Negate", () => {
 			}, -1);
 		});
 
-		it("makes a negateative value positive", () => {
+		it("makes a negative value positive", () => {
 			return ConstantOutput(() => {
 				const signal = new Signal(-10);
 				const negate = new Negate();

package/Tone/signal/Signal.ts

@@ -31,7 +31,7 @@ export interface SignalOptions<TypeName extends UnitName>
  *
  * @example
  * const osc = new Tone.Oscillator().toDestination().start();
- * // a scheduleable signal which can be connected to control an AudioParam or another Signal
+ * // a schedulable signal which can be connected to control an AudioParam or another Signal
  * const signal = new Tone.Signal({
  * 	value: "C4",
  * 	units: "frequency"

package/Tone/source/Source.test.ts

@@ -55,7 +55,7 @@ describe("Source", () => {
 		source.dispose();
 	});
 
-	it("is initally stopped", () => {
+	it("is initially stopped", () => {
 		const source = new Oscillator();
 		expect(source.state).to.equal("stopped");
 		source.dispose();

package/Tone/source/UserMedia.test.ts

@@ -99,8 +99,7 @@ describe("UserMedia", () => {
 				return extIn
 					.open("doesn't exist")
 					.then(() => {
-						// shouldn't call 'then'
-						throw new Error("shouldnt call 'then'");
+						throw new Error("shouldn't call 'then'");
 					})
 					.catch(() => {
 						extIn.dispose();