react-audio-wavekit 0.1.5 → 0.1.7

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

@@ -0,0 +1,139 @@
+import { computeBufferSize } from "../helpers/compute-buffer-size.js";
+import { filterBuffer } from "../helpers/filter-buffer.js";
+import { interceptConnections } from "../helpers/intercept-connections.js";
+function divide(a, b) {
+  const denominator = b[0] * b[0] + b[1] * b[1];
+  return [(a[0] * b[0] + a[1] * b[1]) / denominator, (a[1] * b[0] - a[0] * b[1]) / denominator];
+}
+function multiply(a, b) {
+  return [a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]];
+}
+function evaluatePolynomial(coefficient, z) {
+  let result = [0, 0];
+  for (let i = coefficient.length - 1; i >= 0; i -= 1) {
+    result = multiply(result, z);
+    result[0] += coefficient[i];
+  }
+  return result;
+}
+const createNativeIIRFilterNodeFakerFactory = (createInvalidAccessError, createInvalidStateError, createNativeScriptProcessorNode, createNotSupportedError) => {
+  return (nativeContext, baseLatency, { channelCount, channelCountMode, channelInterpretation, feedback, feedforward }) => {
+    const bufferSize = computeBufferSize(baseLatency, nativeContext.sampleRate);
+    const convertedFeedback = feedback instanceof Float64Array ? feedback : new Float64Array(feedback);
+    const convertedFeedforward = feedforward instanceof Float64Array ? feedforward : new Float64Array(feedforward);
+    const feedbackLength = convertedFeedback.length;
+    const feedforwardLength = convertedFeedforward.length;
+    const minLength = Math.min(feedbackLength, feedforwardLength);
+    if (feedbackLength === 0 || feedbackLength > 20) {
+      throw createNotSupportedError();
+    }
+    if (convertedFeedback[0] === 0) {
+      throw createInvalidStateError();
+    }
+    if (feedforwardLength === 0 || feedforwardLength > 20) {
+      throw createNotSupportedError();
+    }
+    if (convertedFeedforward[0] === 0) {
+      throw createInvalidStateError();
+    }
+    if (convertedFeedback[0] !== 1) {
+      for (let i = 0; i < feedforwardLength; i += 1) {
+        convertedFeedforward[i] /= convertedFeedback[0];
+      }
+      for (let i = 1; i < feedbackLength; i += 1) {
+        convertedFeedback[i] /= convertedFeedback[0];
+      }
+    }
+    const scriptProcessorNode = createNativeScriptProcessorNode(nativeContext, bufferSize, channelCount, channelCount);
+    scriptProcessorNode.channelCount = channelCount;
+    scriptProcessorNode.channelCountMode = channelCountMode;
+    scriptProcessorNode.channelInterpretation = channelInterpretation;
+    const bufferLength = 32;
+    const bufferIndexes = [];
+    const xBuffers = [];
+    const yBuffers = [];
+    for (let i = 0; i < channelCount; i += 1) {
+      bufferIndexes.push(0);
+      const xBuffer = new Float32Array(bufferLength);
+      const yBuffer = new Float32Array(bufferLength);
+      xBuffer.fill(0);
+      yBuffer.fill(0);
+      xBuffers.push(xBuffer);
+      yBuffers.push(yBuffer);
+    }
+    scriptProcessorNode.onaudioprocess = (event) => {
+      const inputBuffer = event.inputBuffer;
+      const outputBuffer = event.outputBuffer;
+      const numberOfChannels = inputBuffer.numberOfChannels;
+      for (let i = 0; i < numberOfChannels; i += 1) {
+        const input = inputBuffer.getChannelData(i);
+        const output = outputBuffer.getChannelData(i);
+        bufferIndexes[i] = filterBuffer(convertedFeedback, feedbackLength, convertedFeedforward, feedforwardLength, minLength, xBuffers[i], yBuffers[i], bufferIndexes[i], bufferLength, input, output);
+      }
+    };
+    const nyquist = nativeContext.sampleRate / 2;
+    const nativeIIRFilterNodeFaker = {
+      get bufferSize() {
+        return bufferSize;
+      },
+      get channelCount() {
+        return scriptProcessorNode.channelCount;
+      },
+      set channelCount(value) {
+        scriptProcessorNode.channelCount = value;
+      },
+      get channelCountMode() {
+        return scriptProcessorNode.channelCountMode;
+      },
+      set channelCountMode(value) {
+        scriptProcessorNode.channelCountMode = value;
+      },
+      get channelInterpretation() {
+        return scriptProcessorNode.channelInterpretation;
+      },
+      set channelInterpretation(value) {
+        scriptProcessorNode.channelInterpretation = value;
+      },
+      get context() {
+        return scriptProcessorNode.context;
+      },
+      get inputs() {
+        return [scriptProcessorNode];
+      },
+      get numberOfInputs() {
+        return scriptProcessorNode.numberOfInputs;
+      },
+      get numberOfOutputs() {
+        return scriptProcessorNode.numberOfOutputs;
+      },
+      addEventListener(...args) {
+        return scriptProcessorNode.addEventListener(args[0], args[1], args[2]);
+      },
+      dispatchEvent(...args) {
+        return scriptProcessorNode.dispatchEvent(args[0]);
+      },
+      getFrequencyResponse(frequencyHz, magResponse, phaseResponse) {
+        if (frequencyHz.length !== magResponse.length || magResponse.length !== phaseResponse.length) {
+          throw createInvalidAccessError();
+        }
+        const length = frequencyHz.length;
+        for (let i = 0; i < length; i += 1) {
+          const omega = -Math.PI * (frequencyHz[i] / nyquist);
+          const z = [Math.cos(omega), Math.sin(omega)];
+          const numerator = evaluatePolynomial(convertedFeedforward, z);
+          const denominator = evaluatePolynomial(convertedFeedback, z);
+          const response = divide(numerator, denominator);
+          magResponse[i] = Math.sqrt(response[0] * response[0] + response[1] * response[1]);
+          phaseResponse[i] = Math.atan2(response[1], response[0]);
+        }
+      },
+      removeEventListener(...args) {
+        return scriptProcessorNode.removeEventListener(args[0], args[1], args[2]);
+      }
+    };
+    return interceptConnections(nativeIIRFilterNodeFaker, scriptProcessorNode);
+  };
+};
+export {
+  createNativeIIRFilterNodeFakerFactory
+};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createNativeOfflineAudioContextConstructor = (window) => {
+  if (window === null) {
+    return null;
+  }
+  if (window.hasOwnProperty("OfflineAudioContext")) {
+    return window.OfflineAudioContext;
+  }
+  return window.hasOwnProperty("webkitOfflineAudioContext") ? window.webkitOfflineAudioContext : null;
+};
+exports.createNativeOfflineAudioContextConstructor = createNativeOfflineAudioContextConstructor;

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

@@ -0,0 +1,12 @@
+const createNativeOfflineAudioContextConstructor = (window) => {
+  if (window === null) {
+    return null;
+  }
+  if (window.hasOwnProperty("OfflineAudioContext")) {
+    return window.OfflineAudioContext;
+  }
+  return window.hasOwnProperty("webkitOfflineAudioContext") ? window.webkitOfflineAudioContext : null;
+};
+export {
+  createNativeOfflineAudioContextConstructor
+};

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeAudioParamValue = require("../helpers/assign-native-audio-node-audio-param-value.cjs");
+const assignNativeAudioNodeOption = require("../helpers/assign-native-audio-node-option.cjs");
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const wrapAudioScheduledSourceNodeStartMethodNegativeParameters = require("../helpers/wrap-audio-scheduled-source-node-start-method-negative-parameters.cjs");
+const wrapAudioScheduledSourceNodeStopMethodNegativeParameters = require("../helpers/wrap-audio-scheduled-source-node-stop-method-negative-parameters.cjs");
+const createNativeOscillatorNodeFactory = (addSilentConnection, cacheTestResult, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls) => {
+  return (nativeContext, options) => {
+    const nativeOscillatorNode = nativeContext.createOscillator();
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeOscillatorNode, options);
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeOscillatorNode, options, "detune");
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeOscillatorNode, options, "frequency");
+    if (options.periodicWave !== void 0) {
+      nativeOscillatorNode.setPeriodicWave(options.periodicWave);
+    } else {
+      assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeOscillatorNode, options, "type");
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStartMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStartMethodNegativeParameters.wrapAudioScheduledSourceNodeStartMethodNegativeParameters(nativeOscillatorNode);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, () => testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls(nativeOscillatorNode, nativeContext);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStopMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStopMethodNegativeParameters.wrapAudioScheduledSourceNodeStopMethodNegativeParameters(nativeOscillatorNode);
+    }
+    addSilentConnection(nativeContext, nativeOscillatorNode);
+    return nativeOscillatorNode;
+  };
+};
+exports.createNativeOscillatorNodeFactory = createNativeOscillatorNodeFactory;

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

@@ -0,0 +1,32 @@
+import { assignNativeAudioNodeAudioParamValue } from "../helpers/assign-native-audio-node-audio-param-value.js";
+import { assignNativeAudioNodeOption } from "../helpers/assign-native-audio-node-option.js";
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+import { wrapAudioScheduledSourceNodeStartMethodNegativeParameters } from "../helpers/wrap-audio-scheduled-source-node-start-method-negative-parameters.js";
+import { wrapAudioScheduledSourceNodeStopMethodNegativeParameters } from "../helpers/wrap-audio-scheduled-source-node-stop-method-negative-parameters.js";
+const createNativeOscillatorNodeFactory = (addSilentConnection, cacheTestResult, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls) => {
+  return (nativeContext, options) => {
+    const nativeOscillatorNode = nativeContext.createOscillator();
+    assignNativeAudioNodeOptions(nativeOscillatorNode, options);
+    assignNativeAudioNodeAudioParamValue(nativeOscillatorNode, options, "detune");
+    assignNativeAudioNodeAudioParamValue(nativeOscillatorNode, options, "frequency");
+    if (options.periodicWave !== void 0) {
+      nativeOscillatorNode.setPeriodicWave(options.periodicWave);
+    } else {
+      assignNativeAudioNodeOption(nativeOscillatorNode, options, "type");
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStartMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStartMethodNegativeParameters(nativeOscillatorNode);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, () => testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls(nativeOscillatorNode, nativeContext);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStopMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStopMethodNegativeParameters(nativeOscillatorNode);
+    }
+    addSilentConnection(nativeContext, nativeOscillatorNode);
+    return nativeOscillatorNode;
+  };
+};
+export {
+  createNativeOscillatorNodeFactory
+};

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeAudioParamValue = require("../helpers/assign-native-audio-node-audio-param-value.cjs");
+const assignNativeAudioNodeOption = require("../helpers/assign-native-audio-node-option.cjs");
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const createNativePannerNodeFactory = (createNativePannerNodeFaker) => {
+  return (nativeContext, options) => {
+    const nativePannerNode = nativeContext.createPanner();
+    if (nativePannerNode.orientationX === void 0) {
+      return createNativePannerNodeFaker(nativeContext, options);
+    }
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativePannerNode, options);
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "orientationX");
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "orientationY");
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "orientationZ");
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "positionX");
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "positionY");
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "positionZ");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativePannerNode, options, "coneInnerAngle");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativePannerNode, options, "coneOuterAngle");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativePannerNode, options, "coneOuterGain");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativePannerNode, options, "distanceModel");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativePannerNode, options, "maxDistance");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativePannerNode, options, "panningModel");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativePannerNode, options, "refDistance");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativePannerNode, options, "rolloffFactor");
+    return nativePannerNode;
+  };
+};
+exports.createNativePannerNodeFactory = createNativePannerNodeFactory;

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

@@ -0,0 +1,30 @@
+import { assignNativeAudioNodeAudioParamValue } from "../helpers/assign-native-audio-node-audio-param-value.js";
+import { assignNativeAudioNodeOption } from "../helpers/assign-native-audio-node-option.js";
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+const createNativePannerNodeFactory = (createNativePannerNodeFaker) => {
+  return (nativeContext, options) => {
+    const nativePannerNode = nativeContext.createPanner();
+    if (nativePannerNode.orientationX === void 0) {
+      return createNativePannerNodeFaker(nativeContext, options);
+    }
+    assignNativeAudioNodeOptions(nativePannerNode, options);
+    assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "orientationX");
+    assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "orientationY");
+    assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "orientationZ");
+    assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "positionX");
+    assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "positionY");
+    assignNativeAudioNodeAudioParamValue(nativePannerNode, options, "positionZ");
+    assignNativeAudioNodeOption(nativePannerNode, options, "coneInnerAngle");
+    assignNativeAudioNodeOption(nativePannerNode, options, "coneOuterAngle");
+    assignNativeAudioNodeOption(nativePannerNode, options, "coneOuterGain");
+    assignNativeAudioNodeOption(nativePannerNode, options, "distanceModel");
+    assignNativeAudioNodeOption(nativePannerNode, options, "maxDistance");
+    assignNativeAudioNodeOption(nativePannerNode, options, "panningModel");
+    assignNativeAudioNodeOption(nativePannerNode, options, "refDistance");
+    assignNativeAudioNodeOption(nativePannerNode, options, "rolloffFactor");
+    return nativePannerNode;
+  };
+};
+export {
+  createNativePannerNodeFactory
+};

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

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const interceptConnections = require("../helpers/intercept-connections.cjs");
+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.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.interceptConnections(nativePannerNodeFaker, pannerNode), whenConnected, whenDisconnected);
+  };
+};
+exports.createNativePannerNodeFakerFactory = createNativePannerNodeFakerFactory;