Tonejs · tambien · May 6, 2024 · May 6, 2024
diff --git a/Tone/component/analysis/Analyser.ts b/Tone/component/analysis/Analyser.ts
@@ -62,17 +62,12 @@ export class Analyser extends ToneAudioNode<AnalyserOptions> {
 	constructor(type?: AnalyserType, size?: number);
 	constructor(options?: Partial<AnalyserOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Analyser.getDefaults(), arguments, [
-				"type",
-				"size",
-			])
-		);
 		const options = optionsFromArguments(
 			Analyser.getDefaults(),
 			arguments,
 			["type", "size"]
 		);
+		super(options);
 
 		this.input =
 			this.output =

diff --git a/Tone/component/analysis/FFT.ts b/Tone/component/analysis/FFT.ts
@@ -32,10 +32,10 @@ export class FFT extends MeterBase<FFTOptions> {
 	constructor(size?: PowerOfTwo);
 	constructor(options?: Partial<FFTOptions>);
 	constructor() {
-		super(optionsFromArguments(FFT.getDefaults(), arguments, ["size"]));
 		const options = optionsFromArguments(FFT.getDefaults(), arguments, [
 			"size",
 		]);
+		super(options);
 
 		this.normalRange = options.normalRange;
 		this._analyser.type = "fft";

diff --git a/Tone/component/analysis/Follower.ts b/Tone/component/analysis/Follower.ts
@@ -50,16 +50,12 @@ export class Follower extends ToneAudioNode<FollowerOptions> {
 	constructor(smoothing?: Time);
 	constructor(options?: Partial<FollowerOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Follower.getDefaults(), arguments, [
-				"smoothing",
-			])
-		);
 		const options = optionsFromArguments(
 			Follower.getDefaults(),
 			arguments,
 			["smoothing"]
 		);
+		super(options);
 
 		this._abs = this.input = new Abs({ context: this.context });
 		this._lowpass = this.output = new OnePoleFilter({

diff --git a/Tone/component/analysis/Meter.ts b/Tone/component/analysis/Meter.ts
@@ -55,12 +55,10 @@ export class Meter extends MeterBase<MeterOptions> {
 	constructor(smoothing?: NormalRange);
 	constructor(options?: Partial<MeterOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Meter.getDefaults(), arguments, ["smoothing"])
-		);
 		const options = optionsFromArguments(Meter.getDefaults(), arguments, [
 			"smoothing",
 		]);
+		super(options);
 
 		this.input =
 			this.output =

diff --git a/Tone/component/analysis/Waveform.ts b/Tone/component/analysis/Waveform.ts
@@ -22,14 +22,12 @@ export class Waveform extends MeterBase<WaveformOptions> {
 	constructor(size?: PowerOfTwo);
 	constructor(options?: Partial<WaveformOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Waveform.getDefaults(), arguments, ["size"])
-		);
 		const options = optionsFromArguments(
 			Waveform.getDefaults(),
 			arguments,
 			["size"]
 		);
+		super(options);
 
 		this._analyser.type = "waveform";
 		this.size = options.size;

diff --git a/Tone/component/channel/Channel.ts b/Tone/component/channel/Channel.ts
@@ -63,16 +63,11 @@ export class Channel extends ToneAudioNode<ChannelOptions> {
 	constructor(volume?: Decibels, pan?: AudioRange);
 	constructor(options?: Partial<ChannelOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Channel.getDefaults(), arguments, [
-				"volume",
-				"pan",
-			])
-		);
 		const options = optionsFromArguments(Channel.getDefaults(), arguments, [
 			"volume",
 			"pan",
 		]);
+		super(options);
 
 		this._solo = this.input = new Solo({
 			solo: options.solo,

diff --git a/Tone/component/channel/CrossFade.ts b/Tone/component/channel/CrossFade.ts
@@ -100,18 +100,12 @@ export class CrossFade extends ToneAudioNode<CrossFadeOptions> {
 	constructor(fade?: NormalRange);
 	constructor(options?: Partial<CrossFadeOptions>);
 	constructor() {
-		super(
-			Object.assign(
-				optionsFromArguments(CrossFade.getDefaults(), arguments, [
-					"fade",
-				])
-			)
-		);
 		const options = optionsFromArguments(
 			CrossFade.getDefaults(),
 			arguments,
 			["fade"]
 		);
+		super(options);
 
 		this.fade = new Signal({
 			context: this.context,

diff --git a/Tone/component/channel/Merge.ts b/Tone/component/channel/Merge.ts
@@ -44,12 +44,10 @@ export class Merge extends ToneAudioNode<MergeOptions> {
 	constructor(channels?: Positive);
 	constructor(options?: Partial<MergeOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Merge.getDefaults(), arguments, ["channels"])
-		);
 		const options = optionsFromArguments(Merge.getDefaults(), arguments, [
 			"channels",
 		]);
+		super(options);
 
 		this._merger =
 			this.output =

diff --git a/Tone/component/channel/MultibandSplit.ts b/Tone/component/channel/MultibandSplit.ts
@@ -106,17 +106,12 @@ export class MultibandSplit extends ToneAudioNode<MultibandSplitOptions> {
 	constructor(lowFrequency?: Frequency, highFrequency?: Frequency);
 	constructor(options?: Partial<MultibandSplitOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(MultibandSplit.getDefaults(), arguments, [
-				"lowFrequency",
-				"highFrequency",
-			])
-		);
 		const options = optionsFromArguments(
 			MultibandSplit.getDefaults(),
 			arguments,
 			["lowFrequency", "highFrequency"]
 		);
+		super(options);
 
 		this.lowFrequency = new Signal({
 			context: this.context,

diff --git a/Tone/component/channel/PanVol.ts b/Tone/component/channel/PanVol.ts
@@ -61,16 +61,11 @@ export class PanVol extends ToneAudioNode<PanVolOptions> {
 	constructor(pan?: AudioRange, volume?: Decibels);
 	constructor(options?: Partial<PanVolOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(PanVol.getDefaults(), arguments, [
-				"pan",
-				"volume",
-			])
-		);
 		const options = optionsFromArguments(PanVol.getDefaults(), arguments, [
 			"pan",
 			"volume",
 		]);
+		super(options);
 
 		this._panner = this.input = new Panner({
 			context: this.context,

diff --git a/Tone/component/channel/Panner.ts b/Tone/component/channel/Panner.ts
@@ -54,14 +54,10 @@ export class Panner extends ToneAudioNode<TonePannerOptions> {
 	 */
 	constructor(pan?: AudioRange);
 	constructor() {
-		super(
-			Object.assign(
-				optionsFromArguments(Panner.getDefaults(), arguments, ["pan"])
-			)
-		);
 		const options = optionsFromArguments(Panner.getDefaults(), arguments, [
 			"pan",
 		]);
+		super(options);
 
 		this.pan = new Param({
 			context: this.context,

diff --git a/Tone/component/channel/Panner3D.ts b/Tone/component/channel/Panner3D.ts
@@ -54,18 +54,12 @@ export class Panner3D extends ToneAudioNode<Panner3DOptions> {
 	constructor(positionX: number, positionY: number, positionZ: number);
 	constructor(options?: Partial<Panner3DOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Panner3D.getDefaults(), arguments, [
-				"positionX",
-				"positionY",
-				"positionZ",
-			])
-		);
 		const options = optionsFromArguments(
 			Panner3D.getDefaults(),
 			arguments,
 			["positionX", "positionY", "positionZ"]
 		);
+		super(options);
 
 		this._panner = this.input = this.output = this.context.createPanner();
 		// set some values

diff --git a/Tone/component/channel/Recorder.ts b/Tone/component/channel/Recorder.ts
@@ -57,8 +57,8 @@ export class Recorder extends ToneAudioNode<RecorderOptions> {
 
 	constructor(options?: Partial<RecorderOptions>);
 	constructor() {
-		super(optionsFromArguments(Recorder.getDefaults(), arguments));
 		const options = optionsFromArguments(Recorder.getDefaults(), arguments);
+		super(options);
 
 		this.input = new Gain({
 			context: this.context,

diff --git a/Tone/component/channel/Solo.ts b/Tone/component/channel/Solo.ts
@@ -34,10 +34,10 @@ export class Solo extends ToneAudioNode<SoloOptions> {
 	constructor(solo?: boolean);
 	constructor(options?: Partial<SoloOptions>);
 	constructor() {
-		super(optionsFromArguments(Solo.getDefaults(), arguments, ["solo"]));
 		const options = optionsFromArguments(Solo.getDefaults(), arguments, [
 			"solo",
 		]);
+		super(options);
 
 		this.input = this.output = new Gain({
 			context: this.context,

diff --git a/Tone/component/channel/Split.ts b/Tone/component/channel/Split.ts
@@ -33,12 +33,10 @@ export class Split extends ToneAudioNode<SplitOptions> {
 	constructor(channels?: number);
 	constructor(options?: Partial<SplitOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Split.getDefaults(), arguments, ["channels"])
-		);
 		const options = optionsFromArguments(Split.getDefaults(), arguments, [
 			"channels",
 		]);
+		super(options);
 
 		this._splitter =
 			this.input =

diff --git a/Tone/component/channel/Volume.ts b/Tone/component/channel/Volume.ts
@@ -54,12 +54,10 @@ export class Volume extends ToneAudioNode<VolumeOptions> {
 	constructor(volume?: Decibels);
 	constructor(options?: Partial<VolumeOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Volume.getDefaults(), arguments, ["volume"])
-		);
 		const options = optionsFromArguments(Volume.getDefaults(), arguments, [
 			"volume",
 		]);
+		super(options);
 
 		this.input = this.output = new Gain({
 			context: this.context,

diff --git a/Tone/component/dynamics/Compressor.ts b/Tone/component/dynamics/Compressor.ts
@@ -79,17 +79,12 @@ export class Compressor extends ToneAudioNode<CompressorOptions> {
 	constructor(threshold?: Decibels, ratio?: Positive);
 	constructor(options?: Partial<CompressorOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Compressor.getDefaults(), arguments, [
-				"threshold",
-				"ratio",
-			])
-		);
 		const options = optionsFromArguments(
 			Compressor.getDefaults(),
 			arguments,
 			["threshold", "ratio"]
 		);
+		super(options);
 
 		this.threshold = new Param({
 			minValue: this._compressor.threshold.minValue,

diff --git a/Tone/component/dynamics/Gate.ts b/Tone/component/dynamics/Gate.ts
@@ -54,18 +54,11 @@ export class Gate extends ToneAudioNode<GateOptions> {
 	constructor(threshold?: Decibels, smoothing?: Time);
 	constructor(options?: Partial<GateOptions>);
 	constructor() {
-		super(
-			Object.assign(
-				optionsFromArguments(Gate.getDefaults(), arguments, [
-					"threshold",
-					"smoothing",
-				])
-			)
-		);
 		const options = optionsFromArguments(Gate.getDefaults(), arguments, [
 			"threshold",
 			"smoothing",
 		]);
+		super(options);
 
 		this._follower = new Follower({
 			context: this.context,

diff --git a/Tone/component/dynamics/Limiter.ts b/Tone/component/dynamics/Limiter.ts
@@ -44,16 +44,10 @@ export class Limiter extends ToneAudioNode<LimiterOptions> {
 	constructor(threshold?: Decibels);
 	constructor(options?: Partial<LimiterOptions>);
 	constructor() {
-		super(
-			Object.assign(
-				optionsFromArguments(Limiter.getDefaults(), arguments, [
-					"threshold",
-				])
-			)
-		);
 		const options = optionsFromArguments(Limiter.getDefaults(), arguments, [
 			"threshold",
 		]);
+		super(options);
 
 		this._compressor =
 			this.input =

diff --git a/Tone/component/dynamics/MidSideCompressor.ts b/Tone/component/dynamics/MidSideCompressor.ts
@@ -49,15 +49,11 @@ export class MidSideCompressor extends ToneAudioNode<MidSideCompressorOptions> {
 
 	constructor(options?: RecursivePartial<MidSideCompressorOptions>);
 	constructor() {
-		super(
-			Object.assign(
-				optionsFromArguments(MidSideCompressor.getDefaults(), arguments)
-			)
-		);
 		const options = optionsFromArguments(
 			MidSideCompressor.getDefaults(),
 			arguments
 		);
+		super(options);
 
 		this._midSideSplit = this.input = new MidSideSplit({
 			context: this.context,

diff --git a/Tone/component/dynamics/MultibandCompressor.ts b/Tone/component/dynamics/MultibandCompressor.ts
@@ -71,18 +71,11 @@ export class MultibandCompressor extends ToneAudioNode<MultibandCompressorOption
 
 	constructor(options?: RecursivePartial<MultibandCompressorOptions>);
 	constructor() {
-		super(
-			Object.assign(
-				optionsFromArguments(
-					MultibandCompressor.getDefaults(),
-					arguments
-				)
-			)
-		);
 		const options = optionsFromArguments(
 			MultibandCompressor.getDefaults(),
 			arguments
 		);
+		super(options);
 
 		this._splitter = this.input = new MultibandSplit({
 			context: this.context,

diff --git a/Tone/component/envelope/Envelope.ts b/Tone/component/envelope/Envelope.ts
@@ -186,19 +186,12 @@ export class Envelope extends ToneAudioNode<EnvelopeOptions> {
 	);
 	constructor(options?: Partial<EnvelopeOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(Envelope.getDefaults(), arguments, [
-				"attack",
-				"decay",
-				"sustain",
-				"release",
-			])
-		);
 		const options = optionsFromArguments(
 			Envelope.getDefaults(),
 			arguments,
 			["attack", "decay", "sustain", "release"]
 		);
+		super(options);
 
 		this.attack = options.attack;
 		this.decay = options.decay;

diff --git a/Tone/component/envelope/FrequencyEnvelope.ts b/Tone/component/envelope/FrequencyEnvelope.ts
@@ -62,19 +62,12 @@ export class FrequencyEnvelope extends Envelope {
 	);
 	constructor(options?: Partial<FrequencyEnvelopeOptions>);
 	constructor() {
-		super(
-			optionsFromArguments(FrequencyEnvelope.getDefaults(), arguments, [
-				"attack",
-				"decay",
-				"sustain",
-				"release",
-			])
-		);
 		const options = optionsFromArguments(
 			FrequencyEnvelope.getDefaults(),
 			arguments,
 			["attack", "decay", "sustain", "release"]
 		);
+		super(options);
 
 		this._octaves = options.octaves;
 		this._baseFrequency = this.toFrequency(options.baseFrequency);