react-native-audio-api 0.8.3 → 0.9.0-nightly-96a5bcd-20251007

package/src/core/BaseAudioContext.ts

@@ -1,22 +1,29 @@
+import { InvalidAccessError, NotSupportedError } from '../errors';
 import { IBaseAudioContext } from '../interfaces';
 import {
+  AudioBufferBaseSourceNodeOptions,
   ContextState,
   PeriodicWaveConstraints,
-  AudioBufferSourceNodeOptions,
+  AudioWorkletRuntime,
 } from '../types';
+import { isWorkletsAvailable, workletsModule } from '../utils';
+import WorkletSourceNode from './WorkletSourceNode';
+import WorkletProcessingNode from './WorkletProcessingNode';
+import AnalyserNode from './AnalyserNode';
+import AudioBuffer from './AudioBuffer';
+import AudioBufferQueueSourceNode from './AudioBufferQueueSourceNode';
+import AudioBufferSourceNode from './AudioBufferSourceNode';
 import AudioDestinationNode from './AudioDestinationNode';
-import OscillatorNode from './OscillatorNode';
-import GainNode from './GainNode';
-import StereoPannerNode from './StereoPannerNode';
 import BiquadFilterNode from './BiquadFilterNode';
-import AudioBufferSourceNode from './AudioBufferSourceNode';
-import AudioBuffer from './AudioBuffer';
+import ConstantSourceNode from './ConstantSourceNode';
+import GainNode from './GainNode';
+import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
-import AnalyserNode from './AnalyserNode';
-import AudioBufferQueueSourceNode from './AudioBufferQueueSourceNode';
-import StreamerNode from './StreamerNode';
-import { InvalidAccessError, NotSupportedError } from '../errors';
 import RecorderAdapterNode from './RecorderAdapterNode';
+import StereoPannerNode from './StereoPannerNode';
+import StreamerNode from './StreamerNode';
+import WorkletNode from './WorkletNode';
+import { decodeAudioData, decodePCMInBase64 } from './AudioDecoder';
 
 export default class BaseAudioContext {
   readonly destination: AudioDestinationNode;
@@ -37,6 +44,152 @@ export default class BaseAudioContext {
     return this.context.state;
   }
 
+  public async decodeAudioData(
+    input: string | ArrayBuffer,
+    sampleRate?: number
+  ): Promise<AudioBuffer> {
+    if (!(typeof input === 'string' || input instanceof ArrayBuffer)) {
+      throw new TypeError('Input must be a string or ArrayBuffer');
+    }
+    return await decodeAudioData(input, sampleRate ?? this.sampleRate);
+  }
+
+  public async decodePCMInBase64(
+    base64String: string,
+    inputSampleRate: number,
+    inputChannelCount: number,
+    isInterleaved: boolean = true
+  ): Promise<AudioBuffer> {
+    return await decodePCMInBase64(
+      base64String,
+      inputSampleRate,
+      inputChannelCount,
+      isInterleaved
+    );
+  }
+
+  createWorkletNode(
+    callback: (audioData: Array<Float32Array>, channelCount: number) => void,
+    bufferLength: number,
+    inputChannelCount: number,
+    workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
+  ): WorkletNode {
+    if (inputChannelCount < 1 || inputChannelCount > 32) {
+      throw new NotSupportedError(
+        `The number of input channels provided (${inputChannelCount}) can not be less than 1 or greater than 32`
+      );
+    }
+    if (bufferLength < 1) {
+      throw new NotSupportedError(
+        `The buffer length provided (${bufferLength}) can not be less than 1`
+      );
+    }
+
+    if (isWorkletsAvailable) {
+      const shareableWorklet = 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
+        )
+      );
+    }
+    /// User does not have worklets as a dependency so he cannot use the worklet API.
+    throw new Error(
+      '[RnAudioApi] Worklets are not available, please install react-native-worklets as a dependency. Refer to documentation for more details.'
+    );
+  }
+
+  createWorkletProcessingNode(
+    callback: (
+      inputData: Array<Float32Array>,
+      outputData: Array<Float32Array>,
+      framesToProcess: number,
+      currentTime: number
+    ) => void,
+    workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
+  ): WorkletProcessingNode {
+    if (isWorkletsAvailable) {
+      const shareableWorklet = 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'
+        )
+      );
+    }
+    /// User does not have worklets as a dependency so he cannot use the worklet API.
+    throw new Error(
+      '[RnAudioApi] Worklets are not available, please install react-native-worklets as a dependency. Refer to documentation for more details.'
+    );
+  }
+
+  createWorkletSourceNode(
+    callback: (
+      audioData: Array<Float32Array>,
+      framesToProcess: number,
+      currentTime: number,
+      startOffset: number
+    ) => void,
+    workletRuntime: AudioWorkletRuntime = 'AudioRuntime'
+  ): WorkletSourceNode {
+    if (!isWorkletsAvailable) {
+      /// User does not have worklets as a dependency so he cannot use the worklet API.
+      throw new Error(
+        '[RnAudioApi] Worklets are not available, please install react-native-worklets as a dependency. Refer to documentation for more details.'
+      );
+    }
+    const shareableWorklet = 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'
+      )
+    );
+  }
+
   createRecorderAdapter(): RecorderAdapterNode {
     return new RecorderAdapterNode(this, this.context.createRecorderAdapter());
   }
@@ -49,6 +202,10 @@ export default class BaseAudioContext {
     return new StreamerNode(this, this.context.createStreamer());
   }
 
+  createConstantSource(): ConstantSourceNode {
+    return new ConstantSourceNode(this, this.context.createConstantSource());
+  }
+
   createGain(): GainNode {
     return new GainNode(this, this.context.createGain());
   }
@@ -62,7 +219,7 @@ export default class BaseAudioContext {
   }
 
   createBufferSource(
-    options?: AudioBufferSourceNodeOptions
+    options?: AudioBufferBaseSourceNodeOptions
   ): AudioBufferSourceNode {
     const pitchCorrection = options?.pitchCorrection ?? false;
 
@@ -72,10 +229,14 @@ export default class BaseAudioContext {
     );
   }
 
-  createBufferQueueSource(): AudioBufferQueueSourceNode {
+  createBufferQueueSource(
+    options?: AudioBufferBaseSourceNodeOptions
+  ): AudioBufferQueueSourceNode {
+    const pitchCorrection = options?.pitchCorrection ?? false;
+
     return new AudioBufferQueueSourceNode(
       this,
-      this.context.createBufferQueueSource()
+      this.context.createBufferQueueSource(pitchCorrection)
     );
   }
 
@@ -128,32 +289,4 @@ export default class BaseAudioContext {
   createAnalyser(): AnalyserNode {
     return new AnalyserNode(this, this.context.createAnalyser());
   }
-
-  /** Decodes audio data from a local file path. */
-  async decodeAudioDataSource(sourcePath: string): Promise<AudioBuffer> {
-    // Remove the file:// prefix if it exists
-    if (sourcePath.startsWith('file://')) {
-      sourcePath = sourcePath.replace('file://', '');
-    }
-
-    return new AudioBuffer(
-      await this.context.decodeAudioDataSource(sourcePath)
-    );
-  }
-
-  /** Decodes audio data from an ArrayBuffer. */
-  async decodeAudioData(data: ArrayBuffer): Promise<AudioBuffer> {
-    return new AudioBuffer(
-      await this.context.decodeAudioData(new Uint8Array(data))
-    );
-  }
-
-  async decodePCMInBase64Data(
-    base64: string,
-    playbackRate: number = 1.0
-  ): Promise<AudioBuffer> {
-    return new AudioBuffer(
-      await this.context.decodePCMAudioDataInBase64(base64, playbackRate)
-    );
-  }
 }

package/src/core/ConstantSourceNode.ts

@@ -0,0 +1,13 @@
+import { IConstantSourceNode } from '../interfaces';
+import AudioParam from './AudioParam';
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class ConstantSourceNode extends AudioScheduledSourceNode {
+  readonly offset: AudioParam;
+
+  constructor(context: BaseAudioContext, node: IConstantSourceNode) {
+    super(context, node);
+    this.offset = new AudioParam(node.offset, context);
+  }
+}

package/src/core/OfflineAudioContext.ts

@@ -3,12 +3,17 @@ import BaseAudioContext from './BaseAudioContext';
 import { OfflineAudioContextOptions } from '../types';
 import { InvalidStateError, NotSupportedError } from '../errors';
 import AudioBuffer from './AudioBuffer';
+import { isWorkletsAvailable, workletsModule } from '../utils';
 
 export default class OfflineAudioContext extends BaseAudioContext {
   private isSuspended: boolean;
   private isRendering: boolean;
   private duration: number;
 
+  // We need to keep here a reference to this runtime to better manage its lifecycle
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  private _audioRuntime: any;
+
   constructor(options: OfflineAudioContextOptions);
   constructor(numberOfChannels: number, length: number, sampleRate: number);
   constructor(
@@ -16,10 +21,20 @@ export default class OfflineAudioContext extends BaseAudioContext {
     arg1?: number,
     arg2?: number
   ) {
+    let audioRuntime = null;
+    if (isWorkletsAvailable) {
+      audioRuntime = workletsModule.createWorkletRuntime('AudioWorkletRuntime');
+    }
+
     if (typeof arg0 === 'object') {
       const { numberOfChannels, length, sampleRate } = arg0;
       super(
-        global.createOfflineAudioContext(numberOfChannels, length, sampleRate)
+        global.createOfflineAudioContext(
+          numberOfChannels,
+          length,
+          sampleRate,
+          audioRuntime
+        )
       );
 
       this.duration = length / sampleRate;
@@ -28,7 +43,7 @@ export default class OfflineAudioContext extends BaseAudioContext {
       typeof arg1 === 'number' &&
       typeof arg2 === 'number'
     ) {
-      super(global.createOfflineAudioContext(arg0, arg1, arg2));
+      super(global.createOfflineAudioContext(arg0, arg1, arg2, audioRuntime));
       this.duration = arg1 / arg2;
     } else {
       throw new NotSupportedError('Invalid constructor arguments');
@@ -36,6 +51,7 @@ export default class OfflineAudioContext extends BaseAudioContext {
 
     this.isSuspended = false;
     this.isRendering = false;
+    this._audioRuntime = audioRuntime;
   }
 
   async resume(): Promise<undefined> {

package/src/core/OscillatorNode.ts

@@ -5,6 +5,7 @@ import AudioParam from './AudioParam';
 import BaseAudioContext from './BaseAudioContext';
 import PeriodicWave from './PeriodicWave';
 import { InvalidStateError } from '../errors';
+import { EventEmptyType } from '../events/types';
 
 export default class OscillatorNode extends AudioScheduledSourceNode {
   readonly frequency: AudioParam;
@@ -34,4 +35,14 @@ export default class OscillatorNode extends AudioScheduledSourceNode {
   public setPeriodicWave(wave: PeriodicWave): void {
     (this.node as IOscillatorNode).setPeriodicWave(wave.periodicWave);
   }
+
+  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;
+  }
 }

package/src/core/WorkletNode.ts

@@ -0,0 +1,3 @@
+import AudioNode from './AudioNode';
+
+export default class WorkletNode extends AudioNode {}

package/src/core/WorkletProcessingNode.ts

@@ -0,0 +1,3 @@
+import AudioNode from './AudioNode';
+
+export default class WorkletProcessingNode extends AudioNode {}

package/src/core/WorkletSourceNode.ts

@@ -0,0 +1,3 @@
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+
+export default class WorkletSourceNode extends AudioScheduledSourceNode {}

package/src/events/types.ts

@@ -46,6 +46,7 @@ type SystemEvents = RemoteCommandEvents & {
 
 export interface OnEndedEventType extends EventEmptyType {
   bufferId: string | undefined;
+  isLast: boolean | undefined;
 }
 
 export interface OnAudioReadyEventType {
@@ -56,6 +57,7 @@ export interface OnAudioReadyEventType {
 
 interface AudioAPIEvents {
   ended: OnEndedEventType;
+  loopEnded: EventEmptyType;
   audioReady: OnAudioReadyEventType;
   positionChanged: EventTypeWithValue;
   audioError: EventEmptyType; // to change

package/src/interfaces.ts

@@ -1,26 +1,68 @@
+import { AudioEventCallback, AudioEventName } from './events/types';
 import {
-  WindowType,
-  ContextState,
-  OscillatorType,
   BiquadFilterType,
   ChannelCountMode,
   ChannelInterpretation,
+  ContextState,
+  OscillatorType,
+  WindowType,
 } from './types';
-import { AudioEventName, AudioEventCallback } from './events/types';
+
+export type WorkletNodeCallback = (
+  audioData: Array<ArrayBuffer>,
+  channelCount: number
+) => void;
+
+export type WorkletSourceNodeCallback = (
+  audioData: Array<ArrayBuffer>,
+  framesToProcess: number,
+  currentTime: number,
+  startOffset: number
+) => void;
+
+export type WorkletProcessingNodeCallback = (
+  inputData: Array<ArrayBuffer>,
+  outputData: Array<ArrayBuffer>,
+  framesToProcess: number,
+  currentTime: number
+) => void;
+
+export type ShareableWorkletCallback =
+  | WorkletNodeCallback
+  | WorkletSourceNodeCallback
+  | WorkletProcessingNodeCallback;
 
 export interface IBaseAudioContext {
   readonly destination: IAudioDestinationNode;
   readonly state: ContextState;
   readonly sampleRate: number;
   readonly currentTime: number;
+  readonly decoder: IAudioDecoder;
 
   createRecorderAdapter(): IRecorderAdapterNode;
+  createWorkletSourceNode(
+    shareableWorklet: ShareableWorkletCallback,
+    shouldUseUiRuntime: boolean
+  ): IWorkletSourceNode;
+  createWorkletNode(
+    shareableWorklet: ShareableWorkletCallback,
+    shouldUseUiRuntime: boolean,
+    bufferLength: number,
+    inputChannelCount: number
+  ): IWorkletNode;
+  createWorkletProcessingNode(
+    shareableWorklet: ShareableWorkletCallback,
+    shouldUseUiRuntime: boolean
+  ): IWorkletProcessingNode;
   createOscillator(): IOscillatorNode;
+  createConstantSource(): IConstantSourceNode;
   createGain(): IGainNode;
   createStereoPanner(): IStereoPannerNode;
   createBiquadFilter: () => IBiquadFilterNode;
   createBufferSource: (pitchCorrection: boolean) => IAudioBufferSourceNode;
-  createBufferQueueSource: () => IAudioBufferQueueSourceNode;
+  createBufferQueueSource: (
+    pitchCorrection: boolean
+  ) => IAudioBufferQueueSourceNode;
   createBuffer: (
     channels: number,
     length: number,
@@ -32,12 +74,6 @@ export interface IBaseAudioContext {
     disableNormalization: boolean
   ) => IPeriodicWave;
   createAnalyser: () => IAnalyserNode;
-  decodeAudioDataSource: (sourcePath: string) => Promise<IAudioBuffer>;
-  decodeAudioData: (arrayBuffer: ArrayBuffer) => Promise<IAudioBuffer>;
-  decodePCMAudioDataInBase64: (
-    b64: string,
-    playbackRate: number
-  ) => Promise<IAudioBuffer>;
   createStreamer: () => IStreamerNode;
 }
 
@@ -119,6 +155,10 @@ export interface IStreamerNode extends IAudioNode {
   initialize(streamPath: string): boolean;
 }
 
+export interface IConstantSourceNode extends IAudioScheduledSourceNode {
+  readonly offset: IAudioParam;
+}
+
 export interface IAudioBufferSourceNode extends IAudioBufferBaseSourceNode {
   buffer: IAudioBuffer | null;
   loop: boolean;
@@ -128,6 +168,9 @@ export interface IAudioBufferSourceNode extends IAudioBufferBaseSourceNode {
 
   start: (when?: number, offset?: number, duration?: number) => void;
   setBuffer: (audioBuffer: IAudioBuffer | null) => void;
+
+  // passing subscriptionId(uint_64 in cpp, string in js) to the cpp
+  onLoopEnded: string;
 }
 
 export interface IAudioBufferQueueSourceNode
@@ -200,6 +243,12 @@ export interface IAnalyserNode extends IAudioNode {
 
 export interface IRecorderAdapterNode extends IAudioNode {}
 
+export interface IWorkletNode extends IAudioNode {}
+
+export interface IWorkletSourceNode extends IAudioScheduledSourceNode {}
+
+export interface IWorkletProcessingNode extends IAudioNode {}
+
 export interface IAudioRecorder {
   start: () => void;
   stop: () => void;
@@ -210,6 +259,23 @@ export interface IAudioRecorder {
   onAudioReady: string;
 }
 
+export interface IAudioDecoder {
+  decodeWithMemoryBlock: (
+    arrayBuffer: ArrayBuffer,
+    sampleRate?: number
+  ) => Promise<IAudioBuffer>;
+  decodeWithFilePath: (
+    sourcePath: string,
+    sampleRate?: number
+  ) => Promise<IAudioBuffer>;
+  decodeWithPCMInBase64: (
+    b64: string,
+    inputSampleRate: number,
+    inputChannelCount: number,
+    interleaved?: boolean
+  ) => Promise<IAudioBuffer>;
+}
+
 export interface IAudioEventEmitter {
   addAudioEventListener<Name extends AudioEventName>(
     name: Name,

package/src/types.ts

@@ -14,6 +14,8 @@ export type BiquadFilterType =
 
 export type ContextState = 'running' | 'closed' | `suspended`;
 
+export type AudioWorkletRuntime = 'AudioRuntime' | 'UIRuntime';
+
 export type OscillatorType =
   | 'sine'
   | 'square'
@@ -43,7 +45,7 @@ export interface AudioRecorderOptions {
 
 export type WindowType = 'blackman' | 'hann';
 
-export interface AudioBufferSourceNodeOptions {
+export interface AudioBufferBaseSourceNodeOptions {
   pitchCorrection: boolean;
 }
 

package/src/utils/index.ts

@@ -1,3 +1,24 @@
+import type { ShareableWorkletCallback } from '../interfaces';
+
+interface SimplifiedWorkletModule {
+  makeShareableCloneRecursive: (
+    workletCallback: ShareableWorkletCallback
+  ) => ShareableWorkletCallback;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  createWorkletRuntime: (options?: any) => any;
+}
+
 export function clamp(value: number, min: number, max: number): number {
   return Math.min(Math.max(value, min), max);
 }
+
+export let isWorkletsAvailable = false;
+export let workletsModule: SimplifiedWorkletModule;
+
+try {
+  workletsModule = require('react-native-worklets');
+  isWorkletsAvailable = true;
+} catch (error) {
+  isWorkletsAvailable = false;
+}

package/src/web-core/AudioBufferSourceNode.tsx

@@ -26,7 +26,7 @@ interface IStretcherNode extends globalThis.AudioNode {
   numberOfInputs: number;
   numberOfOutputs: number;
 
-  onended:
+  onEnded:
     | ((this: globalThis.AudioScheduledSourceNode, ev: Event) => unknown)
     | null;
   addEventListener: (

package/src/web-core/AudioContext.tsx

@@ -2,7 +2,7 @@ import {
   ContextState,
   PeriodicWaveConstraints,
   AudioContextOptions,
-  AudioBufferSourceNodeOptions,
+  AudioBufferBaseSourceNodeOptions,
 } from '../types';
 import { InvalidAccessError, NotSupportedError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
@@ -17,6 +17,7 @@ import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
 
 import { globalWasmPromise, globalTag } from './custom/LoadCustomWasm';
+import ConstantSourceNode from './ConstantSourceNode';
 
 export default class AudioContext implements BaseAudioContext {
   readonly context: globalThis.AudioContext;
@@ -53,6 +54,10 @@ export default class AudioContext implements BaseAudioContext {
     return new OscillatorNode(this, this.context.createOscillator());
   }
 
+  createConstantSource(): ConstantSourceNode {
+    return new ConstantSourceNode(this, this.context.createConstantSource());
+  }
+
   createGain(): GainNode {
     return new GainNode(this, this.context.createGain());
   }
@@ -66,7 +71,7 @@ export default class AudioContext implements BaseAudioContext {
   }
 
   async createBufferSource(
-    options?: AudioBufferSourceNodeOptions
+    options?: AudioBufferBaseSourceNodeOptions
   ): Promise<AudioBufferSourceNode> {
     if (!options || !options.pitchCorrection) {
       return new AudioBufferSourceNode(

package/src/web-core/AudioScheduledSourceNode.tsx

@@ -37,7 +37,7 @@ export default class AudioScheduledSourceNode extends AudioNode {
   }
 
   // eslint-disable-next-line accessor-pairs
-  public set onended(callback: (event: EventEmptyType) => void) {
+  public set onEnded(callback: (event: EventEmptyType) => void) {
     (this.node as globalThis.AudioScheduledSourceNode).onended = callback;
   }
 }

package/src/web-core/BaseAudioContext.tsx

@@ -8,6 +8,7 @@ import GainNode from './GainNode';
 import OscillatorNode from './OscillatorNode';
 import PeriodicWave from './PeriodicWave';
 import StereoPannerNode from './StereoPannerNode';
+import ConstantSourceNode from './ConstantSourceNode';
 
 export default interface BaseAudioContext {
   readonly context: globalThis.BaseAudioContext;
@@ -18,6 +19,7 @@ export default interface BaseAudioContext {
   get currentTime(): number;
   get state(): ContextState;
   createOscillator(): OscillatorNode;
+  createConstantSource(): ConstantSourceNode;
   createGain(): GainNode;
   createStereoPanner(): StereoPannerNode;
   createBiquadFilter(): BiquadFilterNode;

package/src/web-core/ConstantSourceNode.tsx

@@ -0,0 +1,12 @@
+import AudioParam from './AudioParam';
+import AudioScheduledSourceNode from './AudioScheduledSourceNode';
+import BaseAudioContext from './BaseAudioContext';
+
+export default class ConstantSourceNode extends AudioScheduledSourceNode {
+  readonly offset: AudioParam;
+
+  constructor(context: BaseAudioContext, node: globalThis.ConstantSourceNode) {
+    super(context, node);
+    this.offset = new AudioParam(node.offset, context);
+  }
+}