react-native-audio-api 0.12.0-nightly-0d1a19d-20260120 → 0.12.0-nightly-6993a06-20260122

package/src/api.ts

@@ -29,7 +29,7 @@ export { default as WorkletProcessingNode } from './core/WorkletProcessingNode';
 export { default as WorkletSourceNode } from './core/WorkletSourceNode';
 
 export { default as useSystemVolume } from './hooks/useSystemVolume';
-export { default as AudioManager } from './system';
+export { default as PeriodicWave } from './core/PeriodicWave';
 
 export * from './errors';
 export * from './system/types';
@@ -40,6 +40,8 @@ export { default as FilePreset } from './utils/filePresets';
 export { PlaybackNotificationManager } from './system/notification';
 export { RecordingNotificationManager } from './system/notification';
 
+export { default as AudioManager } from './system';
+
 export {
   NotificationManager,
   PlaybackControlName,

package/src/api.web.ts

@@ -15,18 +15,17 @@ export { default as OscillatorNode } from './web-core/OscillatorNode';
 export { default as StereoPannerNode } from './web-core/StereoPannerNode';
 export { default as ConstantSourceNode } from './web-core/ConstantSourceNode';
 export { default as ConvolverNode } from './web-core/ConvolverNode';
+export { default as PeriodicWave } from './web-core/PeriodicWave';
 export { default as WaveShaperNode } from './web-core/WaveShaperNode';
 
 export * from './web-core/custom';
 
 export {
   OscillatorType,
-  BiquadFilterType,
   ChannelCountMode,
   ChannelInterpretation,
   ContextState,
   WindowType,
-  PeriodicWaveConstraints,
 } from './types';
 
 export {

package/src/core/AnalyserNode.ts

@@ -1,13 +1,28 @@
+import BaseAudioContext from './BaseAudioContext';
+import { AnalyserOptions } from '../defaults';
 import { IndexSizeError } from '../errors';
 import { IAnalyserNode } from '../interfaces';
-import { WindowType } from '../types';
+import { WindowType, TAnalyserOptions } from '../types';
 import AudioNode from './AudioNode';
+import { AnalyserOptionsValidator } from '../options-validators';
 
 export default class AnalyserNode extends AudioNode {
   private static allowedFFTSize: number[] = [
     32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768,
   ];
 
+  constructor(context: BaseAudioContext, options?: TAnalyserOptions) {
+    const finalOptions: TAnalyserOptions = {
+      ...AnalyserOptions,
+      ...options,
+    };
+
+    AnalyserOptionsValidator.validate(finalOptions);
+    const analyserNode: IAnalyserNode =
+      context.context.createAnalyser(finalOptions);
+    super(context, analyserNode);
+  }
+
   public get fftSize(): number {
     return (this.node as IAnalyserNode).fftSize;
   }

package/src/core/AudioBuffer.ts

@@ -1,5 +1,8 @@
 import { IAudioBuffer } from '../interfaces';
 import { IndexSizeError } from '../errors';
+import BaseAudioContext from './BaseAudioContext';
+import { TAudioBufferOptions } from '../types';
+import { AudioBufferOptions } from '../defaults';
 
 export default class AudioBuffer {
   readonly length: number;
@@ -9,12 +12,29 @@ export default class AudioBuffer {
   /** @internal */
   public readonly buffer: IAudioBuffer;
 
-  constructor(buffer: IAudioBuffer) {
-    this.buffer = buffer;
-    this.length = buffer.length;
-    this.duration = buffer.duration;
-    this.sampleRate = buffer.sampleRate;
-    this.numberOfChannels = buffer.numberOfChannels;
+  constructor(buffer: IAudioBuffer);
+  constructor(context: BaseAudioContext, options: TAudioBufferOptions);
+
+  constructor(
+    contextOrBuffer: BaseAudioContext | IAudioBuffer,
+    options?: TAudioBufferOptions
+  ) {
+    let buf: IAudioBuffer;
+    if (contextOrBuffer instanceof BaseAudioContext) {
+      const finalOptions = {
+        ...AudioBufferOptions,
+        ...options,
+      };
+      const context = contextOrBuffer;
+      buf = context.context.createBuffer(finalOptions);
+    } else {
+      buf = contextOrBuffer;
+    }
+    this.buffer = buf;
+    this.length = buf.length;
+    this.duration = buf.duration;
+    this.sampleRate = buf.sampleRate;
+    this.numberOfChannels = buf.numberOfChannels;
   }
 
   public getChannelData(channel: number): Float32Array {

package/src/core/AudioBufferQueueSourceNode.ts

@@ -2,8 +2,28 @@ import { IAudioBufferQueueSourceNode } from '../interfaces';
 import AudioBufferBaseSourceNode from './AudioBufferBaseSourceNode';
 import AudioBuffer from './AudioBuffer';
 import { RangeError } from '../errors';
+import BaseAudioContext from './BaseAudioContext';
+import { TBaseAudioBufferSourceOptions } from '../types';
+import { BaseAudioBufferSourceOptions } from '../defaults';
+import { AudioEventSubscription } from '../events';
+import { OnBufferEndEventType } from '../events/types';
 
 export default class AudioBufferQueueSourceNode extends AudioBufferBaseSourceNode {
+  private onBufferEndedSubscription?: AudioEventSubscription;
+  private onBufferEndedCallback?: (event: OnBufferEndEventType) => void;
+
+  constructor(
+    context: BaseAudioContext,
+    options?: TBaseAudioBufferSourceOptions
+  ) {
+    const finalOptions: TBaseAudioBufferSourceOptions = {
+      ...BaseAudioBufferSourceOptions,
+      ...options,
+    };
+    const node = context.context.createBufferQueueSource(finalOptions);
+    super(context, node);
+  }
+
   public enqueueBuffer(buffer: AudioBuffer): string {
     return (this.node as IAudioBufferQueueSourceNode).enqueueBuffer(
       buffer.buffer
@@ -50,6 +70,32 @@ export default class AudioBufferQueueSourceNode extends AudioBufferBaseSourceNod
     (this.node as IAudioBufferQueueSourceNode).stop(when);
   }
 
+  public get onBufferEnded():
+    | ((event: OnBufferEndEventType) => void)
+    | undefined {
+    return this.onBufferEndedCallback;
+  }
+
+  public set onBufferEnded(
+    callback: ((event: OnBufferEndEventType) => void) | null
+  ) {
+    if (!callback) {
+      (this.node as IAudioBufferQueueSourceNode).onBufferEnded = '0';
+      this.onBufferEndedSubscription?.remove();
+      this.onBufferEndedSubscription = undefined;
+      this.onBufferEndedCallback = undefined;
+
+      return;
+    }
+
+    this.onBufferEndedCallback = callback;
+    this.onBufferEndedSubscription =
+      this.audioEventEmitter.addAudioEventListener('bufferEnded', callback);
+
+    (this.node as IAudioBufferQueueSourceNode).onBufferEnded =
+      this.onBufferEndedSubscription.subscriptionId;
+  }
+
   public pause(): void {
     (this.node as IAudioBufferQueueSourceNode).pause();
   }

package/src/core/AudioBufferSourceNode.ts

@@ -4,11 +4,23 @@ import AudioBuffer from './AudioBuffer';
 import { InvalidStateError, RangeError } from '../errors';
 import { EventEmptyType } from '../events/types';
 import { AudioEventSubscription } from '../events';
+import { TAudioBufferSourceOptions } from '../types';
+import BaseAudioContext from './BaseAudioContext';
+import { AudioBufferSourceOptions } from '../defaults';
 
 export default class AudioBufferSourceNode extends AudioBufferBaseSourceNode {
   private onLoopEndedSubscription?: AudioEventSubscription;
   private onLoopEndedCallback?: (event: EventEmptyType) => void;
 
+  constructor(context: BaseAudioContext, options?: TAudioBufferSourceOptions) {
+    const finalOptions: TAudioBufferSourceOptions = {
+      ...AudioBufferSourceOptions,
+      ...options,
+    };
+    const node = context.context.createBufferSource(finalOptions);
+    super(context, node);
+  }
+
   public get buffer(): AudioBuffer | null {
     const buffer = (this.node as IAudioBufferSourceNode).buffer;
     if (!buffer) {
@@ -85,16 +97,6 @@ export default class AudioBufferSourceNode extends AudioBufferBaseSourceNode {
     (this.node as IAudioBufferSourceNode).start(when, offset, duration);
   }
 
-  public override get onEnded(): ((event: EventEmptyType) => void) | undefined {
-    return super.onEnded as ((event: EventEmptyType) => void) | undefined;
-  }
-
-  public override set onEnded(
-    callback: ((event: EventEmptyType) => void) | null
-  ) {
-    super.onEnded = callback;
-  }
-
   public get onLoopEnded(): ((event: EventEmptyType) => void) | undefined {
     return this.onLoopEndedCallback;
   }

package/src/core/AudioScheduledSourceNode.ts

@@ -1,7 +1,7 @@
 import { IAudioScheduledSourceNode } from '../interfaces';
 import AudioNode from './AudioNode';
 import { InvalidStateError, RangeError } from '../errors';
-import { OnEndedEventType } from '../events/types';
+import { EventEmptyType } from '../events/types';
 import { AudioEventEmitter, AudioEventSubscription } from '../events';
 
 export default class AudioScheduledSourceNode extends AudioNode {
@@ -11,7 +11,7 @@ export default class AudioScheduledSourceNode extends AudioNode {
   );
 
   private onEndedSubscription?: AudioEventSubscription;
-  private onEndedCallback?: (event: OnEndedEventType) => void;
+  private onEndedCallback?: (event: EventEmptyType) => void;
 
   public start(when: number = 0): void {
     if (when < 0) {
@@ -44,11 +44,11 @@ export default class AudioScheduledSourceNode extends AudioNode {
     (this.node as IAudioScheduledSourceNode).stop(when);
   }
 
-  public get onEnded(): ((event: OnEndedEventType) => void) | undefined {
+  public get onEnded(): ((event: EventEmptyType) => void) | undefined {
     return this.onEndedCallback;
   }
 
-  public set onEnded(callback: ((event: OnEndedEventType) => void) | null) {
+  public set onEnded(callback: ((event: EventEmptyType) => void) | null) {
     if (!callback) {
       (this.node as IAudioScheduledSourceNode).onEnded = '0';
       this.onEndedSubscription?.remove();

package/src/core/BaseAudioContext.ts

@@ -1,19 +1,10 @@
-import AudioAPIModule from '../AudioAPIModule';
 import {
   InvalidAccessError,
   InvalidStateError,
   NotSupportedError,
 } from '../errors';
 import { IBaseAudioContext } from '../interfaces';
-import {
-  AudioBufferBaseSourceNodeOptions,
-  AudioWorkletRuntime,
-  ContextState,
-  ConvolverNodeOptions,
-  DecodeDataInput,
-  IIRFilterNodeOptions,
-  PeriodicWaveConstraints,
-} from '../types';
+import { AudioWorkletRuntime, ContextState, DecodeDataInput } from '../types';
 import { assertWorkletsEnabled } from '../utils';
 import AnalyserNode from './AnalyserNode';
 import AudioBuffer from './AudioBuffer';
@@ -96,26 +87,12 @@ export default class BaseAudioContext {
     }
 
     assertWorkletsEnabled();
-
-    const shareableWorklet =
-      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
-        (audioBuffers: Array<ArrayBuffer>, channelCount: number) => {
-          'worklet';
-          const floatAudioData: Array<Float32Array> = audioBuffers.map(
-            (buffer) => new Float32Array(buffer)
-          );
-          callback(floatAudioData, channelCount);
-        }
-      );
-
     return new WorkletNode(
       this,
-      this.context.createWorkletNode(
-        shareableWorklet,
-        workletRuntime === 'UIRuntime',
-        bufferLength,
-        inputChannelCount
-      )
+      workletRuntime,
+      callback,
+      bufferLength,
+      inputChannelCount
     );
   }
 
@@ -129,33 +106,7 @@ export default class BaseAudioContext {
     workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
   ): WorkletProcessingNode {
     assertWorkletsEnabled();
-
-    const shareableWorklet =
-      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
-        (
-          inputBuffers: Array<ArrayBuffer>,
-          outputBuffers: Array<ArrayBuffer>,
-          framesToProcess: number,
-          currentTime: number
-        ) => {
-          'worklet';
-          const inputData: Array<Float32Array> = inputBuffers.map(
-            (buffer) => new Float32Array(buffer, 0, framesToProcess)
-          );
-          const outputData: Array<Float32Array> = outputBuffers.map(
-            (buffer) => new Float32Array(buffer, 0, framesToProcess)
-          );
-          callback(inputData, outputData, framesToProcess, currentTime);
-        }
-      );
-
-    return new WorkletProcessingNode(
-      this,
-      this.context.createWorkletProcessingNode(
-        shareableWorklet,
-        workletRuntime === 'UIRuntime'
-      )
-    );
+    return new WorkletProcessingNode(this, workletRuntime, callback);
   }
 
   createWorkletSourceNode(
@@ -168,71 +119,56 @@ export default class BaseAudioContext {
     workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
   ): WorkletSourceNode {
     assertWorkletsEnabled();
-    const shareableWorklet =
-      AudioAPIModule.workletsModule!.makeShareableCloneRecursive(
-        (
-          audioBuffers: Array<ArrayBuffer>,
-          framesToProcess: number,
-          currentTime: number,
-          startOffset: number
-        ) => {
-          'worklet';
-          const floatAudioData: Array<Float32Array> = audioBuffers.map(
-            (buffer) => new Float32Array(buffer)
-          );
-          callback(floatAudioData, framesToProcess, currentTime, startOffset);
-        }
-      );
-
-    return new WorkletSourceNode(
-      this,
-      this.context.createWorkletSourceNode(
-        shareableWorklet,
-        workletRuntime === 'UIRuntime'
-      )
-    );
+    return new WorkletSourceNode(this, workletRuntime, callback);
   }
 
   createRecorderAdapter(): RecorderAdapterNode {
-    return new RecorderAdapterNode(this, this.context.createRecorderAdapter());
+    return new RecorderAdapterNode(this);
   }
 
   createOscillator(): OscillatorNode {
-    return new OscillatorNode(this, this.context.createOscillator());
+    return new OscillatorNode(this);
   }
 
   createStreamer(): StreamerNode {
-    const streamer = this.context.createStreamer();
-    if (!streamer) {
-      throw new NotSupportedError('StreamerNode requires FFmpeg build');
-    }
-    return new StreamerNode(this, streamer);
+    return new StreamerNode(this);
   }
 
   createConstantSource(): ConstantSourceNode {
-    return new ConstantSourceNode(this, this.context.createConstantSource());
+    return new ConstantSourceNode(this);
   }
 
   createGain(): GainNode {
-    return new GainNode(this, this.context.createGain());
+    return new GainNode(this);
   }
 
   createDelay(maxDelayTime?: number): DelayNode {
-    const maxTime = maxDelayTime ?? 1.0;
-    return new DelayNode(this, this.context.createDelay(maxTime));
+    if (maxDelayTime !== undefined) {
+      return new DelayNode(this, { maxDelayTime });
+    } else {
+      return new DelayNode(this);
+    }
   }
 
   createStereoPanner(): StereoPannerNode {
-    return new StereoPannerNode(this, this.context.createStereoPanner());
+    return new StereoPannerNode(this);
   }
 
   createBiquadFilter(): BiquadFilterNode {
-    return new BiquadFilterNode(this, this.context.createBiquadFilter());
+    return new BiquadFilterNode(this);
+  }
+
+  createBufferSource(options?: {
+    pitchCorrection: boolean;
+  }): AudioBufferSourceNode {
+    if (options !== undefined) {
+      return new AudioBufferSourceNode(this, options);
+    } else {
+      return new AudioBufferSourceNode(this);
+    }
   }
 
-  createIIRFilter(options: IIRFilterNodeOptions): IIRFilterNode {
-    const feedforward = options.feedforward;
-    const feedback = options.feedback;
+  createIIRFilter(feedforward: number[], feedback: number[]): IIRFilterNode {
     if (feedforward.length < 1 || feedforward.length > 20) {
       throw new NotSupportedError(
         `The provided feedforward array has length (${feedforward.length}) outside the range [1, 20]`
@@ -256,42 +192,27 @@ export default class BaseAudioContext {
       );
     }
 
-    return new IIRFilterNode(
-      this,
-      this.context.createIIRFilter(feedforward, feedback)
-    );
+    return new IIRFilterNode(this, { feedforward, feedback });
   }
 
-  createBufferSource(
-    options?: AudioBufferBaseSourceNodeOptions
-  ): AudioBufferSourceNode {
-    const pitchCorrection = options?.pitchCorrection ?? false;
-
-    return new AudioBufferSourceNode(
-      this,
-      this.context.createBufferSource(pitchCorrection)
-    );
-  }
-
-  createBufferQueueSource(
-    options?: AudioBufferBaseSourceNodeOptions
-  ): AudioBufferQueueSourceNode {
-    const pitchCorrection = options?.pitchCorrection ?? false;
-
-    return new AudioBufferQueueSourceNode(
-      this,
-      this.context.createBufferQueueSource(pitchCorrection)
-    );
+  createBufferQueueSource(options?: {
+    pitchCorrection: boolean;
+  }): AudioBufferQueueSourceNode {
+    if (options !== undefined) {
+      return new AudioBufferQueueSourceNode(this, options);
+    } else {
+      return new AudioBufferQueueSourceNode(this);
+    }
   }
 
   createBuffer(
-    numOfChannels: number,
+    numberOfChannels: number,
     length: number,
     sampleRate: number
   ): AudioBuffer {
-    if (numOfChannels < 1 || numOfChannels >= 32) {
+    if (numberOfChannels < 1 || numberOfChannels >= 32) {
       throw new NotSupportedError(
-        `The number of channels provided (${numOfChannels}) is outside the range [1, 32]`
+        `The number of channels provided (${numberOfChannels}) is outside the range [1, 32]`
       );
     }
 
@@ -307,9 +228,7 @@ export default class BaseAudioContext {
       );
     }
 
-    return new AudioBuffer(
-      this.context.createBuffer(numOfChannels, length, sampleRate)
-    );
+    return new AudioBuffer(this, { numberOfChannels, length, sampleRate });
   }
 
   createPeriodicWave(
@@ -322,40 +241,18 @@ export default class BaseAudioContext {
         `The lengths of the real (${real.length}) and imaginary (${imag.length}) arrays must match.`
       );
     }
-
-    const disableNormalization = constraints?.disableNormalization ?? false;
-
-    return new PeriodicWave(
-      this.context.createPeriodicWave(real, imag, disableNormalization)
-    );
+    return new PeriodicWave(this, { real, imag, ...constraints });
   }
 
   createAnalyser(): AnalyserNode {
-    return new AnalyserNode(this, this.context.createAnalyser());
+    return new AnalyserNode(this);
   }
 
-  createConvolver(options?: ConvolverNodeOptions): ConvolverNode {
-    if (options?.buffer) {
-      const numberOfChannels = options.buffer.numberOfChannels;
-      if (
-        numberOfChannels !== 1 &&
-        numberOfChannels !== 2 &&
-        numberOfChannels !== 4
-      ) {
-        throw new NotSupportedError(
-          `The number of channels provided (${numberOfChannels}) in impulse response for ConvolverNode buffer must be 1 or 2 or 4.`
-        );
-      }
-    }
-    const buffer = options?.buffer ?? null;
-    const disableNormalization = options?.disableNormalization ?? false;
-    return new ConvolverNode(
-      this,
-      this.context.createConvolver(buffer?.buffer, disableNormalization)
-    );
+  createConvolver(): ConvolverNode {
+    return new ConvolverNode(this);
   }
 
   createWaveShaper(): WaveShaperNode {
-    return new WaveShaperNode(this, this.context.createWaveShaper());
+    return new WaveShaperNode(this);
   }
 }

package/src/core/BiquadFilterNode.ts

@@ -3,7 +3,8 @@ import { IBiquadFilterNode } from '../interfaces';
 import AudioNode from './AudioNode';
 import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
-import { BiquadFilterType } from '../types';
+import { BiquadFilterOptions } from '../defaults';
+import { TBiquadFilterOptions } from '../types';
 
 export default class BiquadFilterNode extends AudioNode {
   readonly frequency: AudioParam;
@@ -11,7 +12,13 @@ export default class BiquadFilterNode extends AudioNode {
   readonly Q: AudioParam;
   readonly gain: AudioParam;
 
-  constructor(context: BaseAudioContext, biquadFilter: IBiquadFilterNode) {
+  constructor(context: BaseAudioContext, options?: TBiquadFilterOptions) {
+    const finalOptions: TBiquadFilterOptions = {
+      ...BiquadFilterOptions,
+      ...options,
+    };
+    const biquadFilter: IBiquadFilterNode =
+      context.context.createBiquadFilter(finalOptions);
     super(context, biquadFilter);
     this.frequency = new AudioParam(biquadFilter.frequency, context);
     this.detune = new AudioParam(biquadFilter.detune, context);

package/src/core/ConstantSourceNode.ts

@@ -1,4 +1,6 @@
 import { IConstantSourceNode } from '../interfaces';
+import { ConstantSourceOptions } from '../defaults';
+import { TConstantSourceOptions } from '../types';
 import AudioParam from './AudioParam';
 import AudioScheduledSourceNode from './AudioScheduledSourceNode';
 import BaseAudioContext from './BaseAudioContext';
@@ -6,7 +8,13 @@ import BaseAudioContext from './BaseAudioContext';
 export default class ConstantSourceNode extends AudioScheduledSourceNode {
   readonly offset: AudioParam;
 
-  constructor(context: BaseAudioContext, node: IConstantSourceNode) {
+  constructor(context: BaseAudioContext, options?: TConstantSourceOptions) {
+    const finalOptions: TConstantSourceOptions = {
+      ...ConstantSourceOptions,
+      ...options,
+    };
+    const node: IConstantSourceNode =
+      context.context.createConstantSource(finalOptions);
     super(context, node);
     this.offset = new AudioParam(node.offset, context);
   }

package/src/core/ConvolverNode.ts

@@ -1,12 +1,20 @@
 import { IConvolverNode } from '../interfaces';
+import { ConvolverOptions } from '../defaults';
+import { TConvolverOptions } from '../types';
 import BaseAudioContext from './BaseAudioContext';
 import AudioNode from './AudioNode';
 import AudioBuffer from './AudioBuffer';
 
 export default class ConvolverNode extends AudioNode {
-  constructor(context: BaseAudioContext, node: IConvolverNode) {
-    super(context, node);
-    this.normalize = node.normalize;
+  constructor(context: BaseAudioContext, options?: TConvolverOptions) {
+    const finalOptions: TConvolverOptions = {
+      ...ConvolverOptions,
+      ...options,
+    };
+    const convolverNode: IConvolverNode =
+      context.context.createConvolver(finalOptions);
+    super(context, convolverNode);
+    this.normalize = convolverNode.normalize;
   }
 
   public get buffer(): AudioBuffer | null {

package/src/core/DelayNode.ts

@@ -1,12 +1,15 @@
-import { IDelayNode } from '../interfaces';
 import AudioNode from './AudioNode';
 import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
+import { TDelayOptions } from '../types';
+import { DelayOptions } from '../defaults';
 
 export default class DelayNode extends AudioNode {
   readonly delayTime: AudioParam;
 
-  constructor(context: BaseAudioContext, delay: IDelayNode) {
+  constructor(context: BaseAudioContext, options?: TDelayOptions) {
+    const finalOptions = { ...DelayOptions, ...options };
+    const delay = context.context.createDelay(finalOptions);
     super(context, delay);
     this.delayTime = new AudioParam(delay.delayTime, context);
   }

package/src/core/GainNode.ts

@@ -1,4 +1,6 @@
 import { IGainNode } from '../interfaces';
+import { GainOptions } from '../defaults';
+import { TGainOptions } from '../types';
 import AudioNode from './AudioNode';
 import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
@@ -6,8 +8,13 @@ import BaseAudioContext from './BaseAudioContext';
 export default class GainNode extends AudioNode {
   readonly gain: AudioParam;
 
-  constructor(context: BaseAudioContext, gain: IGainNode) {
-    super(context, gain);
-    this.gain = new AudioParam(gain.gain, context);
+  constructor(context: BaseAudioContext, options?: TGainOptions) {
+    const finalOptions: TGainOptions = {
+      ...GainOptions,
+      ...options,
+    };
+    const gainNode: IGainNode = context.context.createGain(finalOptions);
+    super(context, gainNode);
+    this.gain = new AudioParam(gainNode.gain, context);
   }
 }

package/src/core/IIRFilterNode.ts

@@ -1,8 +1,20 @@
 import { NotSupportedError } from '../errors';
 import { IIIRFilterNode } from '../interfaces';
 import AudioNode from './AudioNode';
+import { TIIRFilterOptions } from '../types';
+import { AudioNodeOptions } from '../defaults';
+import BaseAudioContext from './BaseAudioContext';
 
 export default class IIRFilterNode extends AudioNode {
+  constructor(context: BaseAudioContext, options: TIIRFilterOptions) {
+    const finalOptions: TIIRFilterOptions = {
+      ...AudioNodeOptions,
+      ...options,
+    };
+    const iirFilterNode = context.context.createIIRFilter(finalOptions);
+    super(context, iirFilterNode);
+  }
+
   public getFrequencyResponse(
     frequencyArray: Float32Array,
     magResponseOutput: Float32Array,