node-web-audio-api 0.19.0 → 0.21.0

package/js/AudioWorkletGlobalScope.js

@@ -0,0 +1,303 @@
+const {
+  parentPort,
+  workerData,
+} = require('node:worker_threads');
+
+const conversions = require('webidl-conversions');
+
+const {
+  exit_audio_worklet_global_scope,
+  run_audio_worklet_global_scope,
+} = require('../load-native.cjs');
+
+const {
+  workletId,
+  sampleRate,
+} = workerData;
+
+const kWorkletQueueTask = Symbol.for('node-web-audio-api:worklet-queue-task');
+const kWorkletCallableProcess = Symbol.for('node-web-audio-api:worklet-callable-process');
+const kWorkletInputs = Symbol.for('node-web-audio-api:worklet-inputs');
+const kWorkletOutputs = Symbol.for('node-web-audio-api:worklet-outputs');
+const kWorkletParams = Symbol.for('node-web-audio-api:worklet-params');
+const kWorkletParamsCache = Symbol.for('node-web-audio-api:worklet-params-cache');
+// const kWorkletOrderedParamNames = Symbol.for('node-web-audio-api:worklet-ordered-param-names');
+
+const nameProcessorCtorMap = new Map();
+const processors = {};
+let pendingProcessorConstructionData = null;
+let loopStarted = false;
+let runLoopImmediateId = null;
+
+function isIterable(obj) {
+  // checks for null and undefined
+  if (obj === null || obj === undefined) {
+    return false;
+  }
+  return typeof obj[Symbol.iterator] === 'function';
+}
+
+// cf. https://stackoverflow.com/a/46759625
+function isConstructor(f) {
+  try {
+    Reflect.construct(String, [], f);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+function runLoop() {
+  // block until we need to render a quantum
+  run_audio_worklet_global_scope(workletId, processors);
+  // yield to the event loop, and then repeat
+  runLoopImmediateId = setImmediate(runLoop);
+}
+
+// s
+globalThis.currentTime = 0
+globalThis.currentFrame = 0;
+globalThis.sampleRate = sampleRate;
+// @todo - implement in upstream crate
+// globalThis.renderQuantumSize = 128;
+
+globalThis.AudioWorkletProcessor = class AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [];
+  }
+
+  #port = null;
+
+  constructor() {
+    const {
+      port,
+      numberOfInputs,
+      numberOfOutputs,
+      parameterDescriptors,
+    } = pendingProcessorConstructionData;
+
+    // @todo - Mark [[callable process]] as true, set to false in render quantum
+    // either "process" doese not exists, either it throws an error
+    this[kWorkletCallableProcess] = true;
+    // @todo - reuse Float32Arrays between calls + freeze arrays
+    this[kWorkletInputs] = new Array(numberOfInputs).fill([]);
+    // @todo - use `outputChannelCount`
+    this[kWorkletOutputs] = new Array(numberOfOutputs).fill([]);
+    // Object to be reused as `process` parameters argument
+    this[kWorkletParams] = {};
+    // Cache of 2 Float32Array (of length 128 and 1) for each param, to be reused on
+    // each process call according to the size the param for the current render quantum
+    this[kWorkletParamsCache] = {};
+
+    parameterDescriptors.forEach(desc => {
+      this[kWorkletParamsCache][desc.name] = [
+        new Float32Array(128), // should be globalThis.renderQuantumSize
+        new Float32Array(1),
+      ]
+    });
+
+    this.#port = port;
+  }
+
+  get port() {
+    if (!(this instanceof AudioWorkletProcessor)) {
+      throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioWorkletProcessor\'');
+    }
+
+    return this.#port;
+  }
+
+  [kWorkletQueueTask](cmd, err) {
+    this.#port.postMessage({ cmd, err });
+  }
+}
+
+// follow algorithm from:
+// https://webaudio.github.io/web-audio-api/#dom-audioworkletglobalscope-registerprocessor
+globalThis.registerProcessor = function registerProcessor(name, processorCtor) {
+  const parsedName = conversions['DOMString'](name, {
+    context: `Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': name (${name})`,
+  });
+
+  if (parsedName === '') {
+    throw new DOMException(`Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': name is empty`, 'NotSupportedError');
+  }
+
+  if (nameProcessorCtorMap.has(name)) {
+    throw new DOMException(`Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': A processor with name '${name}' has already been registered in this scope`, 'NotSupportedError');
+  }
+
+  if (!isConstructor(processorCtor)) {
+    throw new TypeError(`Cannot execute 'registerProcessor")' in 'AudoWorkletGlobalScope': argument 2 for name '${name}' is not a constructor`);
+  }
+
+  if (typeof processorCtor.prototype !== 'object') {
+    throw new TypeError(`Cannot execute 'registerProcessor")' in 'AudoWorkletGlobalScope': argument 2 for name '${name}' is not is not a valid AudioWorkletProcessor`);
+  }
+
+  // must support Array, Set or iterators
+  let parameterDescriptorsValue = processorCtor.parameterDescriptors;
+
+  if (!isIterable(parameterDescriptorsValue)) {
+    throw new TypeError(`Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': Invalid 'parameterDescriptors' for processor '${name}: 'parameterDescriptors' is not iterable'`);
+  }
+
+  const paramDescriptors = Array.from(parameterDescriptorsValue);
+  const parsedParamDescriptors = [];
+
+  // Parse AudioParamDescriptor sequence
+  // cf. https://webaudio.github.io/web-audio-api/#AudioParamDescriptor
+  for (let i = 0; i < paramDescriptors.length; i++) {
+    const descriptor = paramDescriptors[i];
+    const parsedDescriptor = {};
+
+    if (typeof descriptor !== 'object' || descriptor === null) {
+      throw new TypeError(`Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': Invalid 'parameterDescriptors' for processor '${name}: Element at index ${i} is not an instance of 'AudioParamDescriptor'`);
+    }
+
+    if (descriptor.name === undefined) {
+      throw new TypeError(`Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': Invalid 'parameterDescriptors' for processor '${name}: Element at index ${i} is not an instance of 'AudioParamDescriptor'`);
+    }
+
+    parsedDescriptor.name = conversions['DOMString'](descriptor.name, {
+      context: `Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': Invalid 'parameterDescriptors' for processor '${name}: Invalid 'name' for 'AudioParamDescriptor' at index ${i}`,
+    });
+
+    if (descriptor.defaultValue !== undefined) {
+      parsedDescriptor.defaultValue = conversions['float'](descriptor.defaultValue, {
+        context: `Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': Invalid 'parameterDescriptors' for processor '${name}: Invalid 'defaultValue' for 'AudioParamDescriptor' at index ${i}`,
+      });
+    } else {
+      parsedDescriptor.defaultValue = 0;
+    }
+
+    if (descriptor.maxValue !== undefined) {
+      parsedDescriptor.maxValue = conversions['float'](descriptor.maxValue, {
+        context: `Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': Invalid 'parameterDescriptors' for processor '${name}: Invalid 'maxValue' for 'AudioParamDescriptor' at index ${i}`,
+      });
+    } else {
+      parsedDescriptor.maxValue = 3.4028235e38;
+    }
+
+    if (descriptor.minValue !== undefined) {
+      parsedDescriptor.minValue = conversions['float'](descriptor.minValue, {
+        context: `Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': Invalid 'parameterDescriptors' for processor '${name}: Invalid 'minValue' for 'AudioParamDescriptor' at index ${i}`,
+      });
+    } else {
+      parsedDescriptor.minValue = -3.4028235e38;
+    }
+
+    if (descriptor.automationRate !== undefined) {
+      if (!['a-rate', 'k-rate'].includes(descriptor.automationRate)) {
+        throw new TypeError(`Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': Invalid 'parameterDescriptors' for processor '${name}: The provided value '${descriptor.automationRate}' is not a valid enum value of type AutomationRate for 'AudioParamDescriptor' at index ${i}`);
+      }
+
+      parsedDescriptor.automationRate = conversions['DOMString'](descriptor.automationRate, {
+        context: `Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': Invalid 'parameterDescriptors' for processor '${name}: The provided value '${descriptor.automationRate}'`,
+      });
+    } else {
+      parsedDescriptor.automationRate = 'a-rate';
+    }
+
+    parsedParamDescriptors.push(parsedDescriptor);
+  }
+
+  // check for duplicate parame names and consistency of min, max and default values
+  const paramNames = [];
+
+  for (let i = 0; i < parsedParamDescriptors.length; i++) {
+    const { name, defaultValue, minValue, maxValue } = parsedParamDescriptors[i];
+
+    if (paramNames.includes(name)) {
+      throw new DOMException(`Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': Invalid 'parameterDescriptors' for processor '${name}': 'AudioParamDescriptor' with name '${name}' already declared`, 'NotSupportedError');
+    }
+
+    paramNames.push(name);
+
+    if (!(minValue <= defaultValue && defaultValue <= maxValue)) {
+      throw new DOMException(`Cannot execute 'registerProcessor' in 'AudoWorkletGlobalScope': Invalid 'parameterDescriptors' for processor '${name}': The constraint minValue <= defaultValue <= maxValue is not met`, 'InvalidStateError');
+    }
+  }
+
+  // store constructor
+  nameProcessorCtorMap.set(parsedName, processorCtor);
+  // send param descriptors back to main thread
+  parentPort.postMessage({
+    cmd: 'node-web-audio-api:worlet:processor-registered',
+    name: parsedName,
+    parameterDescriptors: parsedParamDescriptors,
+  });
+};
+
+
+// @todo - recheck this, not sure this is relevant in our case
+// NOTE: Authors that register an event listener on the "message" event of this
+// port should call close on either end of the MessageChannel (either in the
+// AudioWorklet or the AudioWorkletGlobalScope side) to allow for resources to be collected.
+parentPort.on('exit', () => {
+  process.stdout.write('closing worklet');
+});
+
+parentPort.on('message', event => {
+  console.log(event.cmd + '\n');
+
+  switch (event.cmd) {
+    case 'node-web-audio-api:worklet:init': {
+      const { workletId, processors, promiseId } = event;
+      break;
+    }
+    case 'node-web-audio-api:worklet:exit': {
+      clearImmediate(runLoopImmediateId);
+      // properly exit audio worklet on rust side
+      exit_audio_worklet_global_scope(workletId, processors);
+      // exit process
+      process.exit(0);
+      break;
+    }
+    case 'node-web-audio-api:worklet:add-module': {
+      const { code, promiseId } = event;
+      const func = new Function('AudioWorkletProcessor', 'registerProcessor', code);
+      func(AudioWorkletProcessor, registerProcessor);
+
+      // send registered param descriptors on main thread and resolve Promise
+      parentPort.postMessage({
+        cmd: 'node-web-audio-api:worklet:module-added',
+        promiseId,
+      });
+      break;
+    }
+    case 'node-web-audio-api:worklet:create-processor': {
+      const { name, id, options, port } = event;
+      const ctor = nameProcessorCtorMap.get(name);
+
+      // rewrap options of interest for the AudioWorkletNodeBaseClass
+      pendingProcessorConstructionData = {
+        port,
+        numberOfInputs: options.numberOfInputs,
+        numberOfOutputs: options.numberOfOutputs,
+        parameterDescriptors: ctor.parameterDescriptors,
+      };
+
+      let instance;
+
+      try {
+        instance = new ctor(options);
+      } catch (err) {
+        port.postMessage({ cmd: 'node-web-audio-api:worklet:ctor-error', err });
+      }
+
+      pendingProcessorConstructionData = null;
+      // store in global so that Rust can match the JS processor
+      // with its corresponding NapiAudioWorkletProcessor
+      processors[`${id}`] = instance;
+      // notify audio worklet back that processor has finished instanciation
+      parentPort.postMessage({ cmd: 'node-web-audio-api:worklet:processor-created', id });
+
+      if (!loopStarted) {
+        loopStarted = true;
+        setImmediate(runLoop);
+      }
+      break;
+    }
+  }
+});

package/js/AudioWorkletNode.js

@@ -0,0 +1,290 @@
+/* eslint-disable no-unused-vars */
+const conversions = require('webidl-conversions');
+const {
+  toSanitizedSequence,
+} = require('./lib/cast.js');
+const {
+  throwSanitizedError,
+} = require('./lib/errors.js');
+const {
+  kNapiObj,
+  kProcessorRegistered,
+  kGetParameterDescriptors,
+  kPrivateConstructor,
+  kCreateProcessor,
+} = require('./lib/symbols.js');
+const {
+  kEnumerableProperty,
+} = require('./lib/utils.js');
+const {
+  propagateEvent,
+} = require('./lib/events.js');
+const {
+  ErrorEvent,
+} = require('./Events.js');
+
+/* eslint-enable no-unused-vars */
+
+const AudioNode = require('./AudioNode.js');
+const AudioParamMap = require('./AudioParamMap.js');
+const IMPLEMENTATION_MAX_NUMBER_OF_CHANNELS = 32;
+
+module.exports = (jsExport, nativeBinding) => {
+  class AudioWorkletNode extends AudioNode {
+    #port = null;
+    #parameters = {};
+
+    constructor(context, name, options) {
+      if (arguments.length < 2) {
+        throw new TypeError(`Failed to construct 'AudioWorkletNode': 2 arguments required, but only ${arguments.length} present`);
+      }
+
+      if (!(context instanceof jsExport.BaseAudioContext)) {
+        throw new TypeError(`Failed to construct 'AudioWorkletNode': argument 1 is not of type BaseAudioContext`);
+      }
+
+      const parsedName = conversions['DOMString'](name, {
+        context: `Failed to construct 'AudioWorkletNode': The given 'AudioWorkletProcessor' name`,
+      });
+
+      if (!context.audioWorklet[kProcessorRegistered](parsedName)) {
+        throw new DOMException(`Failed to construct 'AudioWorkletNode': processor '${parsedName}' is not registered in 'AudioWorklet'`, 'InvalidStateError');
+      }
+
+      // parsed version of the option to be passed to NAPI
+      const parsedOptions = {};
+
+      if (options && (typeof options !== 'object' || options === null)) {
+        throw new TypeError('Failed to construct \'AudioWorkletNode\': argument 3 is not of type \'AudioWorkletNodeOptions\'');
+      }
+
+      if (options && options.numberOfInputs !== undefined) {
+        parsedOptions.numberOfInputs = conversions['unsigned long'](options.numberOfInputs, {
+          enforceRange: true,
+          context: `Failed to construct 'AudioWorkletNode': Failed to read the 'numberOfInputs' property from AudioWorkletNodeOptions: The provided value (${options.numberOfInputs}})`,
+        });
+      } else {
+        parsedOptions.numberOfInputs = 1;
+      }
+
+      if (options && options.numberOfOutputs !== undefined) {
+        parsedOptions.numberOfOutputs = conversions['unsigned long'](options.numberOfOutputs, {
+          enforceRange: true,
+          context: `Failed to construct 'AudioWorkletNode': Failed to read the 'numberOfOutputs' property from AudioWorkletNodeOptions: The provided value (${options.numberOfOutputs}})`,
+        });
+      } else {
+        parsedOptions.numberOfOutputs = 1;
+      }
+
+      // If outputChannelCount exists,
+      // - If any value in outputChannelCount is zero or greater than the implementation’s maximum number of channels, throw a NotSupportedError and abort the remaining steps.
+      // - If the length of outputChannelCount does not equal numberOfOutputs, throw an IndexSizeError and abort the remaining steps.
+      // - If both numberOfInputs and numberOfOutputs are 1, set the channel count of the node output to the one value in outputChannelCount.
+      // - Otherwise set the channel count of the kth output of the node to the kth element of outputChannelCount sequence and return.
+      if (options && options.outputChannelCount !== undefined) {
+        try {
+          parsedOptions.outputChannelCount = toSanitizedSequence(options.outputChannelCount, Uint32Array);
+        } catch (err) {
+          throw new TypeError(`Failed to construct 'AudioWorkletNode': Failed to read the 'outputChannelCount' property from AudioWorkletNodeOptions: The provided value ${err.message}`);
+        }
+
+        parsedOptions.outputChannelCount.forEach((value, index) => {
+          if (value <= 0 || value > IMPLEMENTATION_MAX_NUMBER_OF_CHANNELS) {
+            throw new DOMException(`Failed to construct 'AudioWorkletNode': Invalid 'outputChannelCount' property from AudioWorkletNodeOptions: Value at index ${index} in outside supported range [1, 32]`, 'NotSupportedError');
+          }
+        });
+
+        if (parsedOptions.numberOfOutputs !== parsedOptions.outputChannelCount.length) {
+          throw new DOMException(`Failed to construct 'AudioWorkletNode': Invalid 'outputChannelCount' property from AudioWorkletNodeOptions: 'outputChannelCount' length (${parsedOptions.outputChannelCount.length}) does not equal 'numberOfOutputs' (${parsedOptions.numberOfOutputs})`, 'IndexSizeError');
+        }
+      } else {
+        // If outputChannelCount does not exists,
+        // - If both numberOfInputs and numberOfOutputs are 1, set the initial channel count of the node output to 1 and return.
+        //   NOTE: For this case, the output chanel count will change to computedNumberOfChannels dynamically based on the input and the channelCountMode at runtime.
+        // - Otherwise set the channel count of each output of the node to 1 and return.
+
+        // @note - not sure what this means, let's go simple
+        parsedOptions.outputChannelCount = new Uint32Array(parsedOptions.numberOfOutputs);
+        parsedOptions.outputChannelCount.fill(1);
+      }
+
+      // @todo
+      // - This should be a "record", let's treat it as a raw object of now
+      // - Check if this needs to checked against the declared `parameterDescriptors`
+      if (options && options.parameterData !== undefined) {
+        if (typeof options.parameterData === 'object' && options.parameterData !== null) {
+          parsedOptions.parameterData = {};
+
+          for (let [key, value] in Object.entries(options.parameterData)) {
+            const parsedKey = conversions['DOMString'](key, {
+              context: `Failed to construct 'AudioWorkletNode': Invalid 'parameterData' property from AudioWorkletNodeOptions: Invalid key (${key})`,
+            });
+
+            const parsedValue = conversions['double'](value, {
+              context: `Failed to construct 'AudioWorkletNode': Invalid 'parameterData' property from AudioWorkletNodeOptions: Invalid value for key ${parsedKey}`,
+            });
+
+            parsedOptions.parameterData[parsedKey] = parsedValue;
+          }
+        } else {
+          throw new TypeError(`Failed to construct 'AudioWorkletNode': Invalid 'parameterData' property from AudioWorkletNodeOptions: 'outputChannelCount' length (${parsedOptions.outputChannelCount.length}) does not equal 'numberOfOutputs' (${parsedOptions.numberOfOutputs})`);
+        }
+      } else {
+        parsedOptions.parameterData = {};
+      }
+
+      // These ones are for the JS processor
+      if (options && options.processorOptions !== undefined) {
+        if (typeof options.processorOptions === 'object' && options.processorOptions !== null) {
+          parsedOptions.processorOptions = Object.assign({}, options.processorOptions);
+        } else {
+          throw new TypeError(`Failed to construct 'AudioWorkletNode': Invalid 'processorOptions' property from AudioWorkletNodeOptions: 'processorOptions' is not an object`);
+        }
+      } else {
+        parsedOptions.processorOptions = {};
+      }
+
+      // AudioNodeOptions
+      if (options && options.channelCount !== undefined) {
+        parsedOptions.channelCount = conversions['unsigned long'](options.channelCount, {
+          enforceRange: true,
+          context: `Failed to construct 'AudioWorkletNode': Failed to read the 'channelCount' property from AudioWorkletNodeOptions: The provided value '${options.channelCount}'`,
+        });
+
+        // if we delegate this check to Rust, this can poison a Mutex
+        // (probably the `audio_param_descriptor_channel` one)
+        if (parsedOptions.channelCount <= 0 || parsedOptions.channelCount > IMPLEMENTATION_MAX_NUMBER_OF_CHANNELS) {
+          throw new DOMException(`Failed to construct 'AudioWorkletNode': Invalid 'channelCount' property: Number of channels: ${parsedOptions.channelCount} is outside range [1, 32]`, 'NotSupportedError')
+        }
+      }
+
+      if (options && options.channelCountMode !== undefined) {
+        if (!['max', 'clamped-max', 'explicit'].includes(options.channelCountMode)) {
+          throw new TypeError(`Failed to construct 'AudioWorkletNode': Failed to read the 'channelCountMode' property from 'AudioNodeOptions': The provided value '${options.channelCountMode}' is not a valid enum value of type ChannelCountMode`);
+        }
+
+        parsedOptions.channelCountMode = conversions['DOMString'](options.channelCountMode, {
+          context: `Failed to construct 'AudioWorkletNode': Failed to read the 'channelCount' property from AudioWorkletNodeOptions: The provided value '${options.channelCountMode}'`,
+        });
+      }
+
+      if (options && options.channelInterpretation !== undefined) {
+        if (!['speakers', 'discrete'].includes(options.channelInterpretation)) {
+          throw new TypeError(`Failed to construct 'AudioWorkletNode': Failed to read the 'channelInterpretation' property from 'AudioNodeOptions': The provided value '${options.channelInterpretation}' is not a valid enum value of type ChannelCountMode`);
+        }
+
+        parsedOptions.channelInterpretation = conversions['DOMString'](options.channelInterpretation, {
+          context: `Failed to construct 'AudioWorkletNode': Failed to read the 'channelInterpretation' property from AudioWorkletNodeOptions: The provided value '${options.channelInterpretation}'`,
+        });
+      }
+
+      // Create NapiAudioWorkletNode
+      const parameterDescriptors = context.audioWorklet[kGetParameterDescriptors](parsedName);
+      let napiObj;
+
+      try {
+        napiObj = new nativeBinding.AudioWorkletNode(
+          context[kNapiObj],
+          parsedName,
+          parsedOptions,
+          parameterDescriptors,
+        );
+      } catch (err) {
+        throwSanitizedError(err);
+      }
+
+      super(context, {
+        [kNapiObj]: napiObj,
+      });
+
+      let parameters = new Map();
+
+      for (let name in this[kNapiObj].parameters) {
+        const audioParam = new jsExport.AudioParam({
+          [kNapiObj]: this[kNapiObj].parameters[name],
+        });
+
+        parameters.set(name, audioParam);
+      }
+
+      this.#parameters = new AudioParamMap({
+        [kPrivateConstructor]: true,
+        parameters,
+      });
+
+      // Create JS processor
+      this.#port = context.audioWorklet[kCreateProcessor](
+        parsedName,
+        parsedOptions,
+        napiObj.id,
+      );
+
+      this.#port.on('message', msg => {
+        // ErrorEvent named processorerror
+        switch (msg.cmd) {
+          case 'node-web-audio-api:worklet:ctor-error': {
+            const message = `Failed to construct '${parsedName}' AudioWorkletProcessor: ${msg.err.message}`;
+            const event = new ErrorEvent('processorerror', { message, error: msg.err });
+            propagateEvent(this, event);
+            break;
+          }
+          case 'node-web-audio-api:worklet:process-invalid': {
+            const message = `Failed to execute 'process' on '${parsedName}' AudioWorkletProcessor: ${msg.err.message}`;
+            const error = new TypeError(message);
+            error.stack = msg.err.stack.replace(msg.err.message, message);
+
+            const event = new ErrorEvent('processorerror', { message, error });
+            propagateEvent(this, event);
+            break;
+          }
+          case 'node-web-audio-api:worklet:process-error': {
+            const message = `Failed to execute 'process' on '${parsedName}' AudioWorkletProcessor: ${msg.err.message}`;
+            const event = new ErrorEvent('processorerror', { message, error: msg.err });
+            propagateEvent(this, event);
+            break;
+          }
+        }
+      });
+    }
+
+    get parameters() {
+      if (!(this instanceof AudioWorkletNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioWorkletNode\'');
+      }
+
+      return this.#parameters;
+    }
+
+    get port() {
+      if (!(this instanceof AudioWorkletNode)) {
+        throw new TypeError('Invalid Invocation: Value of \'this\' must be of type \'AudioWorkletNode\'');
+      }
+
+      return this.#port;
+    }
+  }
+
+  Object.defineProperties(AudioWorkletNode, {
+    length: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 2,
+    },
+  });
+
+  Object.defineProperties(AudioWorkletNode.prototype, {
+    [Symbol.toStringTag]: {
+      __proto__: null,
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: 'AudioWorkletNode',
+    },
+    parameters: kEnumerableProperty,
+    port: kEnumerableProperty,
+  });
+
+  return AudioWorkletNode;
+};