@fluex/fluexgl-dsp 0.4.7 → 0.4.8

package/lib/src/effects/classes/Analyser.ts

@@ -24,10 +24,10 @@ export class Analyser extends Effector {
     constructor(options?: Partial<AnalyserOptions>) {
         super();
 
-        if (options) this.SetOptions(options);
+        if (options) this.setOptions(options);
     }
 
-    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
 
         this.context = context;
         this.analyserNode = new AnalyserNode(context, this.options);
@@ -36,7 +36,7 @@ export class Analyser extends Effector {
         this.allocateBuffers();
     }
 
-    public SetOptions(options: Partial<AnalyserOptions>): void {
+    public setOptions(options: Partial<AnalyserOptions>): void {
 
         (Object.keys(options) as AnalyserOptionKeys[]).forEach((key) => {
             const value = options[key];
@@ -60,7 +60,7 @@ export class Analyser extends Effector {
         }
     }
 
-    public GetWaveformFloatData(): Float32Array | null {
+    public getWaveformFloatData(): Float32Array | null {
 
         if (!this.analyserNode) return null;
 
@@ -68,7 +68,7 @@ export class Analyser extends Effector {
         return this.waveformFloat32ArrayBuffer;
     }
 
-    public GetWaveformByteData(): Uint8Array | null {
+    public getWaveformByteData(): Uint8Array | null {
 
         if (!this.analyserNode) return null;
 
@@ -76,7 +76,7 @@ export class Analyser extends Effector {
         return this.waveformUint8ArrayBuffer;
     }
 
-    public GetFrequencyFloatData(): Float32Array | null {
+    public getFrequencyFloatData(): Float32Array | null {
 
         if(!this.analyserNode) return null;
 
@@ -84,7 +84,7 @@ export class Analyser extends Effector {
         return this.frequencyFloat32ArrayBuffer;
     }
 
-    public GetFrequencyByteData(): Uint8Array | null {
+    public getFrequencyByteData(): Uint8Array | null {
 
         if(!this.analyserNode) return null;
 

package/lib/src/effects/classes/Chorus.ts

@@ -1,4 +1,4 @@
-import { CoerceFiniteNumber, SendMessageToWorklet, CreateAudioWorkletNode } from "../../utilities/helpers";
+import { coerceFiniteNumber, sendMessageToWorklet, createAudioWorkletNode } from "../../utilities/helpers";
 import { Effector } from "../../core/classes/Effector";
 import { ChorusEffectOptions, ChorusMessageCommandId, AudioWorkletProcessorNames, StrictMode } from "../../typings";
 
@@ -17,22 +17,22 @@ export class Chorus extends Effector {
     constructor({ baseDelayMs, depthMs, rateHz, mix, feedback, strictMode }: Partial<ChorusEffectOptions>) {
         super();
 
-        this.baseDelayMs = Math.max(0, CoerceFiniteNumber(baseDelayMs, this.baseDelayMs));
-        this.depthMs = Math.max(0, CoerceFiniteNumber(depthMs, this.depthMs));
-        this.rateHz = Math.max(0, CoerceFiniteNumber(rateHz, this.rateHz));
-        this.mix = Math.max(0, Math.min(1, CoerceFiniteNumber(mix, this.mix)));
-        this.feedback = Math.max(0, Math.min(1, CoerceFiniteNumber(feedback, this.feedback)));
+        this.baseDelayMs = Math.max(0, coerceFiniteNumber(baseDelayMs, this.baseDelayMs));
+        this.depthMs = Math.max(0, coerceFiniteNumber(depthMs, this.depthMs));
+        this.rateHz = Math.max(0, coerceFiniteNumber(rateHz, this.rateHz));
+        this.mix = Math.max(0, Math.min(1, coerceFiniteNumber(mix, this.mix)));
+        this.feedback = Math.max(0, Math.min(1, coerceFiniteNumber(feedback, this.feedback)));
 
-        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        const mode = coerceFiniteNumber(strictMode, this.strictMode);
         this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
     }
 
-    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
         this.context = context;
-        this.audioWorkletNode = CreateAudioWorkletNode<ChorusEffectOptions>(context, AudioWorkletProcessorNames.Chorus, this.ReturnOptionsAsObject());
+        this.audioWorkletNode = createAudioWorkletNode<ChorusEffectOptions>(context, AudioWorkletProcessorNames.Chorus, this.returnOptionsAsObject());
     }
 
-    public ReturnOptionsAsObject(): ChorusEffectOptions {
+    public returnOptionsAsObject(): ChorusEffectOptions {
         return {
             baseDelayMs: this.baseDelayMs,
             depthMs: this.depthMs,
@@ -43,33 +43,33 @@ export class Chorus extends Effector {
         }
     }
 
-    public SetBaseDelayMs(value: number): boolean {
-        value = Math.max(0, CoerceFiniteNumber(value, this.baseDelayMs));
+    public setBaseDelayMs(value: number): boolean {
+        value = Math.max(0, coerceFiniteNumber(value, this.baseDelayMs));
         this.baseDelayMs = value;
-        return SendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetBaseDelayMs, value);
+        return sendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetBaseDelayMs, value);
     }
 
-    public SetDepthMs(value: number) {
-        value = Math.max(0, CoerceFiniteNumber(value, this.depthMs));
+    public setDepthMs(value: number) {
+        value = Math.max(0, coerceFiniteNumber(value, this.depthMs));
         this.depthMs = value;
-        return SendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetDepthMs, value);
+        return sendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetDepthMs, value);
     }
 
-    public SetRateHz(value: number) {
-        value = Math.max(0, CoerceFiniteNumber(value, this.rateHz));
+    public setRateHz(value: number) {
+        value = Math.max(0, coerceFiniteNumber(value, this.rateHz));
         this.rateHz = value;
-        return SendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetRateHz, value);
+        return sendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetRateHz, value);
     }
 
-    public SetMix(value: number) {
-        value = Math.max(0, Math.min(1, CoerceFiniteNumber(value, this.mix)));
+    public setMix(value: number) {
+        value = Math.max(0, Math.min(1, coerceFiniteNumber(value, this.mix)));
         this.mix = value;
-        return SendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetMix, value);
+        return sendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetMix, value);
     }
 
-    public SetFeedback(value: number) {
-        value = Math.max(0, Math.min(1, CoerceFiniteNumber(value, this.feedback)));
+    public setFeedback(value: number) {
+        value = Math.max(0, Math.min(1, coerceFiniteNumber(value, this.feedback)));
         this.feedback = value;
-        return SendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetFeedback, value);
+        return sendMessageToWorklet<ChorusMessageCommandId, number>(this.audioWorkletNode, ChorusMessageCommandId.SetFeedback, value);
     }
 }

package/lib/src/effects/classes/Distortion.ts

@@ -8,7 +8,7 @@ export class Distortion extends Effector {
         super();
     }
 
-    public async InitializeOnAttachment(parentialContext: AudioContext): Promise<void> {
+    public async initializeOnAttachment(parentialContext: AudioContext): Promise<void> {
         
     }
 }

package/lib/src/effects/classes/Reverb.ts

@@ -0,0 +1,81 @@
+import { Effector } from "../../core/exports";
+import { AudioWorkletProcessorNames, StrictMode } from "../../typings";
+import { coerceFiniteNumber, createAudioWorkletNode, sendMessageToWorklet } from "../../utilities/helpers";
+
+export interface ReverbOptions {
+    roomSize: number;
+    damping: number;
+    mix: number;
+    stereoSpreadMs: number;
+    strictMode: StrictMode;
+}
+
+export enum ReverbMessageCommandId {
+    SetRoomSize,
+    SetDamping,
+    SetMix,
+    SetStereoSpreadMs
+}
+
+export class Reverb extends Effector {
+
+    public label: string | null = "Reverb";
+    public name: string = "Reverb";
+
+    public roomSize: number = 0.3;
+    public damping: number = 0.5;
+    public mix: number = 0.3;
+    public stereoSpreadMs: number = 0;
+    public strictMode: StrictMode = StrictMode.Disabled;
+
+    constructor(options?: Partial<ReverbOptions>) {
+        super();
+
+        this.roomSize = Math.max(0, coerceFiniteNumber(options?.roomSize ?? this.roomSize, this.roomSize));
+        this.damping = Math.max(0, coerceFiniteNumber(options?.damping ?? this.damping, this.damping));
+        this.mix = Math.max(0, coerceFiniteNumber(options?.mix ?? this.mix, this.mix));
+        this.stereoSpreadMs = Math.max(0, coerceFiniteNumber(options?.stereoSpreadMs ?? this.stereoSpreadMs, this.stereoSpreadMs));
+
+        const mode = coerceFiniteNumber(options?.strictMode ?? this.strictMode, this.strictMode);
+        this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
+    }
+
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
+        this.context = context;
+        this.audioWorkletNode = createAudioWorkletNode<ReverbOptions>(context, AudioWorkletProcessorNames.Reverb, this.returnOptionsAsObject());
+    }
+
+    public returnOptionsAsObject(): ReverbOptions {
+        return {
+            roomSize: this.roomSize,
+            damping: this.damping,
+            mix: this.mix,
+            stereoSpreadMs: this.stereoSpreadMs,
+            strictMode: this.strictMode
+        }
+    }
+
+    public setRoomSize(roomSize: number): boolean {
+        roomSize = Math.max(0, coerceFiniteNumber(roomSize ?? this.roomSize, this.roomSize));
+        this.roomSize = roomSize;
+        return sendMessageToWorklet<ReverbMessageCommandId, number>(this.audioWorkletNode, ReverbMessageCommandId.SetRoomSize, roomSize);
+    }
+
+    public setDamping(damping: number): boolean {
+        damping = Math.max(0, coerceFiniteNumber(damping ?? this.damping, this.damping));
+        this.damping = damping;
+        return sendMessageToWorklet<ReverbMessageCommandId, number>(this.audioWorkletNode, ReverbMessageCommandId.SetDamping, damping);
+    }
+
+    public setMix(mix: number): boolean {
+        mix = Math.max(0, coerceFiniteNumber(mix ?? this.mix, this.mix));
+        this.mix = mix;
+        return sendMessageToWorklet<ReverbMessageCommandId, number>(this.audioWorkletNode, ReverbMessageCommandId.SetMix, mix);
+    }
+
+    public setStereoSpreadMs(stereoSpreadMs: number) {
+        stereoSpreadMs = Math.max(0, coerceFiniteNumber(stereoSpreadMs ?? this.stereoSpreadMs, this.stereoSpreadMs));
+        this.stereoSpreadMs = stereoSpreadMs;
+        return sendMessageToWorklet<ReverbMessageCommandId, number>(this.audioWorkletNode, ReverbMessageCommandId.SetStereoSpreadMs, stereoSpreadMs);
+    }
+}

package/lib/src/effects/classes/clips/HardClip.ts

@@ -1,5 +1,5 @@
 import { Effector } from "../../../core/classes/Effector";
-import { CoerceFiniteNumber, CreateAudioWorkletNode, SendMessageToWorklet } from "../../../utilities/helpers";
+import { coerceFiniteNumber, createAudioWorkletNode, sendMessageToWorklet } from "../../../utilities/helpers";
 import { HardClipMessageCommandId, AudioWorkletProcessorNames, HardClipOptions, StrictMode } from "../../../typings";
 
 export class HardClip extends Effector {
@@ -11,22 +11,22 @@ export class HardClip extends Effector {
     public gain: number = 1;
     public strictMode: StrictMode = StrictMode.Disabled;
 
-    constructor({ drive, gain, strictMode }: Partial<HardClipOptions>) {
+    constructor(options?: HardClipOptions) {
         super();
 
-        this.drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
-        this.gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
+        this.drive = Math.max(0, coerceFiniteNumber(options?.drive ?? this.drive, this.drive));
+        this.gain = Math.max(0, coerceFiniteNumber(options?.gain ?? this.gain, this.gain));
 
-        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        const mode = coerceFiniteNumber(options?.strictMode ?? this.strictMode, this.strictMode);
         this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
     }
 
-    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
         this.context = context;
-        this.audioWorkletNode = CreateAudioWorkletNode<HardClipOptions>(context, AudioWorkletProcessorNames.HardClip, this.ReturnOptionsAsObject());
+        this.audioWorkletNode = createAudioWorkletNode<HardClipOptions>(context, AudioWorkletProcessorNames.HardClip, this.returnOptionsAsObject());
     }
 
-    public ReturnOptionsAsObject(): HardClipOptions {
+    public returnOptionsAsObject(): HardClipOptions {
         return {
             drive: this.drive,
             gain: this.gain,
@@ -34,15 +34,15 @@ export class HardClip extends Effector {
         }
     }
 
-     public SetDrive(drive: number): boolean {
-        drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
+     public setDrive(drive: number): boolean {
+        drive = Math.max(0, coerceFiniteNumber(drive, this.drive));
         this.drive = drive;
-        return SendMessageToWorklet<HardClipMessageCommandId, number>(this.audioWorkletNode, HardClipMessageCommandId.SetDrive, drive);
+        return sendMessageToWorklet<HardClipMessageCommandId, number>(this.audioWorkletNode, HardClipMessageCommandId.SetDrive, drive);
     }
 
-    public SetGain(gain: number): boolean{
-        gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
+    public setGain(gain: number): boolean{
+        gain = Math.max(0, coerceFiniteNumber(gain, this.gain));
         this.gain = gain;
-        return SendMessageToWorklet<HardClipMessageCommandId, number>(this.audioWorkletNode, HardClipMessageCommandId.SetGain, gain);
+        return sendMessageToWorklet<HardClipMessageCommandId, number>(this.audioWorkletNode, HardClipMessageCommandId.SetGain, gain);
     }
 }

package/lib/src/effects/classes/clips/SoftClip.ts

@@ -1,4 +1,4 @@
-import { CoerceFiniteNumber, CreateAudioWorkletNode, SendMessageToWorklet } from "../../../utilities/helpers";
+import { coerceFiniteNumber, createAudioWorkletNode, sendMessageToWorklet } from "../../../utilities/helpers";
 import { Effector } from "../../../core/classes/Effector";
 import { SoftClipOptions, AudioWorkletProcessorNames, SoftClipMessageCommandId, StrictMode } from "../../../typings";
 
@@ -14,23 +14,23 @@ export class SoftClip extends Effector {
     constructor({ drive, gain, strictMode }: Partial<SoftClipOptions> = {}) {
         super();
 
-        this.drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
-        this.gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
+        this.drive = Math.max(0, coerceFiniteNumber(drive, this.drive));
+        this.gain = Math.max(0, coerceFiniteNumber(gain, this.gain));
 
-        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        const mode = coerceFiniteNumber(strictMode, this.strictMode);
         this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
     }
 
-    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
     
         if(this.context === null) 
             this.context = context;
         
         if(this.audioWorkletNode === null) 
-            this.audioWorkletNode = CreateAudioWorkletNode<SoftClipOptions>(context, AudioWorkletProcessorNames.SoftClip, this.ReturnOptionsAsObject());
+            this.audioWorkletNode = createAudioWorkletNode<SoftClipOptions>(context, AudioWorkletProcessorNames.SoftClip, this.returnOptionsAsObject());
     }
 
-    public ReturnOptionsAsObject(): SoftClipOptions {
+    public returnOptionsAsObject(): SoftClipOptions {
         return {
             drive: this.drive,
             gain: this.gain,
@@ -38,15 +38,15 @@ export class SoftClip extends Effector {
         }
     }
 
-    public SetDrive(drive: number): boolean {
-        drive = Math.max(0, CoerceFiniteNumber(drive, this.drive));
+    public setDrive(drive: number): boolean {
+        drive = Math.max(0, coerceFiniteNumber(drive, this.drive));
         this.drive = drive;
-        return SendMessageToWorklet<SoftClipMessageCommandId, number>(this.audioWorkletNode, SoftClipMessageCommandId.SetDrive, drive);
+        return sendMessageToWorklet<SoftClipMessageCommandId, number>(this.audioWorkletNode, SoftClipMessageCommandId.SetDrive, drive);
     }
 
-    public SetGain(gain: number): boolean{
-        gain = Math.max(0, CoerceFiniteNumber(gain, this.gain));
+    public setGain(gain: number): boolean{
+        gain = Math.max(0, coerceFiniteNumber(gain, this.gain));
         this.gain = gain;
-        return SendMessageToWorklet<SoftClipMessageCommandId, number>(this.audioWorkletNode, SoftClipMessageCommandId.SetGain, gain);
+        return sendMessageToWorklet<SoftClipMessageCommandId, number>(this.audioWorkletNode, SoftClipMessageCommandId.SetGain, gain);
     }
 }

package/lib/src/effects/classes/filters/HighPassFilter.ts

@@ -1,4 +1,4 @@
-import { CoerceFiniteNumber, CreateAudioWorkletNode, SendMessageToWorklet } from "../../../utilities/helpers";
+import { coerceFiniteNumber, createAudioWorkletNode, sendMessageToWorklet } from "../../../utilities/helpers";
 import { Effector } from "../../../core/classes/Effector";
 import { AudioWorkletProcessorNames, HighPassFilterMessageCommandId, HighPassFilterOptions, StrictMode } from "../../../typings";
 import { DEFAULT_SAMPLE_RATE } from "../../../utilities/constants";
@@ -18,22 +18,22 @@ export class HighPassFilter extends Effector {
     constructor({ cutoff, q, strictMode }: Partial<HighPassFilterOptions> = {}) {
         super();
 
-        this.cutoff = CoerceFiniteNumber(cutoff, this.cutoff);
-        this.q = CoerceFiniteNumber(q, this.q);
+        this.cutoff = coerceFiniteNumber(cutoff, this.cutoff);
+        this.q = coerceFiniteNumber(q, this.q);
 
-        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        const mode = coerceFiniteNumber(strictMode, this.strictMode);
         this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
         this.audioWorkletNode && this.registerMessageEventListener(this.audioWorkletNode);
     }
 
-    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
 
         this.context = context;
         this.contextSampleRate = context.sampleRate;
-        this.audioWorkletNode = CreateAudioWorkletNode(context, AudioWorkletProcessorNames.HighPassFilter, this.ReturnOptionsAsObject());
+        this.audioWorkletNode = createAudioWorkletNode(context, AudioWorkletProcessorNames.HighPassFilter, this.returnOptionsAsObject());
     }
 
-    public ReturnOptionsAsObject(): HighPassFilterOptions {
+    public returnOptionsAsObject(): HighPassFilterOptions {
         return {
             cutoff: this.cutoff,
             q: this.q,
@@ -42,40 +42,40 @@ export class HighPassFilter extends Effector {
         }
     }
 
-    public SetCutoff(cutoff: number = 1000): boolean {
+    public setCutoff(cutoff: number = 1000): boolean {
 
         if (!this.context) return false;
 
-        cutoff = CoerceFiniteNumber(cutoff, this.cutoff);
+        cutoff = coerceFiniteNumber(cutoff, this.cutoff);
         cutoff = Math.min(this.maxFrequency, cutoff);
 
         if (cutoff >= this.context.sampleRate)
             cutoff = this.context.sampleRate;
 
         this.cutoff = cutoff;
-        return SendMessageToWorklet<HighPassFilterMessageCommandId, number>(this.audioWorkletNode, HighPassFilterMessageCommandId.SetCutoff, cutoff);
+        return sendMessageToWorklet<HighPassFilterMessageCommandId, number>(this.audioWorkletNode, HighPassFilterMessageCommandId.SetCutoff, cutoff);
     }
     
-    public SetMaxFrequency(maxFrequency: number = this.maxFrequency) {
+    public setMaxFrequency(maxFrequency: number = this.maxFrequency) {
 
-        maxFrequency = CoerceFiniteNumber(maxFrequency, this.maxFrequency);
+        maxFrequency = coerceFiniteNumber(maxFrequency, this.maxFrequency);
 
         if(maxFrequency > (this.contextSampleRate * 0.5))
             throw new Error("Could not set the max frequency, because the value is over the sample rate.");
 
         this.maxFrequency = maxFrequency;
-        return SendMessageToWorklet<HighPassFilterMessageCommandId.SetMaxFrequency, number>(this.audioWorkletNode, HighPassFilterMessageCommandId.SetMaxFrequency, maxFrequency);
+        return sendMessageToWorklet<HighPassFilterMessageCommandId.SetMaxFrequency, number>(this.audioWorkletNode, HighPassFilterMessageCommandId.SetMaxFrequency, maxFrequency);
     }
 
-    public SetQ(q: number = 0.7): boolean {
+    public setQ(q: number = 0.7): boolean {
 
-        q = CoerceFiniteNumber(q, this.q);
+        q = coerceFiniteNumber(q, this.q);
         q = Math.max(0.0001, q);
 
         if (q > 4)
             q = 4;
 
         this.q = q;
-        return SendMessageToWorklet<HighPassFilterMessageCommandId, number>(this.audioWorkletNode, HighPassFilterMessageCommandId.SetQ, q);
+        return sendMessageToWorklet<HighPassFilterMessageCommandId, number>(this.audioWorkletNode, HighPassFilterMessageCommandId.SetQ, q);
     }
 }

package/lib/src/effects/classes/filters/LowPassFilter.ts

@@ -1,6 +1,6 @@
 import { Effector } from "../../../core/classes/Effector";
 
-import { CoerceFiniteNumber, SendMessageToWorklet, CreateAudioWorkletNode } from "../../../utilities/helpers";
+import { coerceFiniteNumber, sendMessageToWorklet, createAudioWorkletNode } from "../../../utilities/helpers";
 
 import { LowPassFilterOptions, LowPassFilterMessageCommandId, AudioWorkletProcessorNames, StrictMode } from "../../../typings";
 
@@ -17,22 +17,22 @@ export class LowPassFilter extends Effector {
     constructor({ cutoff, minFrequency, q, strictMode }: Partial<LowPassFilterOptions>) {
         super();
 
-        this.cutoff = CoerceFiniteNumber(cutoff, this.cutoff);
-        this.minFrequency = CoerceFiniteNumber(minFrequency, this.minFrequency);
-        this.q = CoerceFiniteNumber(q, this.q);
+        this.cutoff = coerceFiniteNumber(cutoff, this.cutoff);
+        this.minFrequency = coerceFiniteNumber(minFrequency, this.minFrequency);
+        this.q = coerceFiniteNumber(q, this.q);
 
-        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        const mode = coerceFiniteNumber(strictMode, this.strictMode);
         this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
     }
 
-    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
 
         this.context = context;
-        this.audioWorkletNode = CreateAudioWorkletNode(context, AudioWorkletProcessorNames.LowPassFilter, this.ReturnOptionsAsObject());
+        this.audioWorkletNode = createAudioWorkletNode(context, AudioWorkletProcessorNames.LowPassFilter, this.returnOptionsAsObject());
         this.audioWorkletNode && this.registerMessageEventListener(this.audioWorkletNode);
     }
 
-    public ReturnOptionsAsObject(): LowPassFilterOptions {
+    public returnOptionsAsObject(): LowPassFilterOptions {
         return {
             cutoff: this.cutoff,
             minFrequency: this.minFrequency,
@@ -41,40 +41,40 @@ export class LowPassFilter extends Effector {
         }
     }
 
-    public SetCutoff(cutoff: number = 1000): boolean {
+    public setCutoff(cutoff: number = 1000): boolean {
 
         if (!this.context) return false;
 
-        cutoff = CoerceFiniteNumber(cutoff, this.cutoff);
+        cutoff = coerceFiniteNumber(cutoff, this.cutoff);
         cutoff = Math.max(this.minFrequency, cutoff);
 
         if (cutoff >= this.context.sampleRate)
             cutoff = this.context.sampleRate;
 
         this.cutoff = cutoff;
-        return SendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetCutoff, cutoff);
+        return sendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetCutoff, cutoff);
     }
 
-    public SetMinFrequency(minFrequency: number = 10): boolean {
+    public setMinFrequency(minFrequency: number = 10): boolean {
 
-        minFrequency = CoerceFiniteNumber(minFrequency, this.minFrequency);
+        minFrequency = coerceFiniteNumber(minFrequency, this.minFrequency);
 
         if (minFrequency < 10)
             minFrequency = 10;
 
         this.minFrequency = minFrequency;
-        return SendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetMinFrequency, minFrequency);
+        return sendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetMinFrequency, minFrequency);
     }
 
-    public SetQ(q: number = 0.7): boolean {
+    public setQ(q: number = 0.7): boolean {
 
-        q = CoerceFiniteNumber(q, this.q);
+        q = coerceFiniteNumber(q, this.q);
         q = Math.max(0.0001, q);
 
         if(q > 4) 
             q = 4;
 
         this.q = q;
-        return SendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetQ, q);
+        return sendMessageToWorklet<LowPassFilterMessageCommandId, number>(this.audioWorkletNode, LowPassFilterMessageCommandId.SetQ, q);
     }
 }

package/lib/src/effects/classes/filters/NotchFilter.ts

@@ -1,7 +1,7 @@
 import { AudioWorkletProcessorNames, NotchFilterMessageCommandId, NotchFilterOptions, StrictMode } from "../../../typings";
 import { Effector } from "../../../core/classes/Effector";
 import { DEFAULT_SAMPLE_RATE } from "../../../utilities/constants";
-import { CoerceFiniteNumber, CreateAudioWorkletNode, SendMessageToWorklet } from "../../../utilities/helpers";
+import { coerceFiniteNumber, createAudioWorkletNode, sendMessageToWorklet } from "../../../utilities/helpers";
 
 export default class NotchFilter extends Effector {
 
@@ -18,22 +18,22 @@ export default class NotchFilter extends Effector {
     constructor({ cutoff, q, minFrequency, strictMode }: Partial<NotchFilterOptions> = {}) {
         super();
 
-        this.cutoff = CoerceFiniteNumber(cutoff, this.cutoff);
-        this.q = CoerceFiniteNumber(q, this.q);
+        this.cutoff = coerceFiniteNumber(cutoff, this.cutoff);
+        this.q = coerceFiniteNumber(q, this.q);
 
-        const mode = CoerceFiniteNumber(strictMode, this.strictMode);
+        const mode = coerceFiniteNumber(strictMode, this.strictMode);
         this.strictMode = mode === StrictMode.Enabled ? StrictMode.Enabled : StrictMode.Disabled;
         this.audioWorkletNode && this.registerMessageEventListener(this.audioWorkletNode);
     }
 
-    public async InitializeOnAttachment(context: AudioContext): Promise<void> {
+    public async initializeOnAttachment(context: AudioContext): Promise<void> {
 
         this.context = context;
         this.contextSampleRate = context.sampleRate;
-        this.audioWorkletNode = CreateAudioWorkletNode(context, AudioWorkletProcessorNames.NotchFilter, this.ReturnOptionsAsObject());
+        this.audioWorkletNode = createAudioWorkletNode(context, AudioWorkletProcessorNames.NotchFilter, this.returnOptionsAsObject());
     }
 
-    public ReturnOptionsAsObject(): NotchFilterOptions {
+    public returnOptionsAsObject(): NotchFilterOptions {
         return {
             cutoff: this.cutoff,
             q: this.q,
@@ -42,40 +42,40 @@ export default class NotchFilter extends Effector {
         }
     }
 
-    public SetCutoff(cutoff: number = 1000): boolean {
+    public setCutoff(cutoff: number = 1000): boolean {
 
         if (!this.context) return false;
 
-        cutoff = CoerceFiniteNumber(cutoff, this.cutoff);
+        cutoff = coerceFiniteNumber(cutoff, this.cutoff);
         cutoff = Math.min(this.minFrequency, cutoff);
 
         if (cutoff >= this.context.sampleRate)
             cutoff = this.context.sampleRate;
 
         this.cutoff = cutoff;
-        return SendMessageToWorklet<NotchFilterMessageCommandId, number>(this.audioWorkletNode, NotchFilterMessageCommandId.SetCutoff, cutoff);
+        return sendMessageToWorklet<NotchFilterMessageCommandId, number>(this.audioWorkletNode, NotchFilterMessageCommandId.SetCutoff, cutoff);
     }
 
-    public SetMinFrequency(minFrequency: number = this.minFrequency) {
+    public setMinFrequency(minFrequency: number = this.minFrequency) {
 
-        minFrequency = CoerceFiniteNumber(minFrequency, this.minFrequency);
+        minFrequency = coerceFiniteNumber(minFrequency, this.minFrequency);
 
         if(minFrequency < 10) 
             minFrequency = 10;
 
         this.minFrequency = minFrequency;
-        return SendMessageToWorklet<NotchFilterMessageCommandId.SetMinFrequency, number>(this.audioWorkletNode, NotchFilterMessageCommandId.SetMinFrequency, minFrequency);
+        return sendMessageToWorklet<NotchFilterMessageCommandId.SetMinFrequency, number>(this.audioWorkletNode, NotchFilterMessageCommandId.SetMinFrequency, minFrequency);
     }
 
-    public SetQ(q: number = 0.7): boolean {
+    public setQ(q: number = 0.7): boolean {
 
-        q = CoerceFiniteNumber(q, this.q);
+        q = coerceFiniteNumber(q, this.q);
         q = Math.max(0.0001, q);
 
         if (q > 4)
             q = 4;
 
         this.q = q;
-        return SendMessageToWorklet<NotchFilterMessageCommandId, number>(this.audioWorkletNode, NotchFilterMessageCommandId.SetQ, q);
+        return sendMessageToWorklet<NotchFilterMessageCommandId, number>(this.audioWorkletNode, NotchFilterMessageCommandId.SetQ, q);
     }
 }

package/lib/src/effects/exports.ts

@@ -7,6 +7,7 @@ export { Saturation } from "./classes/Saturation";
 export { StereoPanner } from "./classes/StereoPanner";
 export { SoftClip } from "./classes/clips/SoftClip";
 export { HardClip } from "./classes/clips/HardClip";
+export { Reverb, type ReverbOptions } from "./classes/Reverb";
 
 export { Compressor } from "./classes/compressors/Compressor";
 export { MultibandCompressor } from "./classes/compressors/MultibandCompressor";
@@ -16,11 +17,5 @@ export { MonoDelay } from "./classes/delays/MonoDelay";
 export { PingPongDelay } from "./classes/delays/PingPongDelay";
 export { StereoDelay } from "./classes/delays/StereoDelay";
 
-export { ChamberReverb } from "./classes/reverbs/ChamberReverb";
-export { ConvolverReverb } from "./classes/reverbs/ConvolverReverb";
-export { GenericReverb } from "./classes/reverbs/GenericReverb";
-export { HallReverb } from "./classes/reverbs/HallReverb";
-export { RoomReverb } from "./classes/reverbs/RoomReverb";
-
 export { LowPassFilter } from "./classes/filters/LowPassFilter";
 export { HighPassFilter } from "./classes/filters/HighPassFilter";