tone 14.9.14 → 14.9.16

package/README.md

@@ -1,13 +1,11 @@
-Tone.js
-=========
+# Tone.js
 
 [![codecov](https://codecov.io/gh/Tonejs/Tone.js/branch/dev/graph/badge.svg)](https://codecov.io/gh/Tonejs/Tone.js)
 
-
 Tone.js is a Web Audio framework for creating interactive music in the browser. The architecture of Tone.js aims to be familiar to both musicians and audio programmers creating web-based audio applications. On the high-level, Tone offers common DAW (digital audio workstation) features like a global transport for synchronizing and scheduling events as well as prebuilt synths and effects. Additionally, Tone provides high-performance building blocks to create your own synthesizers, effects, and complex control signals.
 
-* [API](https://tonejs.github.io/docs/)
-* [Examples](https://tonejs.github.io/examples/)
+-   [API](https://tonejs.github.io/docs/)
+-   [Examples](https://tonejs.github.io/examples/)
 
 # Installation
 
@@ -21,7 +19,7 @@ npm install tone@next // Or, alternatively, use the 'next' version
 Add Tone.js to a project using the JavaScript `import` syntax:
 
 ```js
-import * as Tone from 'tone';
+import * as Tone from "tone";
 ```
 
 Tone.js is also hosted at unpkg.com. It can be added directly within an HTML document, as long as it precedes any project scripts. [See the example here](https://github.com/Tonejs/Tone.js/blob/master/examples/simpleHtml.html) for more details.
@@ -40,46 +38,46 @@ const synth = new Tone.Synth().toDestination();
 synth.triggerAttackRelease("C4", "8n");
 ```
 
-#### Tone.Synth
+## Tone.Synth
 
 `Tone.Synth` is a basic synthesizer with a single oscillator and an ADSR envelope.
 
-#### triggerAttack / triggerRelease
+### triggerAttack / triggerRelease
 
 `triggerAttack` starts the note (the amplitude is rising), and `triggerRelease` is when the amplitude is going back to 0 (i.e. **note off**).
 
 ```javascript
 const synth = new Tone.Synth().toDestination();
-const now = Tone.now()
+const now = Tone.now();
 // trigger the attack immediately
-synth.triggerAttack("C4", now)
+synth.triggerAttack("C4", now);
 // wait one second before triggering the release
-synth.triggerRelease(now + 1)
+synth.triggerRelease(now + 1);
 ```
 
-#### triggerAttackRelease
+### triggerAttackRelease
 
 `triggerAttackRelease` is a combination of `triggerAttack` and `triggerRelease`
 
-The first argument to the note which can either be a frequency in hertz (like `440`) or as "pitch-octave" notation (like `"D#2"`). 
+The first argument to the note which can either be a frequency in hertz (like `440`) or as "pitch-octave" notation (like `"D#2"`).
 
-The second argument is the duration that the note is held. This value can either be in seconds, or as a [tempo-relative value](https://github.com/Tonejs/Tone.js/wiki/Time). 
+The second argument is the duration that the note is held. This value can either be in seconds, or as a [tempo-relative value](https://github.com/Tonejs/Tone.js/wiki/Time).
 
 The third (optional) argument of `triggerAttackRelease` is _when_ along the AudioContext time the note should play. It can be used to schedule events in the future.
 
 ```javascript
 const synth = new Tone.Synth().toDestination();
-const now = Tone.now()
-synth.triggerAttackRelease("C4", "8n", now)
-synth.triggerAttackRelease("E4", "8n", now + 0.5)
-synth.triggerAttackRelease("G4", "8n", now + 1)
+const now = Tone.now();
+synth.triggerAttackRelease("C4", "8n", now);
+synth.triggerAttackRelease("E4", "8n", now + 0.5);
+synth.triggerAttackRelease("G4", "8n", now + 1);
 ```
 
-#### Time
+## Time
 
 Web Audio has advanced, sample accurate scheduling capabilities. The AudioContext time is what the Web Audio API uses to schedule events, starts at 0 when the page loads and counts up in **seconds**.
 
-`Tone.now()` gets the current time of the AudioContext. 
+`Tone.now()` gets the current time of the AudioContext.
 
 ```javascript
 setInterval(() => console.log(Tone.now()), 100);
@@ -91,21 +89,21 @@ Tone.js abstracts away the AudioContext time. Instead of defining all values in
 
 # Starting Audio
 
-**IMPORTANT**: Browsers will not play _any_ audio until a user clicks something (like a play button). Run your Tone.js code only after calling `Tone.start()` from a event listener which is triggered by a user action such as "click" or "keydown". 
+**IMPORTANT**: Browsers will not play _any_ audio until a user clicks something (like a play button). Run your Tone.js code only after calling `Tone.start()` from a event listener which is triggered by a user action such as "click" or "keydown".
 
 `Tone.start()` returns a promise, the audio will be ready only after that promise is resolved. Scheduling or playing audio before the AudioContext is running will result in silence or incorrect scheduling.
 
 ```javascript
 //attach a click listener to a play button
-document.querySelector('button')?.addEventListener('click', async () => {
-	await Tone.start()
-	console.log('audio is ready')
-})
-``` 
+document.querySelector("button")?.addEventListener("click", async () => {
+	await Tone.start();
+	console.log("audio is ready");
+});
+```
 
 # Scheduling
 
-### Transport
+## Transport
 
 `Tone.getTransport()` returns the main timekeeper. Unlike the AudioContext clock, it can be started, stopped, looped and adjusted on the fly. You can think of it like the arrangement view in a Digital Audio Workstation.
 
@@ -116,72 +114,76 @@ Multiple events and parts can be arranged and synchronized along the Transport.
 const synthA = new Tone.FMSynth().toDestination();
 const synthB = new Tone.AMSynth().toDestination();
 //play a note every quarter-note
-const loopA = new Tone.Loop(time => {
+const loopA = new Tone.Loop((time) => {
 	synthA.triggerAttackRelease("C2", "8n", time);
 }, "4n").start(0);
 //play another note every off quarter-note, by starting it "8n"
-const loopB = new Tone.Loop(time => {
+const loopB = new Tone.Loop((time) => {
 	synthB.triggerAttackRelease("C4", "8n", time);
 }, "4n").start("8n");
 // all loops start when the Transport is started
-Tone.getTransport().start()
+Tone.getTransport().start();
+// ramp up to 800 bpm over 10 seconds
+Tone.getTransport().bpm.rampTo(800, 10);
 ```
 
 Since Javascript callbacks are **not precisely timed**, the sample-accurate time of the event is passed into the callback function. **Use this time value to schedule the events**.
 
 # Instruments
 
-There are numerous synths to choose from including `Tone.FMSynth`, `Tone.AMSynth` and `Tone.NoiseSynth`. 
+There are numerous synths to choose from including `Tone.FMSynth`, `Tone.AMSynth` and `Tone.NoiseSynth`.
 
-All of these instruments are **monophonic** (single voice) which means that they can only play one note at a time. 
+All of these instruments are **monophonic** (single voice) which means that they can only play one note at a time.
 
-To create a **polyphonic** synthesizer, use `Tone.PolySynth`, which accepts a monophonic synth as its first parameter and automatically handles the note allocation so you can pass in multiple notes. The API is similar to the monophonic synths, except `triggerRelease` must be given a note or array of notes. 
+To create a **polyphonic** synthesizer, use `Tone.PolySynth`, which accepts a monophonic synth as its first parameter and automatically handles the note allocation so you can pass in multiple notes. The API is similar to the monophonic synths, except `triggerRelease` must be given a note or array of notes.
 
 ```javascript
-//pass in some initial values for the filter and filter envelope
 const synth = new Tone.PolySynth(Tone.Synth).toDestination();
-const now = Tone.now()
+const now = Tone.now();
 synth.triggerAttack("D4", now);
 synth.triggerAttack("F4", now + 0.5);
 synth.triggerAttack("A4", now + 1);
-synth.triggerAttack("C4", now + 1.5);
-synth.triggerAttack("E4", now + 2);
-synth.triggerRelease(["D4", "F4", "A4", "C4", "E4"], now + 4);
+synth.triggerAttack("C5", now + 1.5);
+synth.triggerAttack("E5", now + 2);
+synth.triggerRelease(["D4", "F4", "A4", "C5", "E5"], now + 4);
 ```
 
 # Samples
 
-Sound generation is not limited to synthesized sounds. You can also load a sample and play that back in a number of ways. `Tone.Player` is one way to load and play back an audio file. 
+Sound generation is not limited to synthesized sounds. You can also load a sample and play that back in a number of ways. `Tone.Player` is one way to load and play back an audio file.
 
 ```javascript
-const player = new Tone.Player("https://tonejs.github.io/audio/berklee/gong_1.mp3").toDestination();
+const player = new Tone.Player(
+	"https://tonejs.github.io/audio/berklee/gong_1.mp3"
+).toDestination();
 Tone.loaded().then(() => {
 	player.start();
 });
 ```
 
-`Tone.loaded()` returns a promise which resolves when _all_ audio files are loaded. It's a helpful shorthand instead of waiting on each individual audio buffer's `onload` event to resolve. 
+`Tone.loaded()` returns a promise which resolves when _all_ audio files are loaded. It's a helpful shorthand instead of waiting on each individual audio buffer's `onload` event to resolve.
 
-## Sampler
+## Tone.Sampler
 
-Multiple samples can also be combined into an instrument. If you have audio files organized by note, `Tone.Sampler` will pitch shift the samples to fill in gaps between notes. So for example, if you only have every 3rd note on a piano sampled, you could turn that into a full piano sample. 
+Multiple samples can also be combined into an instrument. If you have audio files organized by note, `Tone.Sampler` will pitch shift the samples to fill in gaps between notes. So for example, if you only have every 3rd note on a piano sampled, you could turn that into a full piano sample.
 
 Unlike the other synths, Tone.Sampler is polyphonic so doesn't need to be passed into Tone.PolySynth
 
 ```javascript
 const sampler = new Tone.Sampler({
 	urls: {
-		"C4": "C4.mp3",
+		C4: "C4.mp3",
 		"D#4": "Ds4.mp3",
 		"F#4": "Fs4.mp3",
-		"A4": "A4.mp3",
+		A4: "A4.mp3",
 	},
+	release: 1,
 	baseUrl: "https://tonejs.github.io/audio/salamander/",
 }).toDestination();
 
 Tone.loaded().then(() => {
-	sampler.triggerAttackRelease(["Eb4", "G4", "Bb4"], 0.5);
-})
+	sampler.triggerAttackRelease(["Eb4", "G4", "Bb4"], 4);
+});
 ```
 
 # Effects
@@ -193,22 +195,35 @@ const player = new Tone.Player({
 	url: "https://tonejs.github.io/audio/berklee/gurgling_theremin_1.mp3",
 	loop: true,
 	autostart: true,
-})
+});
 //create a distortion effect
 const distortion = new Tone.Distortion(0.4).toDestination();
 //connect a player to the distortion
 player.connect(distortion);
 ```
 
-The connection routing is very flexible. For example, you can connect multiple sources to the same effect and then route the effect through a network of other effects either serially or in parallel. 
+The connection routing is flexible, connections can run serially or in parallel.
+
+```javascript
+const player = new Tone.Player({
+	url: "https://tonejs.github.io/audio/drum-samples/loops/ominous.mp3",
+	autostart: true,
+});
+const filter = new Tone.Filter(400, "lowpass").toDestination();
+const feedbackDelay = new Tone.FeedbackDelay(0.125, 0.5).toDestination();
+
+// connect the player to the feedback delay and filter in parallel
+player.connect(filter);
+player.connect(feedbackDelay);
+```
 
-`Tone.Gain` is very useful in creating complex routing. 
+Multiple nodes can be connected to the same input enabling sources to share effects. `Tone.Gain` is useful utility node for creating complex routing.
 
 # Signals
 
 Like the underlying Web Audio API, Tone.js is built with audio-rate signal control over nearly everything. This is a powerful feature which allows for sample-accurate synchronization and scheduling of parameters.
 
-`Signal` properties have a few built in methods for creating automation curves. 
+`Signal` properties have a few built in methods for creating automation curves.
 
 For example, the `frequency` parameter on `Oscillator` is a Signal so you can create a smooth ramp from one frequency to another.
 
@@ -216,8 +231,10 @@ For example, the `frequency` parameter on `Oscillator` is a Signal so you can cr
 const osc = new Tone.Oscillator().toDestination();
 // start at "C4"
 osc.frequency.value = "C4";
-// ramp to "C5" over 2 seconds
-osc.frequency.rampTo("C5", 2)
+// ramp to "C2" over 2 seconds
+osc.frequency.rampTo("C2", 2);
+// start the oscillator for 2 seconds
+osc.start().stop("+3");
 ```
 
 # AudioContext
@@ -230,13 +247,13 @@ To use MIDI files, you'll first need to convert them into a JSON format which To
 
 # Performance
 
-Tone.js makes extensive use of the native Web Audio Nodes such as the GainNode and WaveShaperNode for all signal processing, which enables Tone.js to work well on both desktop and mobile browsers. 
+Tone.js makes extensive use of the native Web Audio Nodes such as the GainNode and WaveShaperNode for all signal processing, which enables Tone.js to work well on both desktop and mobile browsers.
 
 [This wiki](https://github.com/Tonejs/Tone.js/wiki/Performance) article has some suggestions related to performance for best practices.
 
 # Testing
 
-Tone.js runs an extensive test suite using [mocha](https://mochajs.org/) and [chai](http://chaijs.com/) with nearly 100% coverage. Passing builds on the 'dev' branch are published on npm as `tone@next`. 
+Tone.js runs an extensive test suite using [mocha](https://mochajs.org/) and [chai](http://chaijs.com/) with nearly 100% coverage. Passing builds on the 'dev' branch are published on npm as `tone@next`.
 
 # Contributing
 
@@ -246,9 +263,9 @@ If you have questions (or answers) that are not necessarily bugs/issues, please
 
 # References and Inspiration
 
-* [Many of Chris Wilson's Repositories](https://github.com/cwilso)
-* [Many of Mohayonao's Repositories](https://github.com/mohayonao)
-* [The Spec](http://webaudio.github.io/web-audio-api/)
-* [Sound on Sound - Synth Secrets](http://www.soundonsound.com/sos/may99/articles/synthsec.htm)
-* [Miller Puckette - Theory and Techniques of Electronic Music](http://msp.ucsd.edu/techniques.htm)
-* [standardized-audio-context](https://github.com/chrisguttandin/standardized-audio-context)
+-   [Many of Chris Wilson's Repositories](https://github.com/cwilso)
+-   [Many of Mohayonao's Repositories](https://github.com/mohayonao)
+-   [The Spec](http://webaudio.github.io/web-audio-api/)
+-   [Sound on Sound - Synth Secrets](http://www.soundonsound.com/sos/may99/articles/synthsec.htm)
+-   [Miller Puckette - Theory and Techniques of Electronic Music](http://msp.ucsd.edu/techniques.htm)
+-   [standardized-audio-context](https://github.com/chrisguttandin/standardized-audio-context)

package/Tone/core/context/ToneWithContext.ts

@@ -5,10 +5,21 @@ import { TimeClass } from "../type/Time";
 import { TransportTimeClass } from "../type/TransportTime";
 import { Frequency, Hertz, Seconds, Ticks, Time } from "../type/Units";
 import { assertUsedScheduleTime } from "../util/Debug";
-import { getDefaultsFromInstance, optionsFromArguments } from "../util/Defaults";
+import {
+	getDefaultsFromInstance,
+	optionsFromArguments,
+} from "../util/Defaults";
 import { RecursivePartial } from "../util/Interface";
-import { isArray, isBoolean, isDefined, isNumber, isString, isUndef } from "../util/TypeCheck";
+import {
+	isArray,
+	isBoolean,
+	isDefined,
+	isNumber,
+	isString,
+	isUndef,
+} from "../util/TypeCheck";
 import { BaseContext } from "./BaseContext";
+import type { TransportClass } from "../clock/Transport";
 
 /**
  * A unit which process audio
@@ -20,8 +31,9 @@ export interface ToneWithContextOptions {
 /**
  * The Base class for all nodes that have an AudioContext.
  */
-export abstract class ToneWithContext<Options extends ToneWithContextOptions> extends Tone {
-
+export abstract class ToneWithContext<
+	Options extends ToneWithContextOptions
+> extends Tone {
 	/**
 	 * The context belonging to the node.
 	 */
@@ -37,11 +49,15 @@ export abstract class ToneWithContext<Options extends ToneWithContextOptions> ex
 	/**
 	 * Pass in a constructor as the first argument
 	 */
-	constructor(context?: BaseContext)
+	constructor(context?: BaseContext);
 	constructor(options?: Partial<ToneWithContextOptions>);
 	constructor() {
 		super();
-		const options = optionsFromArguments(ToneWithContext.getDefaults(), arguments, ["context"]);
+		const options = optionsFromArguments(
+			ToneWithContext.getDefaults(),
+			arguments,
+			["context"]
+		);
 		if (this.defaultContext) {
 			this.context = this.defaultContext;
 		} else {
@@ -94,7 +110,7 @@ export abstract class ToneWithContext<Options extends ToneWithContextOptions> ex
 	}
 
 	/**
-	 * Convert the incoming time to seconds. 
+	 * Convert the incoming time to seconds.
 	 * This is calculated against the current {@link TransportClass} bpm
 	 * @example
 	 * const gain = new Tone.Gain();
@@ -137,7 +153,7 @@ export abstract class ToneWithContext<Options extends ToneWithContextOptions> ex
 	protected _getPartialProperties(props: Options): Partial<Options> {
 		const options = this.get();
 		// remove attributes from the prop that are not in the partial
-		Object.keys(options).forEach(name => {
+		Object.keys(options).forEach((name) => {
 			if (isUndef(props[name])) {
 				delete options[name];
 			}
@@ -153,15 +169,26 @@ export abstract class ToneWithContext<Options extends ToneWithContextOptions> ex
 	 */
 	get(): Options {
 		const defaults = getDefaultsFromInstance(this) as Options;
-		Object.keys(defaults).forEach(attribute => {
+		Object.keys(defaults).forEach((attribute) => {
 			if (Reflect.has(this, attribute)) {
 				const member = this[attribute];
-				if (isDefined(member) && isDefined(member.value) && isDefined(member.setValueAtTime)) {
+				if (
+					isDefined(member) &&
+					isDefined(member.value) &&
+					isDefined(member.setValueAtTime)
+				) {
 					defaults[attribute] = member.value;
 				} else if (member instanceof ToneWithContext) {
-					defaults[attribute] = member._getPartialProperties(defaults[attribute]);
+					defaults[attribute] = member._getPartialProperties(
+						defaults[attribute]
+					);
 					// otherwise make sure it's a serializable type
-				} else if (isArray(member) || isNumber(member) || isString(member) || isBoolean(member)) {
+				} else if (
+					isArray(member) ||
+					isNumber(member) ||
+					isString(member) ||
+					isBoolean(member)
+				) {
 					defaults[attribute] = member;
 				} else {
 					// remove all undefined and unserializable attributes
@@ -186,9 +213,13 @@ export abstract class ToneWithContext<Options extends ToneWithContextOptions> ex
 	 * player.autostart = true;
 	 */
 	set(props: RecursivePartial<Options>): this {
-		Object.keys(props).forEach(attribute => {
+		Object.keys(props).forEach((attribute) => {
 			if (Reflect.has(this, attribute) && isDefined(this[attribute])) {
-				if (this[attribute] && isDefined(this[attribute].value) && isDefined(this[attribute].setValueAtTime)) {
+				if (
+					this[attribute] &&
+					isDefined(this[attribute].value) &&
+					isDefined(this[attribute].setValueAtTime)
+				) {
 					// small optimization
 					if (this[attribute].value !== props[attribute]) {
 						this[attribute].value = props[attribute];

package/Tone/event/Part.ts

@@ -60,7 +60,7 @@ export class Part<ValueType = any> extends ToneEvent<ValueType> {
 
 	/**
 	 * @param callback The callback to invoke on each event
-	 * @param events the array of events
+	 * @param value the array of events
 	 */
 	constructor(callback?: ToneEventCallback<CallbackType<ValueType>>, value?: ValueType[]);
 	constructor(options?: Partial<PartOptions<ValueType>>);
@@ -209,7 +209,7 @@ export class Part<ValueType = any> extends ToneEvent<ValueType> {
 	 * Add a an event to the part.
 	 * @param time The time the note should start. If an object is passed in, it should
 	 * 		have a 'time' attribute and the rest of the object will be used as the 'value'.
-	 * @param  value
+	 * @param  value Any value to add to the timeline
 	 * @example
 	 * const part = new Tone.Part();
 	 * part.add("1m", "C#+11");

package/Tone/event/Sequence.ts

@@ -5,7 +5,7 @@ import { isArray, isString } from "../core/util/TypeCheck";
 import { Part } from "./Part";
 import { ToneEvent, ToneEventCallback, ToneEventOptions } from "./ToneEvent";
 
-type SequenceEventDescription<T> = Array<T | Array<T | Array<T | Array<T | Array<T | T[]>>>>>;
+type SequenceEventDescription<T> = Array<T | SequenceEventDescription<T>>;
 
 interface SequenceOptions<T> extends Omit<ToneEventOptions<T>, "value"> {
 	loopStart: number;
@@ -59,7 +59,7 @@ export class Sequence<ValueType = any> extends ToneEvent<ValueType> {
 
 	/**
 	 * @param  callback  The callback to invoke with every note
-	 * @param  sequence  The sequence
+	 * @param  events  The sequence of events
 	 * @param  subdivision  The subdivision between which events are placed.
 	 */
 	constructor(

package/Tone/index.ts

@@ -7,9 +7,13 @@ import { ToneAudioBuffer } from "./core/context/ToneAudioBuffer";
 export { start } from "./core/Global";
 import { Seconds } from "./core/type/Units";
 export { supported } from "./core/context/AudioContext";
+import type { TransportClass } from "./core/clock/Transport";
+import type { DestinationClass } from "./core/context/Destination";
+import type { DrawClass } from "./core/util/Draw";
+import type { ListenerClass } from "./core/context/Listener";
 
 /**
- * The current audio context time of the global {@link BaseContext}. 
+ * The current audio context time of the global {@link BaseContext}.
  * @see {@link Context.now}
  * @category Core
  */
@@ -39,7 +43,7 @@ export const Transport = getContext().transport;
  * @see {@link TransportClass}
  * @category Core
  */
-export function getTransport(): import("./core/clock/Transport").TransportClass {
+export function getTransport(): TransportClass {
 	return getContext().transport;
 }
 
@@ -61,7 +65,7 @@ export const Master = getContext().destination;
  * @see {@link DestinationClass}
  * @category Core
  */
-export function getDestination(): import("./core/context/Destination").DestinationClass {
+export function getDestination(): DestinationClass {
 	return getContext().destination;
 }
 
@@ -76,12 +80,12 @@ export const Listener = getContext().listener;
  * The {@link ListenerClass} belonging to the global Tone.js Context.
  * @category Core
  */
-export function getListener(): import("./core/context/Listener").ListenerClass {
+export function getListener(): ListenerClass {
 	return getContext().listener;
 }
 
 /**
- * Draw is used to synchronize the draw frame with the Transport's callbacks. 
+ * Draw is used to synchronize the draw frame with the Transport's callbacks.
  * @see {@link DrawClass}
  * @category Core
  * @deprecated Use {@link getDraw} instead
@@ -89,12 +93,12 @@ export function getListener(): import("./core/context/Listener").ListenerClass {
 export const Draw = getContext().draw;
 
 /**
- * Get the singleton attached to the global context. 
- * Draw is used to synchronize the draw frame with the Transport's callbacks. 
+ * Get the singleton attached to the global context.
+ * Draw is used to synchronize the draw frame with the Transport's callbacks.
  * @see {@link DrawClass}
  * @category Core
  */
-export function getDraw(): import("./core/util/Draw").DrawClass {
+export function getDraw(): DrawClass {
 	return getContext().draw;
 }
 
@@ -106,7 +110,7 @@ export function getDraw(): import("./core/util/Draw").DrawClass {
 export const context = getContext();
 
 /**
- * Promise which resolves when all of the loading promises are resolved. 
+ * Promise which resolves when all of the loading promises are resolved.
  * Alias for static {@link ToneAudioBuffer.loaded} method.
  * @category Core
  */

package/Tone/signal/SyncedSignal.ts

@@ -4,6 +4,7 @@ import { optionsFromArguments } from "../core/util/Defaults";
 import { TransportTimeClass } from "../core/type/TransportTime";
 import { ToneConstantSource } from "./ToneConstantSource";
 import { OutputNode } from "../core/context/ToneAudioNode";
+import type { TransportClass } from "../core/clock/Transport";
 
 /**
  * Adds the ability to synchronize the signal to the {@link TransportClass}

package/Tone/signal/WaveShaper.ts

@@ -55,7 +55,7 @@ export class WaveShaper extends SignalOperator<WaveShaperOptions> {
 	 *                signal is an AudioRange [-1, 1] value and the output
 	 *                signal can take on any numerical values.
 	 *
-	 * @param bufferLen The length of the WaveShaperNode buffer.
+	 * @param length The length of the WaveShaperNode buffer.
 	 */
 	constructor(mapping?: WaveShaperMapping, length?: number);
 	constructor(options?: Partial<WaveShaperOptions>);

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "14.9.14";
+export const version: string = "14.9.16";