tone 14.8.32 → 14.8.36

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

@@ -237,6 +237,35 @@ describe("TickSource", () => {
 			expect(source.getTicksAtTime(6)).to.be.closeTo(6, 0.01);
 			source.dispose();
 		});
+
+		it("will recompute memoized values when events are modified", () => {
+			const source = new TickSource(1);
+			source.start(3).pause(4);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(1, 0.01);
+			source.start(1).pause(2);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(2, 0.01);
+			source.setTicksAtTime(3, 1);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(5, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(5, 0.01);
+			source.cancel(4);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(5, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(6, 0.01);
+			source.dispose();
+		});
 	});
 
 	context("forEachTickBetween", () => {
@@ -591,6 +620,29 @@ describe("TickSource", () => {
 			expect(source.getSecondsAtTime(1.5)).to.be.closeTo(0, 0.01);
 			source.dispose();
 		});
+
+		it("will recompute memoized values when events are modified", () => {
+			const source = new TickSource(1);
+			source.start(3).pause(4);
+			expect(source.getSecondsAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(2)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(3)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(4)).to.be.closeTo(1, 0.01);
+			expect(source.getSecondsAtTime(5)).to.be.closeTo(1, 0.01);
+			source.start(1).pause(2);
+			expect(source.getSecondsAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(2)).to.be.closeTo(1, 0.01);
+			expect(source.getSecondsAtTime(3)).to.be.closeTo(1, 0.01);
+			expect(source.getSecondsAtTime(4)).to.be.closeTo(2, 0.01);
+			expect(source.getSecondsAtTime(5)).to.be.closeTo(2, 0.01);
+			source.cancel(4);
+			expect(source.getSecondsAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(2)).to.be.closeTo(1, 0.01);
+			expect(source.getSecondsAtTime(3)).to.be.closeTo(1, 0.01);
+			expect(source.getSecondsAtTime(4)).to.be.closeTo(2, 0.01);
+			expect(source.getSecondsAtTime(5)).to.be.closeTo(3, 0.01);
+			source.dispose();
+		});
 	});
 
 	context("Frequency", () => {

package/Tone/core/clock/TickSource.ts

@@ -3,7 +3,7 @@ import { Seconds, Ticks, Time } from "../type/Units";
 import { optionsFromArguments } from "../util/Defaults";
 import { readOnly } from "../util/Interface";
 import { PlaybackState, StateTimeline, StateTimelineEvent } from "../util/StateTimeline";
-import { Timeline } from "../util/Timeline";
+import { Timeline, TimelineEvent } from "../util/Timeline";
 import { isDefined } from "../util/TypeCheck";
 import { TickSignal } from "./TickSignal";
 import { EQ } from "../util/Math";
@@ -13,12 +13,24 @@ interface TickSourceOptions extends ToneWithContextOptions {
 	units: "bpm" | "hertz";
 }
 
-interface TickSourceOffsetEvent {
+interface TickSourceOffsetEvent extends TimelineEvent {
 	ticks: number;
 	time: number;
 	seconds: number;
 }
 
+interface TickSourceTicksAtTimeEvent extends TimelineEvent {
+	state: PlaybackState;
+	time: number;
+	ticks: number;
+}
+
+interface TickSourceSecondsAtTimeEvent extends TimelineEvent {
+	state: PlaybackState;
+	time: number;
+	seconds: number;
+}
+
 /**
  * Uses [TickSignal](TickSignal) to track elapsed ticks with complex automation curves.
  */
@@ -41,6 +53,16 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 	 */
 	private _tickOffset: Timeline<TickSourceOffsetEvent> = new Timeline();
 
+	/**
+	 * Memoized values of getTicksAtTime at events with state other than "started"
+	 */
+	private _ticksAtTime: Timeline<TickSourceTicksAtTimeEvent> = new Timeline<TickSourceTicksAtTimeEvent>();
+
+	/**
+	 * Memoized values of getSecondsAtTime at events with state other than "started"
+	 */
+	private _secondsAtTime: Timeline<TickSourceSecondsAtTimeEvent> = new Timeline<TickSourceSecondsAtTimeEvent>();
+
 	/**
 	 * @param frequency The initial frequency that the signal ticks at
 	 */
@@ -90,6 +112,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 			if (isDefined(offset)) {
 				this.setTicksAtTime(offset, computedTime);
 			}
+			this._ticksAtTime.cancel(computedTime);
+			this._secondsAtTime.cancel(computedTime);
 		}
 		return this;
 	}
@@ -111,6 +135,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		this._state.cancel(computedTime);
 		this._state.setStateAtTime("stopped", computedTime);
 		this.setTicksAtTime(0, computedTime);
+		this._ticksAtTime.cancel(computedTime);
+		this._secondsAtTime.cancel(computedTime);
 		return this;
 	}
 
@@ -122,6 +148,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		const computedTime = this.toSeconds(time);
 		if (this._state.getValueAtTime(computedTime) === "started") {
 			this._state.setStateAtTime("paused", computedTime);
+			this._ticksAtTime.cancel(computedTime);
+			this._secondsAtTime.cancel(computedTime);
 		}
 		return this;
 	}
@@ -134,6 +162,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		time = this.toSeconds(time);
 		this._state.cancel(time);
 		this._tickOffset.cancel(time);
+		this._ticksAtTime.cancel(time);
+		this._secondsAtTime.cancel(time);
 		return this;
 	}
 
@@ -145,16 +175,21 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 	getTicksAtTime(time?: Time): Ticks {
 		const computedTime = this.toSeconds(time);
 		const stopEvent = this._state.getLastState("stopped", computedTime) as StateTimelineEvent;
+
+		// get previously memoized ticks if available
+		const memoizedEvent = this._ticksAtTime.get(computedTime);
+
 		// this event allows forEachBetween to iterate until the current time
 		const tmpEvent: StateTimelineEvent = { state: "paused", time: computedTime };
 		this._state.add(tmpEvent);
 
 		// keep track of the previous offset event
-		let lastState = stopEvent;
-		let elapsedTicks = 0;
+		let lastState = memoizedEvent ? memoizedEvent : stopEvent;
+		let elapsedTicks = memoizedEvent ? memoizedEvent.ticks : 0;
+		let eventToMemoize : TickSourceTicksAtTimeEvent | null = null;
 
 		// iterate through all the events since the last stop
-		this._state.forEachBetween(stopEvent.time, computedTime + this.sampleTime, e => {
+		this._state.forEachBetween(lastState.time, computedTime + this.sampleTime, e => {
 			let periodStartTime = lastState.time;
 			// if there is an offset event in this period use that
 			const offsetEvent = this._tickOffset.get(e.time);
@@ -164,6 +199,10 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 			}
 			if (lastState.state === "started" && e.state !== "started") {
 				elapsedTicks += this.frequency.getTicksAtTime(e.time) - this.frequency.getTicksAtTime(periodStartTime);
+				// do not memoize the temporary event
+				if (e.time != tmpEvent.time) {
+					eventToMemoize = { state: e.state, time: e.time, ticks: elapsedTicks };
+				}
 			}
 			lastState = e;
 		});
@@ -171,6 +210,11 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		// remove the temporary event
 		this._state.remove(tmpEvent);
 
+		// memoize the ticks at the most recent event with state other than "started"
+		if (eventToMemoize) {
+			this._ticksAtTime.add(eventToMemoize);
+		}
+
 		// return the ticks
 		return elapsedTicks;
 	}
@@ -211,12 +255,16 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		const tmpEvent: StateTimelineEvent = { state: "paused", time };
 		this._state.add(tmpEvent);
 
+		// get previously memoized seconds if available
+		const memoizedEvent = this._secondsAtTime.get(time);
+
 		// keep track of the previous offset event
-		let lastState = stopEvent;
-		let elapsedSeconds = 0;
+		let lastState = memoizedEvent ? memoizedEvent : stopEvent;
+		let elapsedSeconds = memoizedEvent ? memoizedEvent.seconds : 0;
+		let eventToMemoize : TickSourceSecondsAtTimeEvent | null = null;
 
 		// iterate through all the events since the last stop
-		this._state.forEachBetween(stopEvent.time, time + this.sampleTime, e => {
+		this._state.forEachBetween(lastState.time, time + this.sampleTime, e => {
 			let periodStartTime = lastState.time;
 			// if there is an offset event in this period use that
 			const offsetEvent = this._tickOffset.get(e.time);
@@ -226,6 +274,10 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 			}
 			if (lastState.state === "started" && e.state !== "started") {
 				elapsedSeconds += e.time - periodStartTime;
+				// do not memoize the temporary event
+				if (e.time != tmpEvent.time) {
+					eventToMemoize = { state: e.state, time: e.time, seconds: elapsedSeconds };
+				}
 			}
 			lastState = e;
 		});
@@ -233,7 +285,12 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		// remove the temporary event
 		this._state.remove(tmpEvent);
 
-		// return the ticks
+		// memoize the seconds at the most recent event with state other than "started"
+		if (eventToMemoize) {
+			this._secondsAtTime.add(eventToMemoize);
+		}
+
+		// return the seconds
 		return elapsedSeconds;
 	}
 
@@ -250,6 +307,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 			ticks,
 			time,
 		});
+		this._ticksAtTime.cancel(time);
+		this._secondsAtTime.cancel(time);
 		return this;
 	}
 
@@ -332,6 +391,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		super.dispose();
 		this._state.dispose();
 		this._tickOffset.dispose();
+		this._ticksAtTime.dispose();
+		this._secondsAtTime.dispose();
 		this.frequency.dispose();
 		return this;
 	}

package/Tone/core/type/Frequency.ts

@@ -50,7 +50,7 @@ export class FrequencyClass<Type extends number = Hertz> extends TimeClass<Type,
 				},
 			},
 			note: {
-				regexp: /^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i,
+				regexp: /^([a-g]{1}(?:b|#|##|x|bb|###|#x|x#|bbb)?)(-?[0-9]+)/i,
 				method(pitch, octave): number {
 					const index = noteToScaleIndex[pitch.toLowerCase()];
 					const noteNumber = index + (parseInt(octave, 10) + 1) * 12;
@@ -219,13 +219,13 @@ export class FrequencyClass<Type extends number = Hertz> extends TimeClass<Type,
  * @hidden
  */
 const noteToScaleIndex = {
-	cbb: -2, cb: -1, c: 0, "c#": 1, cx: 2,
-	dbb: 0, db: 1, d: 2, "d#": 3, dx: 4,
-	ebb: 2, eb: 3, e: 4, "e#": 5, ex: 6,
-	fbb: 3, fb: 4, f: 5, "f#": 6, fx: 7,
-	gbb: 5, gb: 6, g: 7, "g#": 8, gx: 9,
-	abb: 7, ab: 8, a: 9, "a#": 10, ax: 11,
-	bbb: 9, bb: 10, b: 11, "b#": 12, bx: 13,
+	cbbb: -3, cbb: -2, cb: -1, c:  0, "c#":  1, cx:  2, "c##":  2, "c###":  3, "cx#":  3, "c#x":  3,
+	dbbb: -1, dbb:  0, db:  1, d:  2, "d#":  3, dx:  4, "d##":  4, "d###":  5, "dx#":  5, "d#x":  5,
+	ebbb:  1, ebb:  2, eb:  3, e:  4, "e#":  5, ex:  6, "e##":  6, "e###":  7, "ex#":  7, "e#x":  7,
+	fbbb:  2, fbb:  3, fb:  4, f:  5, "f#":  6, fx:  7, "f##":  7, "f###":  8, "fx#":  8, "f#x":  8,
+	gbbb:  4, gbb:  5, gb:  6, g:  7, "g#":  8, gx:  9, "g##":  9, "g###": 10, "gx#": 10, "g#x": 10,
+	abbb:  6, abb:  7, ab:  8, a:  9, "a#": 10, ax: 11, "a##": 11, "a###": 12, "ax#": 12, "a#x": 12,
+	bbbb:  8, bbb:  9, bb: 10, b: 11, "b#": 12, bx: 13, "b##": 13, "b###": 14, "bx#": 14, "b#x": 14,
 };
 
 /**

package/Tone/effect/Chorus.test.ts

@@ -7,25 +7,29 @@ import { Oscillator } from "Tone/source";
 import { Offline } from "test/helper/Offline";
 
 describe("Chorus", () => {
-
 	BasicTests(Chorus);
 	EffectTests(Chorus);
 
 	it("matches a file", () => {
-		return CompareToFile(() => {
-			const chorus = new Chorus().toDestination().start();
-			const osc = new Oscillator(220, "sawtooth").connect(chorus).start();
-		}, "chorus.wav", 0.1);
+		return CompareToFile(
+			() => {
+				const chorus = new Chorus().toDestination().start();
+				const osc = new Oscillator(220, "sawtooth")
+					.connect(chorus)
+					.start();
+			},
+			"chorus.wav",
+			0.25
+		);
 	});
 
 	context("API", () => {
-
 		it("can pass in options in the constructor", () => {
 			const chorus = new Chorus({
 				frequency: 2,
 				delayTime: 1,
 				depth: 0.4,
-				spread: 90
+				spread: 90,
 			});
 			expect(chorus.frequency.value).to.be.closeTo(2, 0.01);
 			expect(chorus.delayTime).to.be.closeTo(1, 0.01);
@@ -84,4 +88,3 @@ describe("Chorus", () => {
 		});
 	});
 });
-

package/Tone/instrument/NoiseSynth.ts

@@ -4,7 +4,10 @@ import { omitFromObject, optionsFromArguments } from "../core/util/Defaults";
 import { RecursivePartial } from "../core/util/Interface";
 import { Noise, NoiseOptions } from "../source/Noise";
 import { Instrument, InstrumentOptions } from "./Instrument";
-import { ToneAudioNode, ToneAudioNodeOptions } from "../core/context/ToneAudioNode";
+import {
+	ToneAudioNode,
+	ToneAudioNodeOptions,
+} from "../core/context/ToneAudioNode";
 import { Envelope, EnvelopeOptions } from "../component/envelope/Envelope";
 import { Source } from "../source/Source";
 
@@ -14,7 +17,7 @@ export interface NoiseSynthOptions extends InstrumentOptions {
 }
 
 /**
- * Tone.NoiseSynth is composed of [[Noise]] through an [[AmplitudeEnvelope]]. 
+ * Tone.NoiseSynth is composed of [[Noise]] through an [[AmplitudeEnvelope]].
  * ```
  * +-------+   +-------------------+
  * | Noise +>--> AmplitudeEnvelope +>--> Output
@@ -26,7 +29,6 @@ export interface NoiseSynthOptions extends InstrumentOptions {
  * @category Instrument
  */
 export class NoiseSynth extends Instrument<NoiseSynthOptions> {
-
 	readonly name = "NoiseSynth";
 
 	/**
@@ -39,17 +41,30 @@ export class NoiseSynth extends Instrument<NoiseSynthOptions> {
 	 */
 	readonly envelope: AmplitudeEnvelope;
 
-	constructor(options?: RecursivePartial<NoiseSynthOptions>)
+	constructor(options?: RecursivePartial<NoiseSynthOptions>);
 	constructor() {
 		super(optionsFromArguments(NoiseSynth.getDefaults(), arguments));
-		const options = optionsFromArguments(NoiseSynth.getDefaults(), arguments);
-		this.noise = new Noise(Object.assign({
-			context: this.context,
-		}, options.noise));
+		const options = optionsFromArguments(
+			NoiseSynth.getDefaults(),
+			arguments
+		);
+		this.noise = new Noise(
+			Object.assign(
+				{
+					context: this.context,
+				},
+				options.noise
+			)
+		);
 
-		this.envelope = new AmplitudeEnvelope(Object.assign({
-			context: this.context,
-		}, options.envelope));
+		this.envelope = new AmplitudeEnvelope(
+			Object.assign(
+				{
+					context: this.context,
+				},
+				options.envelope
+			)
+		);
 
 		// connect the noise to the output
 		this.noise.chain(this.envelope, this.output);
@@ -58,17 +73,23 @@ export class NoiseSynth extends Instrument<NoiseSynthOptions> {
 	static getDefaults(): NoiseSynthOptions {
 		return Object.assign(Instrument.getDefaults(), {
 			envelope: Object.assign(
-				omitFromObject(Envelope.getDefaults(), Object.keys(ToneAudioNode.getDefaults())),
+				omitFromObject(
+					Envelope.getDefaults(),
+					Object.keys(ToneAudioNode.getDefaults())
+				),
 				{
 					decay: 0.1,
 					sustain: 0.0,
-				},
+				}
 			),
 			noise: Object.assign(
-				omitFromObject(Noise.getDefaults(), Object.keys(Source.getDefaults())),
+				omitFromObject(
+					Noise.getDefaults(),
+					Object.keys(Source.getDefaults())
+				),
 				{
 					type: "white",
-				},
+				}
 			),
 		});
 	}
@@ -87,7 +108,11 @@ export class NoiseSynth extends Instrument<NoiseSynthOptions> {
 		// start the noise
 		this.noise.start(time);
 		if (this.envelope.sustain === 0) {
-			this.noise.stop(time + this.toSeconds(this.envelope.attack) + this.toSeconds(this.envelope.decay));
+			this.noise.stop(
+				time +
+					this.toSeconds(this.envelope.attack) +
+					this.toSeconds(this.envelope.decay)
+			);
 		}
 		return this;
 	}
@@ -110,7 +135,21 @@ export class NoiseSynth extends Instrument<NoiseSynthOptions> {
 		return this;
 	}
 
-	triggerAttackRelease(duration: Time, time?: Time, velocity: NormalRange = 1): this {
+	/**
+	 * Trigger the attack and then the release after the duration.
+	 * @param duration The amount of time to hold the note for
+	 * @param time The time the note should start
+	 * @param velocity The volume of the note (0-1)
+	 * @example
+	 * const noiseSynth = new Tone.NoiseSynth().toDestination();
+	 * // hold the note for 0.5 seconds
+	 * noiseSynth.triggerAttackRelease(0.5);
+	 */
+	triggerAttackRelease(
+		duration: Time,
+		time?: Time,
+		velocity: NormalRange = 1
+	): this {
 		time = this.toSeconds(time);
 		duration = this.toSeconds(duration);
 		this.triggerAttack(time, velocity);

package/Tone/source/Source.ts

@@ -2,11 +2,19 @@ import { Volume } from "../component/channel/Volume";
 import "../core/context/Destination";
 import "../core/clock/Transport";
 import { Param } from "../core/context/Param";
-import { OutputNode, ToneAudioNode, ToneAudioNodeOptions } from "../core/context/ToneAudioNode";
+import {
+	OutputNode,
+	ToneAudioNode,
+	ToneAudioNodeOptions,
+} from "../core/context/ToneAudioNode";
 import { Decibels, Seconds, Time } from "../core/type/Units";
 import { defaultArg } from "../core/util/Defaults";
 import { noOp, readOnly } from "../core/util/Interface";
-import { BasicPlaybackState, StateTimeline, StateTimelineEvent } from "../core/util/StateTimeline";
+import {
+	BasicPlaybackState,
+	StateTimeline,
+	StateTimelineEvent,
+} from "../core/util/StateTimeline";
 import { isDefined, isUndef } from "../core/util/TypeCheck";
 import { assert, assertContextRunning } from "../core/util/Debug";
 import { GT } from "../core/util/Math";
@@ -20,9 +28,9 @@ export interface SourceOptions extends ToneAudioNodeOptions {
 }
 
 /**
- * Base class for sources. 
+ * Base class for sources.
  * start/stop of this.context.transport.
- * 
+ *
  * ```
  * // Multiple state change events can be chained together,
  * // but must be set in the correct order and with ascending times
@@ -36,8 +44,9 @@ export interface SourceOptions extends ToneAudioNodeOptions {
  * state.start("+0.3").stop("+0.2");
  * ```
  */
-export abstract class Source<Options extends SourceOptions> extends ToneAudioNode<Options> {
-
+export abstract class Source<
+	Options extends SourceOptions
+> extends ToneAudioNode<Options> {
 	/**
 	 * The output volume node
 	 */
@@ -129,7 +138,9 @@ export abstract class Source<Options extends SourceOptions> extends ToneAudioNod
 	get state(): BasicPlaybackState {
 		if (this._synced) {
 			if (this.context.transport.state === "started") {
-				return this._state.getValueAtTime(this.context.transport.seconds) as BasicPlaybackState;
+				return this._state.getValueAtTime(
+					this.context.transport.seconds
+				) as BasicPlaybackState;
 			} else {
 				return "stopped";
 			}
@@ -155,7 +166,11 @@ export abstract class Source<Options extends SourceOptions> extends ToneAudioNod
 	// overwrite these functions
 	protected abstract _start(time: Time, offset?: Time, duration?: Time): void;
 	protected abstract _stop(time: Time): void;
-	protected abstract _restart(time: Seconds, offset?: Time, duration?: Time): void;
+	protected abstract _restart(
+		time: Seconds,
+		offset?: Time,
+		duration?: Time
+	): void;
 
 	/**
 	 * Ensure that the scheduled time is not before the current time.
@@ -178,12 +193,24 @@ export abstract class Source<Options extends SourceOptions> extends ToneAudioNod
 	 * source.start("+0.5"); // starts the source 0.5 seconds from now
 	 */
 	start(time?: Time, offset?: Time, duration?: Time): this {
-		let computedTime = isUndef(time) && this._synced ? this.context.transport.seconds : this.toSeconds(time);
+		let computedTime =
+			isUndef(time) && this._synced
+				? this.context.transport.seconds
+				: this.toSeconds(time);
 		computedTime = this._clampToCurrentTime(computedTime);
 		// if it's started, stop it and restart it
-		if (!this._synced && this._state.getValueAtTime(computedTime) === "started") {
+		if (
+			!this._synced &&
+			this._state.getValueAtTime(computedTime) === "started"
+		) {
 			// time should be strictly greater than the previous start time
-			assert(GT(computedTime, (this._state.get(computedTime) as StateTimelineEvent).time), "Start time must be strictly greater than previous start time");
+			assert(
+				GT(
+					computedTime,
+					(this._state.get(computedTime) as StateTimelineEvent).time
+				),
+				"Start time must be strictly greater than previous start time"
+			);
 			this._state.cancel(computedTime);
 			this._state.setStateAtTime("started", computedTime);
 			this.log("restart", computedTime);
@@ -196,18 +223,26 @@ export abstract class Source<Options extends SourceOptions> extends ToneAudioNod
 				const event = this._state.get(computedTime);
 				if (event) {
 					event.offset = this.toSeconds(defaultArg(offset, 0));
-					event.duration = duration ? this.toSeconds(duration) : undefined;
+					event.duration = duration
+						? this.toSeconds(duration)
+						: undefined;
 				}
-				const sched = this.context.transport.schedule(t => {
+				const sched = this.context.transport.schedule((t) => {
 					this._start(t, offset, duration);
 				}, computedTime);
 				this._scheduled.push(sched);
 
 				// if the transport is already started
 				// and the time is greater than where the transport is
-				if (this.context.transport.state === "started" && 
-					this.context.transport.getSecondsAtTime(this.immediate()) > computedTime) {
-					this._syncedStart(this.now(), this.context.transport.seconds);
+				if (
+					this.context.transport.state === "started" &&
+					this.context.transport.getSecondsAtTime(this.immediate()) >
+						computedTime
+				) {
+					this._syncedStart(
+						this.now(),
+						this.context.transport.seconds
+					);
 				}
 			} else {
 				assertContextRunning(this.context);
@@ -227,14 +262,23 @@ export abstract class Source<Options extends SourceOptions> extends ToneAudioNod
 	 * source.stop("+0.5"); // stops the source 0.5 seconds from now
 	 */
 	stop(time?: Time): this {
-		let computedTime = isUndef(time) && this._synced ? this.context.transport.seconds : this.toSeconds(time);
+		let computedTime =
+			isUndef(time) && this._synced
+				? this.context.transport.seconds
+				: this.toSeconds(time);
 		computedTime = this._clampToCurrentTime(computedTime);
-		if (this._state.getValueAtTime(computedTime) === "started" || isDefined(this._state.getNextState("started", computedTime))) {
+		if (
+			this._state.getValueAtTime(computedTime) === "started" ||
+			isDefined(this._state.getNextState("started", computedTime))
+		) {
 			this.log("stop", computedTime);
 			if (!this._synced) {
 				this._stop(computedTime);
 			} else {
-				const sched = this.context.transport.schedule(this._stop.bind(this), computedTime);
+				const sched = this.context.transport.schedule(
+					this._stop.bind(this),
+					computedTime
+				);
 				this._scheduled.push(sched);
 			}
 			this._state.cancel(computedTime);
@@ -274,23 +318,36 @@ export abstract class Source<Options extends SourceOptions> extends ToneAudioNod
 		if (!this._synced) {
 			this._synced = true;
 			this._syncedStart = (time, offset) => {
-				if (offset > 0) {
+				if (GT(offset, 0)) {
 					// get the playback state at that time
 					const stateEvent = this._state.get(offset);
 					// listen for start events which may occur in the middle of the sync'ed time
-					if (stateEvent && stateEvent.state === "started" && stateEvent.time !== offset) {
+					if (
+						stateEvent &&
+						stateEvent.state === "started" &&
+						stateEvent.time !== offset
+					) {
 						// get the offset
-						const startOffset = offset - this.toSeconds(stateEvent.time);
+						const startOffset =
+							offset - this.toSeconds(stateEvent.time);
 						let duration: number | undefined;
 						if (stateEvent.duration) {
-							duration = this.toSeconds(stateEvent.duration) - startOffset;
+							duration =
+								this.toSeconds(stateEvent.duration) -
+								startOffset;
 						}
-						this._start(time, this.toSeconds(stateEvent.offset) + startOffset, duration);
+						this._start(
+							time,
+							this.toSeconds(stateEvent.offset) + startOffset,
+							duration
+						);
 					}
 				}
 			};
-			this._syncedStop = time => {
-				const seconds = this.context.transport.getSecondsAtTime(Math.max(time - this.sampleTime, 0));
+			this._syncedStop = (time) => {
+				const seconds = this.context.transport.getSecondsAtTime(
+					Math.max(time - this.sampleTime, 0)
+				);
 				if (this._state.getValueAtTime(seconds) === "started") {
 					this._stop(time);
 				}
@@ -317,7 +374,7 @@ export abstract class Source<Options extends SourceOptions> extends ToneAudioNod
 		}
 		this._synced = false;
 		// clear all of the scheduled ids
-		this._scheduled.forEach(id => this.context.transport.clear(id));
+		this._scheduled.forEach((id) => this.context.transport.clear(id));
 		this._scheduled = [];
 		this._state.cancel(0);
 		// stop it also