react-audio-wavekit 0.1.5 → 0.1.7

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

@@ -0,0 +1,244 @@
+import { interceptConnections } from "../helpers/intercept-connections.js";
+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(nativeStereoPannerNodeFakerFactory, channelMergerNode), whenConnected, whenDisconnected);
+  };
+};
+export {
+  createNativeStereoPannerNodeFakerFactory
+};

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeOption = require("../helpers/assign-native-audio-node-option.cjs");
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const createNativeWaveShaperNodeFactory = (createConnectedNativeAudioBufferSourceNode, createInvalidStateError, createNativeWaveShaperNodeFaker, isDCCurve, monitorConnections, nativeAudioContextConstructor, overwriteAccessors) => {
+  return (nativeContext, options) => {
+    const nativeWaveShaperNode = nativeContext.createWaveShaper();
+    if (nativeAudioContextConstructor !== null && nativeAudioContextConstructor.name === "webkitAudioContext" && nativeContext.createGain().gain.automationRate === void 0) {
+      return createNativeWaveShaperNodeFaker(nativeContext, options);
+    }
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeWaveShaperNode, options);
+    const curve = options.curve === null || options.curve instanceof Float32Array ? options.curve : new Float32Array(options.curve);
+    if (curve !== null && curve.length < 2) {
+      throw createInvalidStateError();
+    }
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeWaveShaperNode, { curve }, "curve");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeWaveShaperNode, options, "oversample");
+    let disconnectNativeAudioBufferSourceNode = null;
+    let isConnected = false;
+    overwriteAccessors(nativeWaveShaperNode, "curve", (get) => () => get.call(nativeWaveShaperNode), (set) => (value) => {
+      set.call(nativeWaveShaperNode, value);
+      if (isConnected) {
+        if (isDCCurve(value) && disconnectNativeAudioBufferSourceNode === null) {
+          disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, nativeWaveShaperNode);
+        } else if (!isDCCurve(value) && disconnectNativeAudioBufferSourceNode !== null) {
+          disconnectNativeAudioBufferSourceNode();
+          disconnectNativeAudioBufferSourceNode = null;
+        }
+      }
+      return value;
+    });
+    const whenConnected = () => {
+      isConnected = true;
+      if (isDCCurve(nativeWaveShaperNode.curve)) {
+        disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, nativeWaveShaperNode);
+      }
+    };
+    const whenDisconnected = () => {
+      isConnected = false;
+      if (disconnectNativeAudioBufferSourceNode !== null) {
+        disconnectNativeAudioBufferSourceNode();
+        disconnectNativeAudioBufferSourceNode = null;
+      }
+    };
+    return monitorConnections(nativeWaveShaperNode, whenConnected, whenDisconnected);
+  };
+};
+exports.createNativeWaveShaperNodeFactory = createNativeWaveShaperNodeFactory;

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

@@ -0,0 +1,48 @@
+import { assignNativeAudioNodeOption } from "../helpers/assign-native-audio-node-option.js";
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+const createNativeWaveShaperNodeFactory = (createConnectedNativeAudioBufferSourceNode, createInvalidStateError, createNativeWaveShaperNodeFaker, isDCCurve, monitorConnections, nativeAudioContextConstructor, overwriteAccessors) => {
+  return (nativeContext, options) => {
+    const nativeWaveShaperNode = nativeContext.createWaveShaper();
+    if (nativeAudioContextConstructor !== null && nativeAudioContextConstructor.name === "webkitAudioContext" && nativeContext.createGain().gain.automationRate === void 0) {
+      return createNativeWaveShaperNodeFaker(nativeContext, options);
+    }
+    assignNativeAudioNodeOptions(nativeWaveShaperNode, options);
+    const curve = options.curve === null || options.curve instanceof Float32Array ? options.curve : new Float32Array(options.curve);
+    if (curve !== null && curve.length < 2) {
+      throw createInvalidStateError();
+    }
+    assignNativeAudioNodeOption(nativeWaveShaperNode, { curve }, "curve");
+    assignNativeAudioNodeOption(nativeWaveShaperNode, options, "oversample");
+    let disconnectNativeAudioBufferSourceNode = null;
+    let isConnected = false;
+    overwriteAccessors(nativeWaveShaperNode, "curve", (get) => () => get.call(nativeWaveShaperNode), (set) => (value) => {
+      set.call(nativeWaveShaperNode, value);
+      if (isConnected) {
+        if (isDCCurve(value) && disconnectNativeAudioBufferSourceNode === null) {
+          disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, nativeWaveShaperNode);
+        } else if (!isDCCurve(value) && disconnectNativeAudioBufferSourceNode !== null) {
+          disconnectNativeAudioBufferSourceNode();
+          disconnectNativeAudioBufferSourceNode = null;
+        }
+      }
+      return value;
+    });
+    const whenConnected = () => {
+      isConnected = true;
+      if (isDCCurve(nativeWaveShaperNode.curve)) {
+        disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, nativeWaveShaperNode);
+      }
+    };
+    const whenDisconnected = () => {
+      isConnected = false;
+      if (disconnectNativeAudioBufferSourceNode !== null) {
+        disconnectNativeAudioBufferSourceNode();
+        disconnectNativeAudioBufferSourceNode = null;
+      }
+    };
+    return monitorConnections(nativeWaveShaperNode, whenConnected, whenDisconnected);
+  };
+};
+export {
+  createNativeWaveShaperNodeFactory
+};

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

@@ -0,0 +1,153 @@
+"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 createNativeWaveShaperNodeFakerFactory = (createConnectedNativeAudioBufferSourceNode, createInvalidStateError, createNativeGainNode, isDCCurve, monitorConnections) => {
+  return (nativeContext, { curve, oversample, ...audioNodeOptions }) => {
+    const negativeWaveShaperNode = nativeContext.createWaveShaper();
+    const positiveWaveShaperNode = nativeContext.createWaveShaper();
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(negativeWaveShaperNode, audioNodeOptions);
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(positiveWaveShaperNode, audioNodeOptions);
+    const inputGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: 1 });
+    const invertGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: -1 });
+    const outputGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: 1 });
+    const revertGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: -1 });
+    let disconnectNativeAudioBufferSourceNode = null;
+    let isConnected = false;
+    let unmodifiedCurve = null;
+    const nativeWaveShaperNodeFaker = {
+      get bufferSize() {
+        return void 0;
+      },
+      get channelCount() {
+        return negativeWaveShaperNode.channelCount;
+      },
+      set channelCount(value) {
+        inputGainNode.channelCount = value;
+        invertGainNode.channelCount = value;
+        negativeWaveShaperNode.channelCount = value;
+        outputGainNode.channelCount = value;
+        positiveWaveShaperNode.channelCount = value;
+        revertGainNode.channelCount = value;
+      },
+      get channelCountMode() {
+        return negativeWaveShaperNode.channelCountMode;
+      },
+      set channelCountMode(value) {
+        inputGainNode.channelCountMode = value;
+        invertGainNode.channelCountMode = value;
+        negativeWaveShaperNode.channelCountMode = value;
+        outputGainNode.channelCountMode = value;
+        positiveWaveShaperNode.channelCountMode = value;
+        revertGainNode.channelCountMode = value;
+      },
+      get channelInterpretation() {
+        return negativeWaveShaperNode.channelInterpretation;
+      },
+      set channelInterpretation(value) {
+        inputGainNode.channelInterpretation = value;
+        invertGainNode.channelInterpretation = value;
+        negativeWaveShaperNode.channelInterpretation = value;
+        outputGainNode.channelInterpretation = value;
+        positiveWaveShaperNode.channelInterpretation = value;
+        revertGainNode.channelInterpretation = value;
+      },
+      get context() {
+        return negativeWaveShaperNode.context;
+      },
+      get curve() {
+        return unmodifiedCurve;
+      },
+      set curve(value) {
+        if (value !== null && value.length < 2) {
+          throw createInvalidStateError();
+        }
+        if (value === null) {
+          negativeWaveShaperNode.curve = value;
+          positiveWaveShaperNode.curve = value;
+        } else {
+          const curveLength = value.length;
+          const negativeCurve = new Float32Array(curveLength + 2 - curveLength % 2);
+          const positiveCurve = new Float32Array(curveLength + 2 - curveLength % 2);
+          negativeCurve[0] = value[0];
+          positiveCurve[0] = -value[curveLength - 1];
+          const length = Math.ceil((curveLength + 1) / 2);
+          const centerIndex = (curveLength + 1) / 2 - 1;
+          for (let i = 1; i < length; i += 1) {
+            const theoreticIndex = i / length * centerIndex;
+            const lowerIndex = Math.floor(theoreticIndex);
+            const upperIndex = Math.ceil(theoreticIndex);
+            negativeCurve[i] = lowerIndex === upperIndex ? value[lowerIndex] : (1 - (theoreticIndex - lowerIndex)) * value[lowerIndex] + (1 - (upperIndex - theoreticIndex)) * value[upperIndex];
+            positiveCurve[i] = lowerIndex === upperIndex ? -value[curveLength - 1 - lowerIndex] : -((1 - (theoreticIndex - lowerIndex)) * value[curveLength - 1 - lowerIndex]) - (1 - (upperIndex - theoreticIndex)) * value[curveLength - 1 - upperIndex];
+          }
+          negativeCurve[length] = curveLength % 2 === 1 ? value[length - 1] : (value[length - 2] + value[length - 1]) / 2;
+          negativeWaveShaperNode.curve = negativeCurve;
+          positiveWaveShaperNode.curve = positiveCurve;
+        }
+        unmodifiedCurve = value;
+        if (isConnected) {
+          if (isDCCurve(unmodifiedCurve) && disconnectNativeAudioBufferSourceNode === null) {
+            disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, inputGainNode);
+          } else if (disconnectNativeAudioBufferSourceNode !== null) {
+            disconnectNativeAudioBufferSourceNode();
+            disconnectNativeAudioBufferSourceNode = null;
+          }
+        }
+      },
+      get inputs() {
+        return [inputGainNode];
+      },
+      get numberOfInputs() {
+        return negativeWaveShaperNode.numberOfInputs;
+      },
+      get numberOfOutputs() {
+        return negativeWaveShaperNode.numberOfOutputs;
+      },
+      get oversample() {
+        return negativeWaveShaperNode.oversample;
+      },
+      set oversample(value) {
+        negativeWaveShaperNode.oversample = value;
+        positiveWaveShaperNode.oversample = 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 (curve !== null) {
+      nativeWaveShaperNodeFaker.curve = curve instanceof Float32Array ? curve : new Float32Array(curve);
+    }
+    if (oversample !== nativeWaveShaperNodeFaker.oversample) {
+      nativeWaveShaperNodeFaker.oversample = oversample;
+    }
+    const whenConnected = () => {
+      inputGainNode.connect(negativeWaveShaperNode).connect(outputGainNode);
+      inputGainNode.connect(invertGainNode).connect(positiveWaveShaperNode).connect(revertGainNode).connect(outputGainNode);
+      isConnected = true;
+      if (isDCCurve(unmodifiedCurve)) {
+        disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, inputGainNode);
+      }
+    };
+    const whenDisconnected = () => {
+      inputGainNode.disconnect(negativeWaveShaperNode);
+      negativeWaveShaperNode.disconnect(outputGainNode);
+      inputGainNode.disconnect(invertGainNode);
+      invertGainNode.disconnect(positiveWaveShaperNode);
+      positiveWaveShaperNode.disconnect(revertGainNode);
+      revertGainNode.disconnect(outputGainNode);
+      isConnected = false;
+      if (disconnectNativeAudioBufferSourceNode !== null) {
+        disconnectNativeAudioBufferSourceNode();
+        disconnectNativeAudioBufferSourceNode = null;
+      }
+    };
+    return monitorConnections(interceptConnections.interceptConnections(nativeWaveShaperNodeFaker, outputGainNode), whenConnected, whenDisconnected);
+  };
+};
+exports.createNativeWaveShaperNodeFakerFactory = createNativeWaveShaperNodeFakerFactory;

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

@@ -0,0 +1,153 @@
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+import { interceptConnections } from "../helpers/intercept-connections.js";
+const createNativeWaveShaperNodeFakerFactory = (createConnectedNativeAudioBufferSourceNode, createInvalidStateError, createNativeGainNode, isDCCurve, monitorConnections) => {
+  return (nativeContext, { curve, oversample, ...audioNodeOptions }) => {
+    const negativeWaveShaperNode = nativeContext.createWaveShaper();
+    const positiveWaveShaperNode = nativeContext.createWaveShaper();
+    assignNativeAudioNodeOptions(negativeWaveShaperNode, audioNodeOptions);
+    assignNativeAudioNodeOptions(positiveWaveShaperNode, audioNodeOptions);
+    const inputGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: 1 });
+    const invertGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: -1 });
+    const outputGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: 1 });
+    const revertGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: -1 });
+    let disconnectNativeAudioBufferSourceNode = null;
+    let isConnected = false;
+    let unmodifiedCurve = null;
+    const nativeWaveShaperNodeFaker = {
+      get bufferSize() {
+        return void 0;
+      },
+      get channelCount() {
+        return negativeWaveShaperNode.channelCount;
+      },
+      set channelCount(value) {
+        inputGainNode.channelCount = value;
+        invertGainNode.channelCount = value;
+        negativeWaveShaperNode.channelCount = value;
+        outputGainNode.channelCount = value;
+        positiveWaveShaperNode.channelCount = value;
+        revertGainNode.channelCount = value;
+      },
+      get channelCountMode() {
+        return negativeWaveShaperNode.channelCountMode;
+      },
+      set channelCountMode(value) {
+        inputGainNode.channelCountMode = value;
+        invertGainNode.channelCountMode = value;
+        negativeWaveShaperNode.channelCountMode = value;
+        outputGainNode.channelCountMode = value;
+        positiveWaveShaperNode.channelCountMode = value;
+        revertGainNode.channelCountMode = value;
+      },
+      get channelInterpretation() {
+        return negativeWaveShaperNode.channelInterpretation;
+      },
+      set channelInterpretation(value) {
+        inputGainNode.channelInterpretation = value;
+        invertGainNode.channelInterpretation = value;
+        negativeWaveShaperNode.channelInterpretation = value;
+        outputGainNode.channelInterpretation = value;
+        positiveWaveShaperNode.channelInterpretation = value;
+        revertGainNode.channelInterpretation = value;
+      },
+      get context() {
+        return negativeWaveShaperNode.context;
+      },
+      get curve() {
+        return unmodifiedCurve;
+      },
+      set curve(value) {
+        if (value !== null && value.length < 2) {
+          throw createInvalidStateError();
+        }
+        if (value === null) {
+          negativeWaveShaperNode.curve = value;
+          positiveWaveShaperNode.curve = value;
+        } else {
+          const curveLength = value.length;
+          const negativeCurve = new Float32Array(curveLength + 2 - curveLength % 2);
+          const positiveCurve = new Float32Array(curveLength + 2 - curveLength % 2);
+          negativeCurve[0] = value[0];
+          positiveCurve[0] = -value[curveLength - 1];
+          const length = Math.ceil((curveLength + 1) / 2);
+          const centerIndex = (curveLength + 1) / 2 - 1;
+          for (let i = 1; i < length; i += 1) {
+            const theoreticIndex = i / length * centerIndex;
+            const lowerIndex = Math.floor(theoreticIndex);
+            const upperIndex = Math.ceil(theoreticIndex);
+            negativeCurve[i] = lowerIndex === upperIndex ? value[lowerIndex] : (1 - (theoreticIndex - lowerIndex)) * value[lowerIndex] + (1 - (upperIndex - theoreticIndex)) * value[upperIndex];
+            positiveCurve[i] = lowerIndex === upperIndex ? -value[curveLength - 1 - lowerIndex] : -((1 - (theoreticIndex - lowerIndex)) * value[curveLength - 1 - lowerIndex]) - (1 - (upperIndex - theoreticIndex)) * value[curveLength - 1 - upperIndex];
+          }
+          negativeCurve[length] = curveLength % 2 === 1 ? value[length - 1] : (value[length - 2] + value[length - 1]) / 2;
+          negativeWaveShaperNode.curve = negativeCurve;
+          positiveWaveShaperNode.curve = positiveCurve;
+        }
+        unmodifiedCurve = value;
+        if (isConnected) {
+          if (isDCCurve(unmodifiedCurve) && disconnectNativeAudioBufferSourceNode === null) {
+            disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, inputGainNode);
+          } else if (disconnectNativeAudioBufferSourceNode !== null) {
+            disconnectNativeAudioBufferSourceNode();
+            disconnectNativeAudioBufferSourceNode = null;
+          }
+        }
+      },
+      get inputs() {
+        return [inputGainNode];
+      },
+      get numberOfInputs() {
+        return negativeWaveShaperNode.numberOfInputs;
+      },
+      get numberOfOutputs() {
+        return negativeWaveShaperNode.numberOfOutputs;
+      },
+      get oversample() {
+        return negativeWaveShaperNode.oversample;
+      },
+      set oversample(value) {
+        negativeWaveShaperNode.oversample = value;
+        positiveWaveShaperNode.oversample = 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 (curve !== null) {
+      nativeWaveShaperNodeFaker.curve = curve instanceof Float32Array ? curve : new Float32Array(curve);
+    }
+    if (oversample !== nativeWaveShaperNodeFaker.oversample) {
+      nativeWaveShaperNodeFaker.oversample = oversample;
+    }
+    const whenConnected = () => {
+      inputGainNode.connect(negativeWaveShaperNode).connect(outputGainNode);
+      inputGainNode.connect(invertGainNode).connect(positiveWaveShaperNode).connect(revertGainNode).connect(outputGainNode);
+      isConnected = true;
+      if (isDCCurve(unmodifiedCurve)) {
+        disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, inputGainNode);
+      }
+    };
+    const whenDisconnected = () => {
+      inputGainNode.disconnect(negativeWaveShaperNode);
+      negativeWaveShaperNode.disconnect(outputGainNode);
+      inputGainNode.disconnect(invertGainNode);
+      invertGainNode.disconnect(positiveWaveShaperNode);
+      positiveWaveShaperNode.disconnect(revertGainNode);
+      revertGainNode.disconnect(outputGainNode);
+      isConnected = false;
+      if (disconnectNativeAudioBufferSourceNode !== null) {
+        disconnectNativeAudioBufferSourceNode();
+        disconnectNativeAudioBufferSourceNode = null;
+      }
+    };
+    return monitorConnections(interceptConnections(nativeWaveShaperNodeFaker, outputGainNode), whenConnected, whenDisconnected);
+  };
+};
+export {
+  createNativeWaveShaperNodeFakerFactory
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/not-supported-error.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createNotSupportedError = () => new DOMException("", "NotSupportedError");
+exports.createNotSupportedError = createNotSupportedError;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/not-supported-error.js

@@ -0,0 +1,4 @@
+const createNotSupportedError = () => new DOMException("", "NotSupportedError");
+export {
+  createNotSupportedError
+};