react-audio-wavekit 0.1.5 → 0.1.6

package/dist/node_modules/standardized-audio-context/build/es2019/factories/audio-node-constructor.cjs

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const globals = require("../globals.cjs");
+const audioNode = require("../guards/audio-node.cjs");
+const audioNodeOutputConnection = require("../guards/audio-node-output-connection.cjs");
+const addActiveInputConnectionToAudioParam = require("../helpers/add-active-input-connection-to-audio-param.cjs");
+const addPassiveInputConnectionToAudioParam = require("../helpers/add-passive-input-connection-to-audio-param.cjs");
+const connectNativeAudioNodeToNativeAudioNode = require("../helpers/connect-native-audio-node-to-native-audio-node.cjs");
+const deleteActiveInputConnection = require("../helpers/delete-active-input-connection.cjs");
+const deleteActiveInputConnectionToAudioParam = require("../helpers/delete-active-input-connection-to-audio-param.cjs");
+const deleteEventListenersOfAudioNode = require("../helpers/delete-event-listeners-of-audio-node.cjs");
+const deletePassiveInputConnectionToAudioNode = require("../helpers/delete-passive-input-connection-to-audio-node.cjs");
+const deletePassiveInputConnectionToAudioParam = require("../helpers/delete-passive-input-connection-to-audio-param.cjs");
+const disconnectNativeAudioNodeFromNativeAudioNode = require("../helpers/disconnect-native-audio-node-from-native-audio-node.cjs");
+const getAudioNodeConnections = require("../helpers/get-audio-node-connections.cjs");
+const getAudioParamConnections = require("../helpers/get-audio-param-connections.cjs");
+const getEventListenersOfAudioNode = require("../helpers/get-event-listeners-of-audio-node.cjs");
+const getNativeAudioNode = require("../helpers/get-native-audio-node.cjs");
+const getNativeAudioParam = require("../helpers/get-native-audio-param.cjs");
+const insertElementInSet = require("../helpers/insert-element-in-set.cjs");
+const isActiveAudioNode = require("../helpers/is-active-audio-node.cjs");
+const isPartOfACycle = require("../helpers/is-part-of-a-cycle.cjs");
+const isPassiveAudioNode = require("../helpers/is-passive-audio-node.cjs");
+const setInternalStateToActive = require("../helpers/set-internal-state-to-active.cjs");
+const setInternalStateToPassiveWhenNecessary = require("../helpers/set-internal-state-to-passive-when-necessary.cjs");
+const testAudioNodeDisconnectMethodSupport = require("../helpers/test-audio-node-disconnect-method-support.cjs");
+const visitEachAudioNodeOnce = require("../helpers/visit-each-audio-node-once.cjs");
+const wrapAudioNodeDisconnectMethod = require("../helpers/wrap-audio-node-disconnect-method.cjs");
+const addConnectionToAudioParamOfAudioContext = (source, destination, output, isOffline) => {
+  const { activeInputs, passiveInputs } = getAudioParamConnections.getAudioParamConnections(destination);
+  const { outputs } = getAudioNodeConnections.getAudioNodeConnections(source);
+  const eventListeners = getEventListenersOfAudioNode.getEventListenersOfAudioNode(source);
+  const eventListener = (isActive) => {
+    const nativeAudioNode = getNativeAudioNode.getNativeAudioNode(source);
+    const nativeAudioParam = getNativeAudioParam.getNativeAudioParam(destination);
+    if (isActive) {
+      const partialConnection = deletePassiveInputConnectionToAudioParam.deletePassiveInputConnectionToAudioParam(passiveInputs, source, output);
+      addActiveInputConnectionToAudioParam.addActiveInputConnectionToAudioParam(activeInputs, source, partialConnection, false);
+      if (!isOffline && !isPartOfACycle.isPartOfACycle(source)) {
+        nativeAudioNode.connect(nativeAudioParam, output);
+      }
+    } else {
+      const partialConnection = deleteActiveInputConnectionToAudioParam.deleteActiveInputConnectionToAudioParam(activeInputs, source, output);
+      addPassiveInputConnectionToAudioParam.addPassiveInputConnectionToAudioParam(passiveInputs, partialConnection, false);
+      if (!isOffline && !isPartOfACycle.isPartOfACycle(source)) {
+        nativeAudioNode.disconnect(nativeAudioParam, output);
+      }
+    }
+  };
+  if (insertElementInSet.insertElementInSet(outputs, [destination, output], (outputConnection) => outputConnection[0] === destination && outputConnection[1] === output, true)) {
+    eventListeners.add(eventListener);
+    if (isActiveAudioNode.isActiveAudioNode(source)) {
+      addActiveInputConnectionToAudioParam.addActiveInputConnectionToAudioParam(activeInputs, source, [output, eventListener], true);
+    } else {
+      addPassiveInputConnectionToAudioParam.addPassiveInputConnectionToAudioParam(passiveInputs, [source, output, eventListener], true);
+    }
+    return true;
+  }
+  return false;
+};
+const deleteInputConnectionOfAudioNode = (source, destination, output, input) => {
+  const { activeInputs, passiveInputs } = getAudioNodeConnections.getAudioNodeConnections(destination);
+  const activeInputConnection = deleteActiveInputConnection.deleteActiveInputConnection(activeInputs[input], source, output);
+  if (activeInputConnection === null) {
+    const passiveInputConnection = deletePassiveInputConnectionToAudioNode.deletePassiveInputConnectionToAudioNode(passiveInputs, source, output, input);
+    return [passiveInputConnection[2], false];
+  }
+  return [activeInputConnection[2], true];
+};
+const deleteInputConnectionOfAudioParam = (source, destination, output) => {
+  const { activeInputs, passiveInputs } = getAudioParamConnections.getAudioParamConnections(destination);
+  const activeInputConnection = deleteActiveInputConnection.deleteActiveInputConnection(activeInputs, source, output);
+  if (activeInputConnection === null) {
+    const passiveInputConnection = deletePassiveInputConnectionToAudioParam.deletePassiveInputConnectionToAudioParam(passiveInputs, source, output);
+    return [passiveInputConnection[1], false];
+  }
+  return [activeInputConnection[2], true];
+};
+const deleteInputsOfAudioNode = (source, isOffline, destination, output, input) => {
+  const [listener, isActive] = deleteInputConnectionOfAudioNode(source, destination, output, input);
+  if (listener !== null) {
+    deleteEventListenersOfAudioNode.deleteEventListenerOfAudioNode(source, listener);
+    if (isActive && !isOffline && !isPartOfACycle.isPartOfACycle(source)) {
+      disconnectNativeAudioNodeFromNativeAudioNode.disconnectNativeAudioNodeFromNativeAudioNode(getNativeAudioNode.getNativeAudioNode(source), getNativeAudioNode.getNativeAudioNode(destination), output, input);
+    }
+  }
+  if (isActiveAudioNode.isActiveAudioNode(destination)) {
+    const { activeInputs } = getAudioNodeConnections.getAudioNodeConnections(destination);
+    setInternalStateToPassiveWhenNecessary.setInternalStateToPassiveWhenNecessary(destination, activeInputs);
+  }
+};
+const deleteInputsOfAudioParam = (source, isOffline, destination, output) => {
+  const [listener, isActive] = deleteInputConnectionOfAudioParam(source, destination, output);
+  if (listener !== null) {
+    deleteEventListenersOfAudioNode.deleteEventListenerOfAudioNode(source, listener);
+    if (isActive && !isOffline && !isPartOfACycle.isPartOfACycle(source)) {
+      getNativeAudioNode.getNativeAudioNode(source).disconnect(getNativeAudioParam.getNativeAudioParam(destination), output);
+    }
+  }
+};
+const deleteAnyConnection = (source, isOffline) => {
+  const audioNodeConnectionsOfSource = getAudioNodeConnections.getAudioNodeConnections(source);
+  const destinations = [];
+  for (const outputConnection of audioNodeConnectionsOfSource.outputs) {
+    if (audioNodeOutputConnection.isAudioNodeOutputConnection(outputConnection)) {
+      deleteInputsOfAudioNode(source, isOffline, ...outputConnection);
+    } else {
+      deleteInputsOfAudioParam(source, isOffline, ...outputConnection);
+    }
+    destinations.push(outputConnection[0]);
+  }
+  audioNodeConnectionsOfSource.outputs.clear();
+  return destinations;
+};
+const deleteConnectionAtOutput = (source, isOffline, output) => {
+  const audioNodeConnectionsOfSource = getAudioNodeConnections.getAudioNodeConnections(source);
+  const destinations = [];
+  for (const outputConnection of audioNodeConnectionsOfSource.outputs) {
+    if (outputConnection[1] === output) {
+      if (audioNodeOutputConnection.isAudioNodeOutputConnection(outputConnection)) {
+        deleteInputsOfAudioNode(source, isOffline, ...outputConnection);
+      } else {
+        deleteInputsOfAudioParam(source, isOffline, ...outputConnection);
+      }
+      destinations.push(outputConnection[0]);
+      audioNodeConnectionsOfSource.outputs.delete(outputConnection);
+    }
+  }
+  return destinations;
+};
+const deleteConnectionToDestination = (source, isOffline, destination, output, input) => {
+  const audioNodeConnectionsOfSource = getAudioNodeConnections.getAudioNodeConnections(source);
+  return Array.from(audioNodeConnectionsOfSource.outputs).filter((outputConnection) => outputConnection[0] === destination && (output === void 0 || outputConnection[1] === output) && (input === void 0 || outputConnection[2] === input)).map((outputConnection) => {
+    if (audioNodeOutputConnection.isAudioNodeOutputConnection(outputConnection)) {
+      deleteInputsOfAudioNode(source, isOffline, ...outputConnection);
+    } else {
+      deleteInputsOfAudioParam(source, isOffline, ...outputConnection);
+    }
+    audioNodeConnectionsOfSource.outputs.delete(outputConnection);
+    return outputConnection[0];
+  });
+};
+const createAudioNodeConstructor = (addAudioNodeConnections, addConnectionToAudioNode, cacheTestResult, createIncrementCycleCounter, createIndexSizeError, createInvalidAccessError, createNotSupportedError, decrementCycleCounter, detectCycles, eventTargetConstructor, getNativeContext, isNativeAudioContext, isNativeAudioNode, isNativeAudioParam, isNativeOfflineAudioContext, nativeAudioWorkletNodeConstructor) => {
+  return class AudioNode extends eventTargetConstructor {
+    constructor(context, isActive, nativeAudioNode, audioNodeRenderer) {
+      super(nativeAudioNode);
+      this._context = context;
+      this._nativeAudioNode = nativeAudioNode;
+      const nativeContext = getNativeContext(context);
+      if (isNativeAudioContext(nativeContext) && true !== cacheTestResult(testAudioNodeDisconnectMethodSupport.testAudioNodeDisconnectMethodSupport, () => {
+        return testAudioNodeDisconnectMethodSupport.testAudioNodeDisconnectMethodSupport(nativeContext, nativeAudioWorkletNodeConstructor);
+      })) {
+        wrapAudioNodeDisconnectMethod.wrapAudioNodeDisconnectMethod(nativeAudioNode);
+      }
+      globals.AUDIO_NODE_STORE.set(this, nativeAudioNode);
+      globals.EVENT_LISTENERS.set(this, /* @__PURE__ */ new Set());
+      if (context.state !== "closed" && isActive) {
+        setInternalStateToActive.setInternalStateToActive(this);
+      }
+      addAudioNodeConnections(this, audioNodeRenderer, nativeAudioNode);
+    }
+    get channelCount() {
+      return this._nativeAudioNode.channelCount;
+    }
+    set channelCount(value) {
+      this._nativeAudioNode.channelCount = value;
+    }
+    get channelCountMode() {
+      return this._nativeAudioNode.channelCountMode;
+    }
+    set channelCountMode(value) {
+      this._nativeAudioNode.channelCountMode = value;
+    }
+    get channelInterpretation() {
+      return this._nativeAudioNode.channelInterpretation;
+    }
+    set channelInterpretation(value) {
+      this._nativeAudioNode.channelInterpretation = value;
+    }
+    get context() {
+      return this._context;
+    }
+    get numberOfInputs() {
+      return this._nativeAudioNode.numberOfInputs;
+    }
+    get numberOfOutputs() {
+      return this._nativeAudioNode.numberOfOutputs;
+    }
+    // tslint:disable-next-line:invalid-void
+    connect(destination, output = 0, input = 0) {
+      if (output < 0 || output >= this._nativeAudioNode.numberOfOutputs) {
+        throw createIndexSizeError();
+      }
+      const nativeContext = getNativeContext(this._context);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      if (isNativeAudioNode(destination) || isNativeAudioParam(destination)) {
+        throw createInvalidAccessError();
+      }
+      if (audioNode.isAudioNode(destination)) {
+        const nativeDestinationAudioNode = getNativeAudioNode.getNativeAudioNode(destination);
+        try {
+          const connection = connectNativeAudioNodeToNativeAudioNode.connectNativeAudioNodeToNativeAudioNode(this._nativeAudioNode, nativeDestinationAudioNode, output, input);
+          const isPassive = isPassiveAudioNode.isPassiveAudioNode(this);
+          if (isOffline || isPassive) {
+            this._nativeAudioNode.disconnect(...connection);
+          }
+          if (this.context.state !== "closed" && !isPassive && isPassiveAudioNode.isPassiveAudioNode(destination)) {
+            setInternalStateToActive.setInternalStateToActive(destination);
+          }
+        } catch (err) {
+          if (err.code === 12) {
+            throw createInvalidAccessError();
+          }
+          throw err;
+        }
+        const isNewConnectionToAudioNode = addConnectionToAudioNode(this, destination, output, input, isOffline);
+        if (isNewConnectionToAudioNode) {
+          const cycles = detectCycles([this], destination);
+          visitEachAudioNodeOnce.visitEachAudioNodeOnce(cycles, createIncrementCycleCounter(isOffline));
+        }
+        return destination;
+      }
+      const nativeAudioParam = getNativeAudioParam.getNativeAudioParam(destination);
+      if (nativeAudioParam.name === "playbackRate" && nativeAudioParam.maxValue === 1024) {
+        throw createNotSupportedError();
+      }
+      try {
+        this._nativeAudioNode.connect(nativeAudioParam, output);
+        if (isOffline || isPassiveAudioNode.isPassiveAudioNode(this)) {
+          this._nativeAudioNode.disconnect(nativeAudioParam, output);
+        }
+      } catch (err) {
+        if (err.code === 12) {
+          throw createInvalidAccessError();
+        }
+        throw err;
+      }
+      const isNewConnectionToAudioParam = addConnectionToAudioParamOfAudioContext(this, destination, output, isOffline);
+      if (isNewConnectionToAudioParam) {
+        const cycles = detectCycles([this], destination);
+        visitEachAudioNodeOnce.visitEachAudioNodeOnce(cycles, createIncrementCycleCounter(isOffline));
+      }
+    }
+    disconnect(destinationOrOutput, output, input) {
+      let destinations;
+      const nativeContext = getNativeContext(this._context);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      if (destinationOrOutput === void 0) {
+        destinations = deleteAnyConnection(this, isOffline);
+      } else if (typeof destinationOrOutput === "number") {
+        if (destinationOrOutput < 0 || destinationOrOutput >= this.numberOfOutputs) {
+          throw createIndexSizeError();
+        }
+        destinations = deleteConnectionAtOutput(this, isOffline, destinationOrOutput);
+      } else {
+        if (output !== void 0 && (output < 0 || output >= this.numberOfOutputs)) {
+          throw createIndexSizeError();
+        }
+        if (audioNode.isAudioNode(destinationOrOutput) && input !== void 0 && (input < 0 || input >= destinationOrOutput.numberOfInputs)) {
+          throw createIndexSizeError();
+        }
+        destinations = deleteConnectionToDestination(this, isOffline, destinationOrOutput, output, input);
+        if (destinations.length === 0) {
+          throw createInvalidAccessError();
+        }
+      }
+      for (const destination of destinations) {
+        const cycles = detectCycles([this], destination);
+        visitEachAudioNodeOnce.visitEachAudioNodeOnce(cycles, decrementCycleCounter);
+      }
+    }
+  };
+};
+exports.createAudioNodeConstructor = createAudioNodeConstructor;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/audio-node-constructor.js

@@ -0,0 +1,274 @@
+import { AUDIO_NODE_STORE, EVENT_LISTENERS } from "../globals.js";
+import { isAudioNode } from "../guards/audio-node.js";
+import { isAudioNodeOutputConnection } from "../guards/audio-node-output-connection.js";
+import { addActiveInputConnectionToAudioParam } from "../helpers/add-active-input-connection-to-audio-param.js";
+import { addPassiveInputConnectionToAudioParam } from "../helpers/add-passive-input-connection-to-audio-param.js";
+import { connectNativeAudioNodeToNativeAudioNode } from "../helpers/connect-native-audio-node-to-native-audio-node.js";
+import { deleteActiveInputConnection } from "../helpers/delete-active-input-connection.js";
+import { deleteActiveInputConnectionToAudioParam } from "../helpers/delete-active-input-connection-to-audio-param.js";
+import { deleteEventListenerOfAudioNode } from "../helpers/delete-event-listeners-of-audio-node.js";
+import { deletePassiveInputConnectionToAudioNode } from "../helpers/delete-passive-input-connection-to-audio-node.js";
+import { deletePassiveInputConnectionToAudioParam } from "../helpers/delete-passive-input-connection-to-audio-param.js";
+import { disconnectNativeAudioNodeFromNativeAudioNode } from "../helpers/disconnect-native-audio-node-from-native-audio-node.js";
+import { getAudioNodeConnections } from "../helpers/get-audio-node-connections.js";
+import { getAudioParamConnections } from "../helpers/get-audio-param-connections.js";
+import { getEventListenersOfAudioNode } from "../helpers/get-event-listeners-of-audio-node.js";
+import { getNativeAudioNode } from "../helpers/get-native-audio-node.js";
+import { getNativeAudioParam } from "../helpers/get-native-audio-param.js";
+import { insertElementInSet } from "../helpers/insert-element-in-set.js";
+import { isActiveAudioNode } from "../helpers/is-active-audio-node.js";
+import { isPartOfACycle } from "../helpers/is-part-of-a-cycle.js";
+import { isPassiveAudioNode } from "../helpers/is-passive-audio-node.js";
+import { setInternalStateToActive } from "../helpers/set-internal-state-to-active.js";
+import { setInternalStateToPassiveWhenNecessary } from "../helpers/set-internal-state-to-passive-when-necessary.js";
+import { testAudioNodeDisconnectMethodSupport } from "../helpers/test-audio-node-disconnect-method-support.js";
+import { visitEachAudioNodeOnce } from "../helpers/visit-each-audio-node-once.js";
+import { wrapAudioNodeDisconnectMethod } from "../helpers/wrap-audio-node-disconnect-method.js";
+const addConnectionToAudioParamOfAudioContext = (source, destination, output, isOffline) => {
+  const { activeInputs, passiveInputs } = getAudioParamConnections(destination);
+  const { outputs } = getAudioNodeConnections(source);
+  const eventListeners = getEventListenersOfAudioNode(source);
+  const eventListener = (isActive) => {
+    const nativeAudioNode = getNativeAudioNode(source);
+    const nativeAudioParam = getNativeAudioParam(destination);
+    if (isActive) {
+      const partialConnection = deletePassiveInputConnectionToAudioParam(passiveInputs, source, output);
+      addActiveInputConnectionToAudioParam(activeInputs, source, partialConnection, false);
+      if (!isOffline && !isPartOfACycle(source)) {
+        nativeAudioNode.connect(nativeAudioParam, output);
+      }
+    } else {
+      const partialConnection = deleteActiveInputConnectionToAudioParam(activeInputs, source, output);
+      addPassiveInputConnectionToAudioParam(passiveInputs, partialConnection, false);
+      if (!isOffline && !isPartOfACycle(source)) {
+        nativeAudioNode.disconnect(nativeAudioParam, output);
+      }
+    }
+  };
+  if (insertElementInSet(outputs, [destination, output], (outputConnection) => outputConnection[0] === destination && outputConnection[1] === output, true)) {
+    eventListeners.add(eventListener);
+    if (isActiveAudioNode(source)) {
+      addActiveInputConnectionToAudioParam(activeInputs, source, [output, eventListener], true);
+    } else {
+      addPassiveInputConnectionToAudioParam(passiveInputs, [source, output, eventListener], true);
+    }
+    return true;
+  }
+  return false;
+};
+const deleteInputConnectionOfAudioNode = (source, destination, output, input) => {
+  const { activeInputs, passiveInputs } = getAudioNodeConnections(destination);
+  const activeInputConnection = deleteActiveInputConnection(activeInputs[input], source, output);
+  if (activeInputConnection === null) {
+    const passiveInputConnection = deletePassiveInputConnectionToAudioNode(passiveInputs, source, output, input);
+    return [passiveInputConnection[2], false];
+  }
+  return [activeInputConnection[2], true];
+};
+const deleteInputConnectionOfAudioParam = (source, destination, output) => {
+  const { activeInputs, passiveInputs } = getAudioParamConnections(destination);
+  const activeInputConnection = deleteActiveInputConnection(activeInputs, source, output);
+  if (activeInputConnection === null) {
+    const passiveInputConnection = deletePassiveInputConnectionToAudioParam(passiveInputs, source, output);
+    return [passiveInputConnection[1], false];
+  }
+  return [activeInputConnection[2], true];
+};
+const deleteInputsOfAudioNode = (source, isOffline, destination, output, input) => {
+  const [listener, isActive] = deleteInputConnectionOfAudioNode(source, destination, output, input);
+  if (listener !== null) {
+    deleteEventListenerOfAudioNode(source, listener);
+    if (isActive && !isOffline && !isPartOfACycle(source)) {
+      disconnectNativeAudioNodeFromNativeAudioNode(getNativeAudioNode(source), getNativeAudioNode(destination), output, input);
+    }
+  }
+  if (isActiveAudioNode(destination)) {
+    const { activeInputs } = getAudioNodeConnections(destination);
+    setInternalStateToPassiveWhenNecessary(destination, activeInputs);
+  }
+};
+const deleteInputsOfAudioParam = (source, isOffline, destination, output) => {
+  const [listener, isActive] = deleteInputConnectionOfAudioParam(source, destination, output);
+  if (listener !== null) {
+    deleteEventListenerOfAudioNode(source, listener);
+    if (isActive && !isOffline && !isPartOfACycle(source)) {
+      getNativeAudioNode(source).disconnect(getNativeAudioParam(destination), output);
+    }
+  }
+};
+const deleteAnyConnection = (source, isOffline) => {
+  const audioNodeConnectionsOfSource = getAudioNodeConnections(source);
+  const destinations = [];
+  for (const outputConnection of audioNodeConnectionsOfSource.outputs) {
+    if (isAudioNodeOutputConnection(outputConnection)) {
+      deleteInputsOfAudioNode(source, isOffline, ...outputConnection);
+    } else {
+      deleteInputsOfAudioParam(source, isOffline, ...outputConnection);
+    }
+    destinations.push(outputConnection[0]);
+  }
+  audioNodeConnectionsOfSource.outputs.clear();
+  return destinations;
+};
+const deleteConnectionAtOutput = (source, isOffline, output) => {
+  const audioNodeConnectionsOfSource = getAudioNodeConnections(source);
+  const destinations = [];
+  for (const outputConnection of audioNodeConnectionsOfSource.outputs) {
+    if (outputConnection[1] === output) {
+      if (isAudioNodeOutputConnection(outputConnection)) {
+        deleteInputsOfAudioNode(source, isOffline, ...outputConnection);
+      } else {
+        deleteInputsOfAudioParam(source, isOffline, ...outputConnection);
+      }
+      destinations.push(outputConnection[0]);
+      audioNodeConnectionsOfSource.outputs.delete(outputConnection);
+    }
+  }
+  return destinations;
+};
+const deleteConnectionToDestination = (source, isOffline, destination, output, input) => {
+  const audioNodeConnectionsOfSource = getAudioNodeConnections(source);
+  return Array.from(audioNodeConnectionsOfSource.outputs).filter((outputConnection) => outputConnection[0] === destination && (output === void 0 || outputConnection[1] === output) && (input === void 0 || outputConnection[2] === input)).map((outputConnection) => {
+    if (isAudioNodeOutputConnection(outputConnection)) {
+      deleteInputsOfAudioNode(source, isOffline, ...outputConnection);
+    } else {
+      deleteInputsOfAudioParam(source, isOffline, ...outputConnection);
+    }
+    audioNodeConnectionsOfSource.outputs.delete(outputConnection);
+    return outputConnection[0];
+  });
+};
+const createAudioNodeConstructor = (addAudioNodeConnections, addConnectionToAudioNode, cacheTestResult, createIncrementCycleCounter, createIndexSizeError, createInvalidAccessError, createNotSupportedError, decrementCycleCounter, detectCycles, eventTargetConstructor, getNativeContext, isNativeAudioContext, isNativeAudioNode, isNativeAudioParam, isNativeOfflineAudioContext, nativeAudioWorkletNodeConstructor) => {
+  return class AudioNode extends eventTargetConstructor {
+    constructor(context, isActive, nativeAudioNode, audioNodeRenderer) {
+      super(nativeAudioNode);
+      this._context = context;
+      this._nativeAudioNode = nativeAudioNode;
+      const nativeContext = getNativeContext(context);
+      if (isNativeAudioContext(nativeContext) && true !== cacheTestResult(testAudioNodeDisconnectMethodSupport, () => {
+        return testAudioNodeDisconnectMethodSupport(nativeContext, nativeAudioWorkletNodeConstructor);
+      })) {
+        wrapAudioNodeDisconnectMethod(nativeAudioNode);
+      }
+      AUDIO_NODE_STORE.set(this, nativeAudioNode);
+      EVENT_LISTENERS.set(this, /* @__PURE__ */ new Set());
+      if (context.state !== "closed" && isActive) {
+        setInternalStateToActive(this);
+      }
+      addAudioNodeConnections(this, audioNodeRenderer, nativeAudioNode);
+    }
+    get channelCount() {
+      return this._nativeAudioNode.channelCount;
+    }
+    set channelCount(value) {
+      this._nativeAudioNode.channelCount = value;
+    }
+    get channelCountMode() {
+      return this._nativeAudioNode.channelCountMode;
+    }
+    set channelCountMode(value) {
+      this._nativeAudioNode.channelCountMode = value;
+    }
+    get channelInterpretation() {
+      return this._nativeAudioNode.channelInterpretation;
+    }
+    set channelInterpretation(value) {
+      this._nativeAudioNode.channelInterpretation = value;
+    }
+    get context() {
+      return this._context;
+    }
+    get numberOfInputs() {
+      return this._nativeAudioNode.numberOfInputs;
+    }
+    get numberOfOutputs() {
+      return this._nativeAudioNode.numberOfOutputs;
+    }
+    // tslint:disable-next-line:invalid-void
+    connect(destination, output = 0, input = 0) {
+      if (output < 0 || output >= this._nativeAudioNode.numberOfOutputs) {
+        throw createIndexSizeError();
+      }
+      const nativeContext = getNativeContext(this._context);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      if (isNativeAudioNode(destination) || isNativeAudioParam(destination)) {
+        throw createInvalidAccessError();
+      }
+      if (isAudioNode(destination)) {
+        const nativeDestinationAudioNode = getNativeAudioNode(destination);
+        try {
+          const connection = connectNativeAudioNodeToNativeAudioNode(this._nativeAudioNode, nativeDestinationAudioNode, output, input);
+          const isPassive = isPassiveAudioNode(this);
+          if (isOffline || isPassive) {
+            this._nativeAudioNode.disconnect(...connection);
+          }
+          if (this.context.state !== "closed" && !isPassive && isPassiveAudioNode(destination)) {
+            setInternalStateToActive(destination);
+          }
+        } catch (err) {
+          if (err.code === 12) {
+            throw createInvalidAccessError();
+          }
+          throw err;
+        }
+        const isNewConnectionToAudioNode = addConnectionToAudioNode(this, destination, output, input, isOffline);
+        if (isNewConnectionToAudioNode) {
+          const cycles = detectCycles([this], destination);
+          visitEachAudioNodeOnce(cycles, createIncrementCycleCounter(isOffline));
+        }
+        return destination;
+      }
+      const nativeAudioParam = getNativeAudioParam(destination);
+      if (nativeAudioParam.name === "playbackRate" && nativeAudioParam.maxValue === 1024) {
+        throw createNotSupportedError();
+      }
+      try {
+        this._nativeAudioNode.connect(nativeAudioParam, output);
+        if (isOffline || isPassiveAudioNode(this)) {
+          this._nativeAudioNode.disconnect(nativeAudioParam, output);
+        }
+      } catch (err) {
+        if (err.code === 12) {
+          throw createInvalidAccessError();
+        }
+        throw err;
+      }
+      const isNewConnectionToAudioParam = addConnectionToAudioParamOfAudioContext(this, destination, output, isOffline);
+      if (isNewConnectionToAudioParam) {
+        const cycles = detectCycles([this], destination);
+        visitEachAudioNodeOnce(cycles, createIncrementCycleCounter(isOffline));
+      }
+    }
+    disconnect(destinationOrOutput, output, input) {
+      let destinations;
+      const nativeContext = getNativeContext(this._context);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      if (destinationOrOutput === void 0) {
+        destinations = deleteAnyConnection(this, isOffline);
+      } else if (typeof destinationOrOutput === "number") {
+        if (destinationOrOutput < 0 || destinationOrOutput >= this.numberOfOutputs) {
+          throw createIndexSizeError();
+        }
+        destinations = deleteConnectionAtOutput(this, isOffline, destinationOrOutput);
+      } else {
+        if (output !== void 0 && (output < 0 || output >= this.numberOfOutputs)) {
+          throw createIndexSizeError();
+        }
+        if (isAudioNode(destinationOrOutput) && input !== void 0 && (input < 0 || input >= destinationOrOutput.numberOfInputs)) {
+          throw createIndexSizeError();
+        }
+        destinations = deleteConnectionToDestination(this, isOffline, destinationOrOutput, output, input);
+        if (destinations.length === 0) {
+          throw createInvalidAccessError();
+        }
+      }
+      for (const destination of destinations) {
+        const cycles = detectCycles([this], destination);
+        visitEachAudioNodeOnce(cycles, decrementCycleCounter);
+      }
+    }
+  };
+};
+export {
+  createAudioNodeConstructor
+};