react-audio-wavekit 0.1.4 → 0.1.6

package/dist/node_modules/standardized-audio-context/build/es2019/factories/native-panner-node-faker-factory.js

@@ -0,0 +1,277 @@
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+import { interceptConnections } from "../helpers/intercept-connections.js";
+const createNativePannerNodeFakerFactory = (connectNativeAudioNodeToNativeAudioNode, createInvalidStateError, createNativeChannelMergerNode, createNativeGainNode, createNativeScriptProcessorNode, createNativeWaveShaperNode, createNotSupportedError, disconnectNativeAudioNodeFromNativeAudioNode, getFirstSample, monitorConnections) => {
+  return (nativeContext, { coneInnerAngle, coneOuterAngle, coneOuterGain, distanceModel, maxDistance, orientationX, orientationY, orientationZ, panningModel, positionX, positionY, positionZ, refDistance, rolloffFactor, ...audioNodeOptions }) => {
+    const pannerNode = nativeContext.createPanner();
+    if (audioNodeOptions.channelCount > 2) {
+      throw createNotSupportedError();
+    }
+    if (audioNodeOptions.channelCountMode === "max") {
+      throw createNotSupportedError();
+    }
+    assignNativeAudioNodeOptions(pannerNode, audioNodeOptions);
+    const SINGLE_CHANNEL_OPTIONS = {
+      channelCount: 1,
+      channelCountMode: "explicit",
+      channelInterpretation: "discrete"
+    };
+    const channelMergerNode = createNativeChannelMergerNode(nativeContext, {
+      ...SINGLE_CHANNEL_OPTIONS,
+      channelInterpretation: "speakers",
+      numberOfInputs: 6
+    });
+    const inputGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: 1 });
+    const orientationXGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 1 });
+    const orientationYGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });
+    const orientationZGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });
+    const positionXGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });
+    const positionYGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });
+    const positionZGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });
+    const scriptProcessorNode = createNativeScriptProcessorNode(nativeContext, 256, 6, 1);
+    const waveShaperNode = createNativeWaveShaperNode(nativeContext, {
+      ...SINGLE_CHANNEL_OPTIONS,
+      curve: new Float32Array([1, 1]),
+      oversample: "none"
+    });
+    let lastOrientation = [orientationX, orientationY, orientationZ];
+    let lastPosition = [positionX, positionY, positionZ];
+    const buffer = new Float32Array(1);
+    scriptProcessorNode.onaudioprocess = ({ inputBuffer }) => {
+      const orientation = [
+        getFirstSample(inputBuffer, buffer, 0),
+        getFirstSample(inputBuffer, buffer, 1),
+        getFirstSample(inputBuffer, buffer, 2)
+      ];
+      if (orientation.some((value, index) => value !== lastOrientation[index])) {
+        pannerNode.setOrientation(...orientation);
+        lastOrientation = orientation;
+      }
+      const positon = [
+        getFirstSample(inputBuffer, buffer, 3),
+        getFirstSample(inputBuffer, buffer, 4),
+        getFirstSample(inputBuffer, buffer, 5)
+      ];
+      if (positon.some((value, index) => value !== lastPosition[index])) {
+        pannerNode.setPosition(...positon);
+        lastPosition = positon;
+      }
+    };
+    Object.defineProperty(orientationYGainNode.gain, "defaultValue", { get: () => 0 });
+    Object.defineProperty(orientationZGainNode.gain, "defaultValue", { get: () => 0 });
+    Object.defineProperty(positionXGainNode.gain, "defaultValue", { get: () => 0 });
+    Object.defineProperty(positionYGainNode.gain, "defaultValue", { get: () => 0 });
+    Object.defineProperty(positionZGainNode.gain, "defaultValue", { get: () => 0 });
+    const nativePannerNodeFaker = {
+      get bufferSize() {
+        return void 0;
+      },
+      get channelCount() {
+        return pannerNode.channelCount;
+      },
+      set channelCount(value) {
+        if (value > 2) {
+          throw createNotSupportedError();
+        }
+        inputGainNode.channelCount = value;
+        pannerNode.channelCount = value;
+      },
+      get channelCountMode() {
+        return pannerNode.channelCountMode;
+      },
+      set channelCountMode(value) {
+        if (value === "max") {
+          throw createNotSupportedError();
+        }
+        inputGainNode.channelCountMode = value;
+        pannerNode.channelCountMode = value;
+      },
+      get channelInterpretation() {
+        return pannerNode.channelInterpretation;
+      },
+      set channelInterpretation(value) {
+        inputGainNode.channelInterpretation = value;
+        pannerNode.channelInterpretation = value;
+      },
+      get coneInnerAngle() {
+        return pannerNode.coneInnerAngle;
+      },
+      set coneInnerAngle(value) {
+        pannerNode.coneInnerAngle = value;
+      },
+      get coneOuterAngle() {
+        return pannerNode.coneOuterAngle;
+      },
+      set coneOuterAngle(value) {
+        pannerNode.coneOuterAngle = value;
+      },
+      get coneOuterGain() {
+        return pannerNode.coneOuterGain;
+      },
+      set coneOuterGain(value) {
+        if (value < 0 || value > 1) {
+          throw createInvalidStateError();
+        }
+        pannerNode.coneOuterGain = value;
+      },
+      get context() {
+        return pannerNode.context;
+      },
+      get distanceModel() {
+        return pannerNode.distanceModel;
+      },
+      set distanceModel(value) {
+        pannerNode.distanceModel = value;
+      },
+      get inputs() {
+        return [inputGainNode];
+      },
+      get maxDistance() {
+        return pannerNode.maxDistance;
+      },
+      set maxDistance(value) {
+        if (value < 0) {
+          throw new RangeError();
+        }
+        pannerNode.maxDistance = value;
+      },
+      get numberOfInputs() {
+        return pannerNode.numberOfInputs;
+      },
+      get numberOfOutputs() {
+        return pannerNode.numberOfOutputs;
+      },
+      get orientationX() {
+        return orientationXGainNode.gain;
+      },
+      get orientationY() {
+        return orientationYGainNode.gain;
+      },
+      get orientationZ() {
+        return orientationZGainNode.gain;
+      },
+      get panningModel() {
+        return pannerNode.panningModel;
+      },
+      set panningModel(value) {
+        pannerNode.panningModel = value;
+      },
+      get positionX() {
+        return positionXGainNode.gain;
+      },
+      get positionY() {
+        return positionYGainNode.gain;
+      },
+      get positionZ() {
+        return positionZGainNode.gain;
+      },
+      get refDistance() {
+        return pannerNode.refDistance;
+      },
+      set refDistance(value) {
+        if (value < 0) {
+          throw new RangeError();
+        }
+        pannerNode.refDistance = value;
+      },
+      get rolloffFactor() {
+        return pannerNode.rolloffFactor;
+      },
+      set rolloffFactor(value) {
+        if (value < 0) {
+          throw new RangeError();
+        }
+        pannerNode.rolloffFactor = value;
+      },
+      addEventListener(...args) {
+        return inputGainNode.addEventListener(args[0], args[1], args[2]);
+      },
+      dispatchEvent(...args) {
+        return inputGainNode.dispatchEvent(args[0]);
+      },
+      removeEventListener(...args) {
+        return inputGainNode.removeEventListener(args[0], args[1], args[2]);
+      }
+    };
+    if (coneInnerAngle !== nativePannerNodeFaker.coneInnerAngle) {
+      nativePannerNodeFaker.coneInnerAngle = coneInnerAngle;
+    }
+    if (coneOuterAngle !== nativePannerNodeFaker.coneOuterAngle) {
+      nativePannerNodeFaker.coneOuterAngle = coneOuterAngle;
+    }
+    if (coneOuterGain !== nativePannerNodeFaker.coneOuterGain) {
+      nativePannerNodeFaker.coneOuterGain = coneOuterGain;
+    }
+    if (distanceModel !== nativePannerNodeFaker.distanceModel) {
+      nativePannerNodeFaker.distanceModel = distanceModel;
+    }
+    if (maxDistance !== nativePannerNodeFaker.maxDistance) {
+      nativePannerNodeFaker.maxDistance = maxDistance;
+    }
+    if (orientationX !== nativePannerNodeFaker.orientationX.value) {
+      nativePannerNodeFaker.orientationX.value = orientationX;
+    }
+    if (orientationY !== nativePannerNodeFaker.orientationY.value) {
+      nativePannerNodeFaker.orientationY.value = orientationY;
+    }
+    if (orientationZ !== nativePannerNodeFaker.orientationZ.value) {
+      nativePannerNodeFaker.orientationZ.value = orientationZ;
+    }
+    if (panningModel !== nativePannerNodeFaker.panningModel) {
+      nativePannerNodeFaker.panningModel = panningModel;
+    }
+    if (positionX !== nativePannerNodeFaker.positionX.value) {
+      nativePannerNodeFaker.positionX.value = positionX;
+    }
+    if (positionY !== nativePannerNodeFaker.positionY.value) {
+      nativePannerNodeFaker.positionY.value = positionY;
+    }
+    if (positionZ !== nativePannerNodeFaker.positionZ.value) {
+      nativePannerNodeFaker.positionZ.value = positionZ;
+    }
+    if (refDistance !== nativePannerNodeFaker.refDistance) {
+      nativePannerNodeFaker.refDistance = refDistance;
+    }
+    if (rolloffFactor !== nativePannerNodeFaker.rolloffFactor) {
+      nativePannerNodeFaker.rolloffFactor = rolloffFactor;
+    }
+    if (lastOrientation[0] !== 1 || lastOrientation[1] !== 0 || lastOrientation[2] !== 0) {
+      pannerNode.setOrientation(...lastOrientation);
+    }
+    if (lastPosition[0] !== 0 || lastPosition[1] !== 0 || lastPosition[2] !== 0) {
+      pannerNode.setPosition(...lastPosition);
+    }
+    const whenConnected = () => {
+      inputGainNode.connect(pannerNode);
+      connectNativeAudioNodeToNativeAudioNode(inputGainNode, waveShaperNode, 0, 0);
+      waveShaperNode.connect(orientationXGainNode).connect(channelMergerNode, 0, 0);
+      waveShaperNode.connect(orientationYGainNode).connect(channelMergerNode, 0, 1);
+      waveShaperNode.connect(orientationZGainNode).connect(channelMergerNode, 0, 2);
+      waveShaperNode.connect(positionXGainNode).connect(channelMergerNode, 0, 3);
+      waveShaperNode.connect(positionYGainNode).connect(channelMergerNode, 0, 4);
+      waveShaperNode.connect(positionZGainNode).connect(channelMergerNode, 0, 5);
+      channelMergerNode.connect(scriptProcessorNode).connect(nativeContext.destination);
+    };
+    const whenDisconnected = () => {
+      inputGainNode.disconnect(pannerNode);
+      disconnectNativeAudioNodeFromNativeAudioNode(inputGainNode, waveShaperNode, 0, 0);
+      waveShaperNode.disconnect(orientationXGainNode);
+      orientationXGainNode.disconnect(channelMergerNode);
+      waveShaperNode.disconnect(orientationYGainNode);
+      orientationYGainNode.disconnect(channelMergerNode);
+      waveShaperNode.disconnect(orientationZGainNode);
+      orientationZGainNode.disconnect(channelMergerNode);
+      waveShaperNode.disconnect(positionXGainNode);
+      positionXGainNode.disconnect(channelMergerNode);
+      waveShaperNode.disconnect(positionYGainNode);
+      positionYGainNode.disconnect(channelMergerNode);
+      waveShaperNode.disconnect(positionZGainNode);
+      positionZGainNode.disconnect(channelMergerNode);
+      channelMergerNode.disconnect(scriptProcessorNode);
+      scriptProcessorNode.disconnect(nativeContext.destination);
+    };
+    return monitorConnections(interceptConnections(nativePannerNodeFaker, pannerNode), whenConnected, whenDisconnected);
+  };
+};
+export {
+  createNativePannerNodeFakerFactory
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/native-periodic-wave-factory.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createNativePeriodicWaveFactory = (createIndexSizeError) => {
+  return (nativeContext, { disableNormalization, imag, real }) => {
+    const convertedImag = imag instanceof Float32Array ? imag : new Float32Array(imag);
+    const convertedReal = real instanceof Float32Array ? real : new Float32Array(real);
+    const nativePeriodicWave = nativeContext.createPeriodicWave(convertedReal, convertedImag, { disableNormalization });
+    if (Array.from(imag).length < 2) {
+      throw createIndexSizeError();
+    }
+    return nativePeriodicWave;
+  };
+};
+exports.createNativePeriodicWaveFactory = createNativePeriodicWaveFactory;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/native-periodic-wave-factory.js

@@ -0,0 +1,14 @@
+const createNativePeriodicWaveFactory = (createIndexSizeError) => {
+  return (nativeContext, { disableNormalization, imag, real }) => {
+    const convertedImag = imag instanceof Float32Array ? imag : new Float32Array(imag);
+    const convertedReal = real instanceof Float32Array ? real : new Float32Array(real);
+    const nativePeriodicWave = nativeContext.createPeriodicWave(convertedReal, convertedImag, { disableNormalization });
+    if (Array.from(imag).length < 2) {
+      throw createIndexSizeError();
+    }
+    return nativePeriodicWave;
+  };
+};
+export {
+  createNativePeriodicWaveFactory
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/native-script-processor-node.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createNativeScriptProcessorNode = (nativeContext, bufferSize, numberOfInputChannels, numberOfOutputChannels) => {
+  return nativeContext.createScriptProcessor(bufferSize, numberOfInputChannels, numberOfOutputChannels);
+};
+exports.createNativeScriptProcessorNode = createNativeScriptProcessorNode;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/native-script-processor-node.js

@@ -0,0 +1,6 @@
+const createNativeScriptProcessorNode = (nativeContext, bufferSize, numberOfInputChannels, numberOfOutputChannels) => {
+  return nativeContext.createScriptProcessor(bufferSize, numberOfInputChannels, numberOfOutputChannels);
+};
+export {
+  createNativeScriptProcessorNode
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/native-stereo-panner-node-factory.cjs

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeAudioParamValue = require("../helpers/assign-native-audio-node-audio-param-value.cjs");
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const createNativeStereoPannerNodeFactory = (createNativeStereoPannerNodeFaker, createNotSupportedError) => {
+  return (nativeContext, options) => {
+    const channelCountMode = options.channelCountMode;
+    if (channelCountMode === "clamped-max") {
+      throw createNotSupportedError();
+    }
+    if (nativeContext.createStereoPanner === void 0) {
+      return createNativeStereoPannerNodeFaker(nativeContext, options);
+    }
+    const nativeStereoPannerNode = nativeContext.createStereoPanner();
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeStereoPannerNode, options);
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeStereoPannerNode, options, "pan");
+    Object.defineProperty(nativeStereoPannerNode, "channelCountMode", {
+      get: () => channelCountMode,
+      set: (value) => {
+        if (value !== channelCountMode) {
+          throw createNotSupportedError();
+        }
+      }
+    });
+    return nativeStereoPannerNode;
+  };
+};
+exports.createNativeStereoPannerNodeFactory = createNativeStereoPannerNodeFactory;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/native-stereo-panner-node-factory.js

@@ -0,0 +1,28 @@
+import { assignNativeAudioNodeAudioParamValue } from "../helpers/assign-native-audio-node-audio-param-value.js";
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+const createNativeStereoPannerNodeFactory = (createNativeStereoPannerNodeFaker, createNotSupportedError) => {
+  return (nativeContext, options) => {
+    const channelCountMode = options.channelCountMode;
+    if (channelCountMode === "clamped-max") {
+      throw createNotSupportedError();
+    }
+    if (nativeContext.createStereoPanner === void 0) {
+      return createNativeStereoPannerNodeFaker(nativeContext, options);
+    }
+    const nativeStereoPannerNode = nativeContext.createStereoPanner();
+    assignNativeAudioNodeOptions(nativeStereoPannerNode, options);
+    assignNativeAudioNodeAudioParamValue(nativeStereoPannerNode, options, "pan");
+    Object.defineProperty(nativeStereoPannerNode, "channelCountMode", {
+      get: () => channelCountMode,
+      set: (value) => {
+        if (value !== channelCountMode) {
+          throw createNotSupportedError();
+        }
+      }
+    });
+    return nativeStereoPannerNode;
+  };
+};
+export {
+  createNativeStereoPannerNodeFactory
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/native-stereo-panner-node-faker-factory.cjs

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interceptConnections = require("../helpers/intercept-connections.cjs");
+const createNativeStereoPannerNodeFakerFactory = (createNativeChannelMergerNode, createNativeChannelSplitterNode, createNativeGainNode, createNativeWaveShaperNode, createNotSupportedError, monitorConnections) => {
+  const CURVE_SIZE = 16385;
+  const DC_CURVE = new Float32Array([1, 1]);
+  const HALF_PI = Math.PI / 2;
+  const SINGLE_CHANNEL_OPTIONS = { channelCount: 1, channelCountMode: "explicit", channelInterpretation: "discrete" };
+  const SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS = { ...SINGLE_CHANNEL_OPTIONS, oversample: "none" };
+  const buildInternalGraphForMono = (nativeContext, inputGainNode, panGainNode, channelMergerNode) => {
+    const leftWaveShaperCurve = new Float32Array(CURVE_SIZE);
+    const rightWaveShaperCurve = new Float32Array(CURVE_SIZE);
+    for (let i = 0; i < CURVE_SIZE; i += 1) {
+      const x = i / (CURVE_SIZE - 1) * HALF_PI;
+      leftWaveShaperCurve[i] = Math.cos(x);
+      rightWaveShaperCurve[i] = Math.sin(x);
+    }
+    const leftGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });
+    const leftWaveShaperNode = createNativeWaveShaperNode(nativeContext, { ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS, curve: leftWaveShaperCurve });
+    const panWaveShaperNode = createNativeWaveShaperNode(nativeContext, { ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS, curve: DC_CURVE });
+    const rightGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });
+    const rightWaveShaperNode = createNativeWaveShaperNode(nativeContext, { ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS, curve: rightWaveShaperCurve });
+    return {
+      connectGraph() {
+        inputGainNode.connect(leftGainNode);
+        inputGainNode.connect(panWaveShaperNode.inputs === void 0 ? panWaveShaperNode : panWaveShaperNode.inputs[0]);
+        inputGainNode.connect(rightGainNode);
+        panWaveShaperNode.connect(panGainNode);
+        panGainNode.connect(leftWaveShaperNode.inputs === void 0 ? leftWaveShaperNode : leftWaveShaperNode.inputs[0]);
+        panGainNode.connect(rightWaveShaperNode.inputs === void 0 ? rightWaveShaperNode : rightWaveShaperNode.inputs[0]);
+        leftWaveShaperNode.connect(leftGainNode.gain);
+        rightWaveShaperNode.connect(rightGainNode.gain);
+        leftGainNode.connect(channelMergerNode, 0, 0);
+        rightGainNode.connect(channelMergerNode, 0, 1);
+      },
+      disconnectGraph() {
+        inputGainNode.disconnect(leftGainNode);
+        inputGainNode.disconnect(panWaveShaperNode.inputs === void 0 ? panWaveShaperNode : panWaveShaperNode.inputs[0]);
+        inputGainNode.disconnect(rightGainNode);
+        panWaveShaperNode.disconnect(panGainNode);
+        panGainNode.disconnect(leftWaveShaperNode.inputs === void 0 ? leftWaveShaperNode : leftWaveShaperNode.inputs[0]);
+        panGainNode.disconnect(rightWaveShaperNode.inputs === void 0 ? rightWaveShaperNode : rightWaveShaperNode.inputs[0]);
+        leftWaveShaperNode.disconnect(leftGainNode.gain);
+        rightWaveShaperNode.disconnect(rightGainNode.gain);
+        leftGainNode.disconnect(channelMergerNode, 0, 0);
+        rightGainNode.disconnect(channelMergerNode, 0, 1);
+      }
+    };
+  };
+  const buildInternalGraphForStereo = (nativeContext, inputGainNode, panGainNode, channelMergerNode) => {
+    const leftInputForLeftOutputWaveShaperCurve = new Float32Array(CURVE_SIZE);
+    const leftInputForRightOutputWaveShaperCurve = new Float32Array(CURVE_SIZE);
+    const rightInputForLeftOutputWaveShaperCurve = new Float32Array(CURVE_SIZE);
+    const rightInputForRightOutputWaveShaperCurve = new Float32Array(CURVE_SIZE);
+    const centerIndex = Math.floor(CURVE_SIZE / 2);
+    for (let i = 0; i < CURVE_SIZE; i += 1) {
+      if (i > centerIndex) {
+        const x = (i - centerIndex) / (CURVE_SIZE - 1 - centerIndex) * HALF_PI;
+        leftInputForLeftOutputWaveShaperCurve[i] = Math.cos(x);
+        leftInputForRightOutputWaveShaperCurve[i] = Math.sin(x);
+        rightInputForLeftOutputWaveShaperCurve[i] = 0;
+        rightInputForRightOutputWaveShaperCurve[i] = 1;
+      } else {
+        const x = i / (CURVE_SIZE - 1 - centerIndex) * HALF_PI;
+        leftInputForLeftOutputWaveShaperCurve[i] = 1;
+        leftInputForRightOutputWaveShaperCurve[i] = 0;
+        rightInputForLeftOutputWaveShaperCurve[i] = Math.cos(x);
+        rightInputForRightOutputWaveShaperCurve[i] = Math.sin(x);
+      }
+    }
+    const channelSplitterNode = createNativeChannelSplitterNode(nativeContext, {
+      channelCount: 2,
+      channelCountMode: "explicit",
+      channelInterpretation: "discrete",
+      numberOfOutputs: 2
+    });
+    const leftInputForLeftOutputGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });
+    const leftInputForLeftOutputWaveShaperNode = createNativeWaveShaperNode(nativeContext, {
+      ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS,
+      curve: leftInputForLeftOutputWaveShaperCurve
+    });
+    const leftInputForRightOutputGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });
+    const leftInputForRightOutputWaveShaperNode = createNativeWaveShaperNode(nativeContext, {
+      ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS,
+      curve: leftInputForRightOutputWaveShaperCurve
+    });
+    const panWaveShaperNode = createNativeWaveShaperNode(nativeContext, { ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS, curve: DC_CURVE });
+    const rightInputForLeftOutputGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });
+    const rightInputForLeftOutputWaveShaperNode = createNativeWaveShaperNode(nativeContext, {
+      ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS,
+      curve: rightInputForLeftOutputWaveShaperCurve
+    });
+    const rightInputForRightOutputGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });
+    const rightInputForRightOutputWaveShaperNode = createNativeWaveShaperNode(nativeContext, {
+      ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS,
+      curve: rightInputForRightOutputWaveShaperCurve
+    });
+    return {
+      connectGraph() {
+        inputGainNode.connect(channelSplitterNode);
+        inputGainNode.connect(panWaveShaperNode.inputs === void 0 ? panWaveShaperNode : panWaveShaperNode.inputs[0]);
+        channelSplitterNode.connect(leftInputForLeftOutputGainNode, 0);
+        channelSplitterNode.connect(leftInputForRightOutputGainNode, 0);
+        channelSplitterNode.connect(rightInputForLeftOutputGainNode, 1);
+        channelSplitterNode.connect(rightInputForRightOutputGainNode, 1);
+        panWaveShaperNode.connect(panGainNode);
+        panGainNode.connect(leftInputForLeftOutputWaveShaperNode.inputs === void 0 ? leftInputForLeftOutputWaveShaperNode : leftInputForLeftOutputWaveShaperNode.inputs[0]);
+        panGainNode.connect(leftInputForRightOutputWaveShaperNode.inputs === void 0 ? leftInputForRightOutputWaveShaperNode : leftInputForRightOutputWaveShaperNode.inputs[0]);
+        panGainNode.connect(rightInputForLeftOutputWaveShaperNode.inputs === void 0 ? rightInputForLeftOutputWaveShaperNode : rightInputForLeftOutputWaveShaperNode.inputs[0]);
+        panGainNode.connect(rightInputForRightOutputWaveShaperNode.inputs === void 0 ? rightInputForRightOutputWaveShaperNode : rightInputForRightOutputWaveShaperNode.inputs[0]);
+        leftInputForLeftOutputWaveShaperNode.connect(leftInputForLeftOutputGainNode.gain);
+        leftInputForRightOutputWaveShaperNode.connect(leftInputForRightOutputGainNode.gain);
+        rightInputForLeftOutputWaveShaperNode.connect(rightInputForLeftOutputGainNode.gain);
+        rightInputForRightOutputWaveShaperNode.connect(rightInputForRightOutputGainNode.gain);
+        leftInputForLeftOutputGainNode.connect(channelMergerNode, 0, 0);
+        rightInputForLeftOutputGainNode.connect(channelMergerNode, 0, 0);
+        leftInputForRightOutputGainNode.connect(channelMergerNode, 0, 1);
+        rightInputForRightOutputGainNode.connect(channelMergerNode, 0, 1);
+      },
+      disconnectGraph() {
+        inputGainNode.disconnect(channelSplitterNode);
+        inputGainNode.disconnect(panWaveShaperNode.inputs === void 0 ? panWaveShaperNode : panWaveShaperNode.inputs[0]);
+        channelSplitterNode.disconnect(leftInputForLeftOutputGainNode, 0);
+        channelSplitterNode.disconnect(leftInputForRightOutputGainNode, 0);
+        channelSplitterNode.disconnect(rightInputForLeftOutputGainNode, 1);
+        channelSplitterNode.disconnect(rightInputForRightOutputGainNode, 1);
+        panWaveShaperNode.disconnect(panGainNode);
+        panGainNode.disconnect(leftInputForLeftOutputWaveShaperNode.inputs === void 0 ? leftInputForLeftOutputWaveShaperNode : leftInputForLeftOutputWaveShaperNode.inputs[0]);
+        panGainNode.disconnect(leftInputForRightOutputWaveShaperNode.inputs === void 0 ? leftInputForRightOutputWaveShaperNode : leftInputForRightOutputWaveShaperNode.inputs[0]);
+        panGainNode.disconnect(rightInputForLeftOutputWaveShaperNode.inputs === void 0 ? rightInputForLeftOutputWaveShaperNode : rightInputForLeftOutputWaveShaperNode.inputs[0]);
+        panGainNode.disconnect(rightInputForRightOutputWaveShaperNode.inputs === void 0 ? rightInputForRightOutputWaveShaperNode : rightInputForRightOutputWaveShaperNode.inputs[0]);
+        leftInputForLeftOutputWaveShaperNode.disconnect(leftInputForLeftOutputGainNode.gain);
+        leftInputForRightOutputWaveShaperNode.disconnect(leftInputForRightOutputGainNode.gain);
+        rightInputForLeftOutputWaveShaperNode.disconnect(rightInputForLeftOutputGainNode.gain);
+        rightInputForRightOutputWaveShaperNode.disconnect(rightInputForRightOutputGainNode.gain);
+        leftInputForLeftOutputGainNode.disconnect(channelMergerNode, 0, 0);
+        rightInputForLeftOutputGainNode.disconnect(channelMergerNode, 0, 0);
+        leftInputForRightOutputGainNode.disconnect(channelMergerNode, 0, 1);
+        rightInputForRightOutputGainNode.disconnect(channelMergerNode, 0, 1);
+      }
+    };
+  };
+  const buildInternalGraph = (nativeContext, channelCount, inputGainNode, panGainNode, channelMergerNode) => {
+    if (channelCount === 1) {
+      return buildInternalGraphForMono(nativeContext, inputGainNode, panGainNode, channelMergerNode);
+    }
+    if (channelCount === 2) {
+      return buildInternalGraphForStereo(nativeContext, inputGainNode, panGainNode, channelMergerNode);
+    }
+    throw createNotSupportedError();
+  };
+  return (nativeContext, { channelCount, channelCountMode, pan, ...audioNodeOptions }) => {
+    if (channelCountMode === "max") {
+      throw createNotSupportedError();
+    }
+    const channelMergerNode = createNativeChannelMergerNode(nativeContext, {
+      ...audioNodeOptions,
+      channelCount: 1,
+      channelCountMode,
+      numberOfInputs: 2
+    });
+    const inputGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, channelCount, channelCountMode, gain: 1 });
+    const panGainNode = createNativeGainNode(nativeContext, {
+      channelCount: 1,
+      channelCountMode: "explicit",
+      channelInterpretation: "discrete",
+      gain: pan
+    });
+    let { connectGraph, disconnectGraph } = buildInternalGraph(nativeContext, channelCount, inputGainNode, panGainNode, channelMergerNode);
+    Object.defineProperty(panGainNode.gain, "defaultValue", { get: () => 0 });
+    Object.defineProperty(panGainNode.gain, "maxValue", { get: () => 1 });
+    Object.defineProperty(panGainNode.gain, "minValue", { get: () => -1 });
+    const nativeStereoPannerNodeFakerFactory = {
+      get bufferSize() {
+        return void 0;
+      },
+      get channelCount() {
+        return inputGainNode.channelCount;
+      },
+      set channelCount(value) {
+        if (inputGainNode.channelCount !== value) {
+          if (isConnected) {
+            disconnectGraph();
+          }
+          ({ connectGraph, disconnectGraph } = buildInternalGraph(nativeContext, value, inputGainNode, panGainNode, channelMergerNode));
+          if (isConnected) {
+            connectGraph();
+          }
+        }
+        inputGainNode.channelCount = value;
+      },
+      get channelCountMode() {
+        return inputGainNode.channelCountMode;
+      },
+      set channelCountMode(value) {
+        if (value === "clamped-max" || value === "max") {
+          throw createNotSupportedError();
+        }
+        inputGainNode.channelCountMode = value;
+      },
+      get channelInterpretation() {
+        return inputGainNode.channelInterpretation;
+      },
+      set channelInterpretation(value) {
+        inputGainNode.channelInterpretation = value;
+      },
+      get context() {
+        return inputGainNode.context;
+      },
+      get inputs() {
+        return [inputGainNode];
+      },
+      get numberOfInputs() {
+        return inputGainNode.numberOfInputs;
+      },
+      get numberOfOutputs() {
+        return inputGainNode.numberOfOutputs;
+      },
+      get pan() {
+        return panGainNode.gain;
+      },
+      addEventListener(...args) {
+        return inputGainNode.addEventListener(args[0], args[1], args[2]);
+      },
+      dispatchEvent(...args) {
+        return inputGainNode.dispatchEvent(args[0]);
+      },
+      removeEventListener(...args) {
+        return inputGainNode.removeEventListener(args[0], args[1], args[2]);
+      }
+    };
+    let isConnected = false;
+    const whenConnected = () => {
+      connectGraph();
+      isConnected = true;
+    };
+    const whenDisconnected = () => {
+      disconnectGraph();
+      isConnected = false;
+    };
+    return monitorConnections(interceptConnections.interceptConnections(nativeStereoPannerNodeFakerFactory, channelMergerNode), whenConnected, whenDisconnected);
+  };
+};
+exports.createNativeStereoPannerNodeFakerFactory = createNativeStereoPannerNodeFakerFactory;