tone 15.0.0 → 15.0.2

package/Tone/core/context/Delay.ts

@@ -54,17 +54,11 @@ export class Delay extends ToneAudioNode<DelayOptions> {
 	constructor(delayTime?: Time, maxDelay?: Time);
 	constructor(options?: Partial<DelayOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Delay.getDefaults(), arguments, [
-				"delayTime",
-				"maxDelay",
-			])
-		);
-
 		const options = optionsFromArguments(Delay.getDefaults(), arguments, [
 			"delayTime",
 			"maxDelay",
 		]);
+		super(options);
 
 		const maxDelayInSeconds = this.toSeconds(options.maxDelay);
 		this._maxDelay = Math.max(

package/Tone/core/context/Destination.ts

@@ -48,11 +48,11 @@ export class DestinationClass extends ToneAudioNode<DestinationOptions> {
 
 	constructor(options: Partial<DestinationOptions>);
 	constructor() {
-		super(optionsFromArguments(DestinationClass.getDefaults(), arguments));
 		const options = optionsFromArguments(
 			DestinationClass.getDefaults(),
 			arguments
 		);
+		super(options);
 
 		connectSeries(
 			this.input,

package/Tone/core/context/Gain.ts

@@ -56,16 +56,11 @@ export class Gain<
 	constructor(gain?: UnitMap[TypeName], units?: TypeName);
 	constructor(options?: Partial<GainOptions<TypeName>>);
 	constructor() {
-		super(
-			optionsFromArguments(Gain.getDefaults(), arguments, [
-				"gain",
-				"units",
-			])
-		);
 		const options = optionsFromArguments(Gain.getDefaults(), arguments, [
 			"gain",
 			"units",
 		]);
+		super(options);
 
 		this.gain = new Param({
 			context: this.context,

package/Tone/core/context/Param.ts

@@ -113,19 +113,12 @@ export class Param<TypeName extends UnitName = "number">
 	constructor(param: AudioParam, units?: TypeName, convert?: boolean);
 	constructor(options: Partial<ParamOptions<TypeName>>);
 	constructor() {
-		super(
-			optionsFromArguments(Param.getDefaults(), arguments, [
-				"param",
-				"units",
-				"convert",
-			])
-		);
-
 		const options = optionsFromArguments(Param.getDefaults(), arguments, [
 			"param",
 			"units",
 			"convert",
 		]);
+		super(options);
 
 		assert(
 			isDefined(options.param) &&

package/Tone/effect/AutoFilter.ts

@@ -50,18 +50,12 @@ export class AutoFilter extends LFOEffect<AutoFilterOptions> {
 	);
 	constructor(options?: Partial<AutoFilterOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(AutoFilter.getDefaults(), arguments, [
-				"frequency",
-				"baseFrequency",
-				"octaves",
-			])
-		);
 		const options = optionsFromArguments(
 			AutoFilter.getDefaults(),
 			arguments,
 			["frequency", "baseFrequency", "octaves"]
 		);
+		super(options);
 
 		this.filter = new Filter(
 			Object.assign(options.filter, {

package/Tone/effect/AutoPanner.ts

@@ -32,16 +32,12 @@ export class AutoPanner extends LFOEffect<AutoPannerOptions> {
 	constructor(frequency?: Frequency);
 	constructor(options?: Partial<AutoPannerOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(AutoPanner.getDefaults(), arguments, [
-				"frequency",
-			])
-		);
 		const options = optionsFromArguments(
 			AutoPanner.getDefaults(),
 			arguments,
 			["frequency"]
 		);
+		super(options);
 
 		this._panner = new Panner({
 			context: this.context,

package/Tone/effect/AutoWah.ts

@@ -101,18 +101,12 @@ export class AutoWah extends Effect<AutoWahOptions> {
 	);
 	constructor(options?: Partial<AutoWahOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(AutoWah.getDefaults(), arguments, [
-				"baseFrequency",
-				"octaves",
-				"sensitivity",
-			])
-		);
 		const options = optionsFromArguments(AutoWah.getDefaults(), arguments, [
 			"baseFrequency",
 			"octaves",
 			"sensitivity",
 		]);
+		super(options);
 
 		this._follower = new Follower({
 			context: this.context,

package/Tone/effect/BitCrusher.ts

@@ -44,14 +44,12 @@ export class BitCrusher extends Effect<BitCrusherOptions> {
 	constructor(bits?: Positive);
 	constructor(options?: Partial<BitCrusherWorkletOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(BitCrusher.getDefaults(), arguments, ["bits"])
-		);
 		const options = optionsFromArguments(
 			BitCrusher.getDefaults(),
 			arguments,
 			["bits"]
 		);
+		super(options);
 
 		this._bitCrusherWorklet = new BitCrusherWorklet({
 			context: this.context,
@@ -93,11 +91,11 @@ class BitCrusherWorklet extends ToneAudioWorklet<BitCrusherWorkletOptions> {
 
 	constructor(options?: Partial<BitCrusherWorkletOptions>);
 	constructor() {
-		super(optionsFromArguments(BitCrusherWorklet.getDefaults(), arguments));
 		const options = optionsFromArguments(
 			BitCrusherWorklet.getDefaults(),
 			arguments
 		);
+		super(options);
 
 		this.input = new Gain({ context: this.context });
 		this.output = new Gain({ context: this.context });

package/Tone/effect/Chebyshev.ts

@@ -42,14 +42,12 @@ export class Chebyshev extends Effect<ChebyshevOptions> {
 	constructor(order?: Positive);
 	constructor(options?: Partial<ChebyshevOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Chebyshev.getDefaults(), arguments, ["order"])
-		);
 		const options = optionsFromArguments(
 			Chebyshev.getDefaults(),
 			arguments,
 			["order"]
 		);
+		super(options);
 
 		this._shaper = new WaveShaper({
 			context: this.context,

package/Tone/effect/Chorus.ts

@@ -88,18 +88,12 @@ export class Chorus extends StereoFeedbackEffect<ChorusOptions> {
 	);
 	constructor(options?: Partial<ChorusOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Chorus.getDefaults(), arguments, [
-				"frequency",
-				"delayTime",
-				"depth",
-			])
-		);
 		const options = optionsFromArguments(Chorus.getDefaults(), arguments, [
 			"frequency",
 			"delayTime",
 			"depth",
 		]);
+		super(options);
 
 		this._depth = options.depth;
 		this._delayTime = options.delayTime / 1000;

package/Tone/effect/Distortion.ts

@@ -36,16 +36,12 @@ export class Distortion extends Effect<DistortionOptions> {
 	constructor(distortion?: number);
 	constructor(options?: Partial<DistortionOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Distortion.getDefaults(), arguments, [
-				"distortion",
-			])
-		);
 		const options = optionsFromArguments(
 			Distortion.getDefaults(),
 			arguments,
 			["distortion"]
 		);
+		super(options);
 
 		this._shaper = new WaveShaper({
 			context: this.context,

package/Tone/effect/FeedbackDelay.ts

@@ -40,17 +40,12 @@ export class FeedbackDelay extends FeedbackEffect<FeedbackDelayOptions> {
 	constructor(delayTime?: Time, feedback?: NormalRange);
 	constructor(options?: Partial<FeedbackDelayOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(FeedbackDelay.getDefaults(), arguments, [
-				"delayTime",
-				"feedback",
-			])
-		);
 		const options = optionsFromArguments(
 			FeedbackDelay.getDefaults(),
 			arguments,
 			["delayTime", "feedback"]
 		);
+		super(options);
 
 		this._delayNode = new Delay({
 			context: this.context,

package/Tone/effect/Freeverb.ts

@@ -71,17 +71,12 @@ export class Freeverb extends StereoEffect<FreeverbOptions> {
 	constructor(roomSize?: NormalRange, dampening?: Frequency);
 	constructor(options?: Partial<FreeverbOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Freeverb.getDefaults(), arguments, [
-				"roomSize",
-				"dampening",
-			])
-		);
 		const options = optionsFromArguments(
 			Freeverb.getDefaults(),
 			arguments,
 			["roomSize", "dampening"]
 		);
+		super(options);
 
 		this.roomSize = new Signal({
 			context: this.context,

package/Tone/effect/FrequencyShifter.ts

@@ -81,16 +81,12 @@ export class FrequencyShifter extends Effect<FrequencyShifterOptions> {
 	constructor(frequency?: Frequency);
 	constructor(options?: Partial<FrequencyShifterOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(FrequencyShifter.getDefaults(), arguments, [
-				"frequency",
-			])
-		);
 		const options = optionsFromArguments(
 			FrequencyShifter.getDefaults(),
 			arguments,
 			["frequency"]
 		);
+		super(options);
 
 		this.frequency = new Signal({
 			context: this.context,

package/Tone/effect/JCReverb.ts

@@ -73,16 +73,12 @@ export class JCReverb extends StereoEffect<JCReverbOptions> {
 	constructor(roomSize?: NormalRange);
 	constructor(options?: Partial<JCReverbOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(JCReverb.getDefaults(), arguments, [
-				"roomSize",
-			])
-		);
 		const options = optionsFromArguments(
 			JCReverb.getDefaults(),
 			arguments,
 			["roomSize"]
 		);
+		super(options);
 
 		this.roomSize = new Signal({
 			context: this.context,

package/Tone/effect/Phaser.ts

@@ -83,18 +83,12 @@ export class Phaser extends StereoEffect<PhaserOptions> {
 	);
 	constructor(options?: Partial<PhaserOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Phaser.getDefaults(), arguments, [
-				"frequency",
-				"octaves",
-				"baseFrequency",
-			])
-		);
 		const options = optionsFromArguments(Phaser.getDefaults(), arguments, [
 			"frequency",
 			"octaves",
 			"baseFrequency",
 		]);
+		super(options);
 
 		this._lfoL = new LFO({
 			context: this.context,

package/Tone/effect/PingPongDelay.ts

@@ -57,17 +57,12 @@ export class PingPongDelay extends StereoXFeedbackEffect<PingPongDelayOptions> {
 	constructor(delayTime?: Time, feedback?: NormalRange);
 	constructor(options?: Partial<PingPongDelayOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(PingPongDelay.getDefaults(), arguments, [
-				"delayTime",
-				"feedback",
-			])
-		);
 		const options = optionsFromArguments(
 			PingPongDelay.getDefaults(),
 			arguments,
 			["delayTime", "feedback"]
 		);
+		super(options);
 
 		this._leftDelay = new Delay({
 			context: this.context,

package/Tone/effect/PitchShift.ts

@@ -88,14 +88,12 @@ export class PitchShift extends FeedbackEffect<PitchShiftOptions> {
 	constructor(pitch?: Interval);
 	constructor(options?: Partial<PitchShiftOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(PitchShift.getDefaults(), arguments, ["pitch"])
-		);
 		const options = optionsFromArguments(
 			PitchShift.getDefaults(),
 			arguments,
 			["pitch"]
 		);
+		super(options);
 
 		this._frequency = new Signal({ context: this.context });
 		this._delayA = new Delay({

package/Tone/effect/Reverb.ts

@@ -56,10 +56,10 @@ export class Reverb extends Effect<ReverbOptions> {
 	constructor(decay?: Seconds);
 	constructor(options?: Partial<ReverbOptions>);
 	constructor() {
-		super(optionsFromArguments(Reverb.getDefaults(), arguments, ["decay"]));
 		const options = optionsFromArguments(Reverb.getDefaults(), arguments, [
 			"decay",
 		]);
+		super(options);
 
 		this._decay = options.decay;
 		this._preDelay = options.preDelay;

package/Tone/effect/StereoWidener.ts

@@ -63,16 +63,13 @@ export class StereoWidener extends MidSideEffect<StereoWidenerOptions> {
 	constructor(width?: NormalRange);
 	constructor(options?: Partial<StereoWidenerOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(StereoWidener.getDefaults(), arguments, [
-				"width",
-			])
-		);
 		const options = optionsFromArguments(
 			StereoWidener.getDefaults(),
 			arguments,
 			["width"]
 		);
+		super(options);
+
 		this.width = new Signal({
 			context: this.context,
 			value: options.width,

package/Tone/effect/Tremolo.ts

@@ -68,16 +68,11 @@ export class Tremolo extends StereoEffect<TremoloOptions> {
 	constructor(frequency?: Frequency, depth?: NormalRange);
 	constructor(options?: Partial<TremoloOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Tremolo.getDefaults(), arguments, [
-				"frequency",
-				"depth",
-			])
-		);
 		const options = optionsFromArguments(Tremolo.getDefaults(), arguments, [
 			"frequency",
 			"depth",
 		]);
+		super(options);
 
 		this._lfoL = new LFO({
 			context: this.context,

package/Tone/effect/Vibrato.ts

@@ -48,16 +48,11 @@ export class Vibrato extends Effect<VibratoOptions> {
 	constructor(frequency?: Frequency, depth?: NormalRange);
 	constructor(options?: Partial<VibratoOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Vibrato.getDefaults(), arguments, [
-				"frequency",
-				"depth",
-			])
-		);
 		const options = optionsFromArguments(Vibrato.getDefaults(), arguments, [
 			"frequency",
 			"depth",
 		]);
+		super(options);
 
 		this._delayNode = new Delay({
 			context: this.context,

package/Tone/event/Loop.ts

@@ -59,16 +59,11 @@ export class Loop<
 	constructor(callback?: (time: Seconds) => void, interval?: Time);
 	constructor(options?: Partial<LoopOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Loop.getDefaults(), arguments, [
-				"callback",
-				"interval",
-			])
-		);
 		const options = optionsFromArguments(Loop.getDefaults(), arguments, [
 			"callback",
 			"interval",
 		]);
+		super(options);
 
 		this._event = new ToneEvent({
 			context: this.context,

package/Tone/event/Part.ts

@@ -83,16 +83,11 @@ export class Part<ValueType = any> extends ToneEvent<ValueType> {
 	);
 	constructor(options?: Partial<PartOptions<ValueType>>);
 	constructor() {
-		super(
-			optionsFromArguments(Part.getDefaults(), arguments, [
-				"callback",
-				"events",
-			])
-		);
 		const options = optionsFromArguments(Part.getDefaults(), arguments, [
 			"callback",
 			"events",
 		]);
+		super(options);
 
 		// make sure things are assigned in the right order
 		this._state.increasing = true;

package/Tone/event/Pattern.ts

@@ -65,18 +65,12 @@ export class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {
 	);
 	constructor(options?: Partial<PatternOptions<ValueType>>);
 	constructor() {
-		super(
-			optionsFromArguments(Pattern.getDefaults(), arguments, [
-				"callback",
-				"values",
-				"pattern",
-			])
-		);
 		const options = optionsFromArguments(Pattern.getDefaults(), arguments, [
 			"callback",
 			"values",
 			"pattern",
 		]);
+		super(options);
 
 		this.callback = options.callback;
 		this._values = options.values;

package/Tone/event/Sequence.ts

@@ -75,18 +75,12 @@ export class Sequence<ValueType = any> extends ToneEvent<ValueType> {
 	);
 	constructor(options?: Partial<SequenceOptions<ValueType>>);
 	constructor() {
-		super(
-			optionsFromArguments(Sequence.getDefaults(), arguments, [
-				"callback",
-				"events",
-				"subdivision",
-			])
-		);
 		const options = optionsFromArguments(
 			Sequence.getDefaults(),
 			arguments,
 			["callback", "events", "subdivision"]
 		);
+		super(options);
 
 		this._subdivision = this.toTicks(options.subdivision);
 

package/Tone/event/ToneEvent.ts

@@ -124,17 +124,12 @@ export class ToneEvent<ValueType = any> extends ToneWithContext<
 	constructor(callback?: ToneEventCallback<ValueType>, value?: ValueType);
 	constructor(options?: Partial<ToneEventOptions<ValueType>>);
 	constructor() {
-		super(
-			optionsFromArguments(ToneEvent.getDefaults(), arguments, [
-				"callback",
-				"value",
-			])
-		);
 		const options = optionsFromArguments(
 			ToneEvent.getDefaults(),
 			arguments,
 			["callback", "value"]
 		);
+		super(options);
 
 		this._loop = options.loop;
 		this.callback = options.callback;

package/Tone/instrument/DuoSynth.ts

@@ -84,8 +84,8 @@ export class DuoSynth extends Monophonic<DuoSynthOptions> {
 
 	constructor(options?: RecursivePartial<DuoSynthOptions>);
 	constructor() {
-		super(optionsFromArguments(DuoSynth.getDefaults(), arguments));
 		const options = optionsFromArguments(DuoSynth.getDefaults(), arguments);
+		super(options);
 
 		this.voice0 = new MonoSynth(
 			Object.assign(options.voice0, {

package/Tone/instrument/FMSynth.ts

@@ -33,8 +33,8 @@ export class FMSynth extends ModulationSynth<FMSynthOptions> {
 
 	constructor(options?: RecursivePartial<FMSynthOptions>);
 	constructor() {
-		super(optionsFromArguments(FMSynth.getDefaults(), arguments));
 		const options = optionsFromArguments(FMSynth.getDefaults(), arguments);
+		super(options);
 
 		this.modulationIndex = new Multiply({
 			context: this.context,

package/Tone/instrument/Instrument.ts

@@ -52,11 +52,11 @@ export abstract class Instrument<
 
 	constructor(options?: Partial<InstrumentOptions>);
 	constructor() {
-		super(optionsFromArguments(Instrument.getDefaults(), arguments));
 		const options = optionsFromArguments(
 			Instrument.getDefaults(),
 			arguments
 		);
+		super(options);
 
 		this._volume = this.output = new Volume({
 			context: this.context,

package/Tone/instrument/MembraneSynth.ts

@@ -53,11 +53,11 @@ export class MembraneSynth extends Synth<MembraneSynthOptions> {
 	 */
 	constructor(options?: RecursivePartial<MembraneSynthOptions>);
 	constructor() {
-		super(optionsFromArguments(MembraneSynth.getDefaults(), arguments));
 		const options = optionsFromArguments(
 			MembraneSynth.getDefaults(),
 			arguments
 		);
+		super(options);
 
 		this.pitchDecay = options.pitchDecay;
 		this.octaves = options.octaves;

package/Tone/instrument/MetalSynth.ts

@@ -97,11 +97,11 @@ export class MetalSynth extends Monophonic<MetalSynthOptions> {
 
 	constructor(options?: RecursivePartial<MetalSynthOptions>);
 	constructor() {
-		super(optionsFromArguments(MetalSynth.getDefaults(), arguments));
 		const options = optionsFromArguments(
 			MetalSynth.getDefaults(),
 			arguments
 		);
+		super(options);
 
 		this.detune = new Signal({
 			context: this.context,

package/Tone/instrument/ModulationSynth.ts

@@ -88,11 +88,11 @@ export abstract class ModulationSynth<
 
 	constructor(options?: RecursivePartial<ModulationSynthOptions>);
 	constructor() {
-		super(optionsFromArguments(ModulationSynth.getDefaults(), arguments));
 		const options = optionsFromArguments(
 			ModulationSynth.getDefaults(),
 			arguments
 		);
+		super(options);
 
 		this._carrier = new Synth({
 			context: this.context,

package/Tone/instrument/MonoSynth.ts

@@ -77,11 +77,11 @@ export class MonoSynth extends Monophonic<MonoSynthOptions> {
 
 	constructor(options?: RecursivePartial<MonoSynthOptions>);
 	constructor() {
-		super(optionsFromArguments(MonoSynth.getDefaults(), arguments));
 		const options = optionsFromArguments(
 			MonoSynth.getDefaults(),
 			arguments
 		);
+		super(options);
 
 		this.oscillator = new OmniOscillator(
 			Object.assign(options.oscillator, {

package/Tone/instrument/Monophonic.ts

@@ -49,11 +49,11 @@ export abstract class Monophonic<
 
 	constructor(options?: Partial<MonophonicOptions>);
 	constructor() {
-		super(optionsFromArguments(Monophonic.getDefaults(), arguments));
 		const options = optionsFromArguments(
 			Monophonic.getDefaults(),
 			arguments
 		);
+		super(options);
 
 		this.portamento = options.portamento;
 		this.onsilence = options.onsilence;

package/Tone/instrument/NoiseSynth.ts

@@ -43,11 +43,12 @@ export class NoiseSynth extends Instrument<NoiseSynthOptions> {
 
 	constructor(options?: RecursivePartial<NoiseSynthOptions>);
 	constructor() {
-		super(optionsFromArguments(NoiseSynth.getDefaults(), arguments));
 		const options = optionsFromArguments(
 			NoiseSynth.getDefaults(),
 			arguments
 		);
+		super(options);
+
 		this.noise = new Noise(
 			Object.assign(
 				{

package/Tone/instrument/PluckSynth.ts

@@ -52,11 +52,11 @@ export class PluckSynth extends Instrument<PluckSynthOptions> {
 
 	constructor(options?: RecursivePartial<PluckSynthOptions>);
 	constructor() {
-		super(optionsFromArguments(PluckSynth.getDefaults(), arguments));
 		const options = optionsFromArguments(
 			PluckSynth.getDefaults(),
 			arguments
 		);
+		super(options);
 
 		this._noise = new Noise({
 			context: this.context,